HierarchicalGrid

UserPreferences

1. 개요
2. 기존 그리드의 문제점
1. 객체의 크기에 의한 문제
1. 객체가 셀에 비해 너무 큰 경우
2. 객체가 셀에 비해 너무 작은 경우
3. 객체의 크기가 가변적인 경우
2. 메모리 문제
3. 계층형 그리드 개요
4. 계층형 그리드 구현
1. HierarchicalGrid.h
2. HierarchicalGrid.cpp
5. 응용 분야 및 한계점

1 개요

일반적인 "타일" 방식의 단점을 개선한 계층형 데이터 구조. OcTree나 QuadTree와 상당히 비슷하지만, 트리 루트가 존재하지 않는다는 점이 틀리다. 루트 없이 레벨값을 통해 바로 해당 계층에 접근할 수 있기 때문에 트리에 비해서 빠르다고 할 수 있다.

2 기존 그리드의 문제점

2.1 객체의 크기에 의한 문제

2.1.1 객체가 셀에 비해 너무 큰 경우

셀이 너무 작은 경우 객체가 움직일 때마다 대량의 셀을 업데이트해야한다. 충돌 체크를 하는 경우에도 마찬가지다.




2.1.2 객체가 셀에 비해 너무 작은 경우

	셀이 너무 큰 경우, 하나의 셀에 많은 객체들이 들어가게 된다. 움직일 때마다 대량의 객체들과 충돌 테스트를 해야한다.
	실제로 충돌하는 객체가 없었음에도 불구하고, 5개의 객체들과의 충돌 테스트를 해야하는 경우이다.




2.1.3 객체의 크기가 가변적인 경우

셀 업데이트와 객체 간 충돌 테스트 둘 다 문제가 되는 경우이다.




2.2 메모리 문제

셀과 메모리 간의 매치에 있어서, 가장 간단하게 생각할 수 있는 것은 그냥 차원에 따라 배열을 잡고, 각각의 셀을 하나씩 1:1 대응시키는 방법이다. 하지만 이 방법은 어느 정도 "적당한" 크기의 셀을 사용하게 되면 거의 필연적으로 메모리 문제를 일으킨다. 어떻게 할당할 수 있겠다가 아니라 몇 기가바이트 수준이 나온다.

3 계층형 그리드 개요

5
4
3
2
1


계층형 그리드는 위와 같이 같은 영역을 커버하는 여러 계층의 그리드로 이루어진다.

빠른 삽입 및 삭제를 위해, 임의의 객체는 크기에 따라 자신을 완전히 수용할 수 있는 계층의 셀에만 삽입된다. 위에서도 언급했듯이 셀 크기가 너무 작으면, 객체가 움직일 때 너무 많은 업데이트가 필요하게 된다. 이를 방지하기 위해 가장 낮은 레벨의 셀 크기는 월드 안에 존재하는 가장 작은 객체의 크기보다는 커야 한다. 레벨이 올라갈 때마다 셀의 크기가 2배씩 커지는 것이 일반적이나, 반드시 그래야할 필요는 없다. 어쨌든 최고 레벨의 셀은 월드 안에 존재하는 가장 큰 크기의 객체보다 커야 한다.

이런 식으로 구조를 잡으면, 임의의 객체는 한 순간에 최대 4개의 셀에 걸쳐있게 된다. 잘 생각해 보면, 하나의 셀이 수용할 수 있는 객체의 크기는 셀 크기보다 작게 하는 것이 좋다는 것을 알 수 있다. 셀 크기와 딱 맞는 객체를 수용하게 되면, 객체는 대부분의 경우 4개의 셀에 걸쳐있게 되기 때문이다. 셀 크기의 절반 정도를, 수용할 수 있는 객체의 최대 크기로 잡는 것이 적당할 것 같다.

임의의 객체가 충돌을 일으키는지 검사하기 위해서는 모든 레벨을 돌면서 그 객체의 영역+1과 겹치는 셀들을 검사해야한다. 여기서 +1 영역이란 해당 레벨에서 객체의 영역과 겹치는 셀들을 뽑아낸 다음, 그것을 동서남북(2D의 경우)으로 1칸씩 확장한 영역을 말한다. 왜 확장이 필요하냐면, 확장된 영역 안에도 객체가 존재할 수 있기 때문이다. (객체는 최대 4개의 셀에 걸쳐있을 수 있다는 점을 생각해 보라.)

각각의 층을 모두 메모리에 할당하게 되면 위에서 언급한 단순한 그리드보다 훨씬 더 많은 메모리를 소모하게 되므로, 객체가 존재하는 셀들만 생성하고, 해쉬를 통해 이를 액세스한다.

4 계층형 그리드 구현

아래의 소스에서는 대충 다음과 같은 모양의 클래스들을 이용한다.


// 대충 이와 같은 모양의 클래스를 사용한다.
class cPoint3D
{
    float x, y, z;
};

class cObject
{
    cPoint3D  m_Position;
    float     m_Radius;
    size_t    m_GridLevel;
    DWORD     m_GridHash;
    cObject*  m_Prev;
    cObject*  m_Next;
};

어서트나 해쉬 함수 같은 건 알아서 바꿔줘야한다.



4.1 HierarchicalGrid.h

#ifndef __HIERARCHICALGRID_H__
#define __HIERARCHICALGRID_H__

#include "Object.h"

////////////////////////////////////////////////////////////////////////////////
/// \class cHierarchicalGrid
/// \brief 월드 상에 존재하는 객체들 간의 충돌 체크를 위한 그리드 클래스.
////////////////////////////////////////////////////////////////////////////////

class cHierarchicalGrid
{
public:
    typedef list<cObject*> OBJECT_LIST;


private:
    class cLevel;

    const size_t m_MaxLevel; ///< 최대 레벨
    cLevel**     m_Levels;   ///< 레벨별로 존재하는 객체들


public:
    /// \brief 생성자
    /// \param maxLevel 최대 레벨
    /// \param minCellSize 최하위 셀의 크기
    /// \param cellToCellRatio 레벨이 하나 올라갈 때마다 셀이 얼마나 커지는가?
    /// \param objectToCellRatio 셀에 들어갈 수 있는 오브젝트 크기 vs 셀 크기의 비율
    cHierarchicalGrid(size_t maxLevel=32, float minCellSize=1.0f, 
        float cellToCellRatio=2.0f, float objectToCellRatio=0.25f);

    /// \brief 소멸자
    virtual ~cHierarchicalGrid();


public:
    /// \brief 객체를 추가한다.
    /// \param object 추가할 객체
    /// \return bool 무사히 추가한 경우 true, 충돌이 일어난 경우 false
    bool AddObject(cObject* object);

    /// \brief 객체를 제거한다.
    /// \param object 제거할 객체
    /// \return bool 무사히 제거한 경우 true, 해당 객체가 존재하지 않는 경우 false
    bool RemoveObject(cObject* object);

    /// \brief 해당 객체와 충돌하는 객체가 있는지의 여부를 반환한다.
    /// \param object 충돌 체크를 수행할 객체
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
    bool CheckObject(cObject* object, float epsilon=0.0f) const;

    /// \brief 해당 지점에 충돌하는 객체가 있는지의 여부를 반환한다.
    /// \param position 충돌 체크를 수행할 지점
    /// \param radius 체크할 영역의 반지름
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
    bool CheckObject(const cPoint3D& position, float radius, float epsilon=0.0f) const;

    /// \brief 해당 영역 안에 있는 모든 객체들을 반환한다.
    /// \param position 중심점
    /// \param radius 반경
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \param objects 객체들이 들어갈 컬렉션
    void QueryObjects(const cPoint3D& position, float radius, float epsilon, 
        cHierarchicalGrid::OBJECT_LIST& objects);


private:
    /// 복사 생성 금지
    cHierarchicalGrid(const cHierarchicalGrid&) 
        : m_MaxLevel(0), m_Levels(NULL) {}

    /// 대입 금지
    cHierarchicalGrid& operator = (const cHierarchicalGrid&) { return *this; }
};

#endif





4.2 HierarchicalGrid.cpp

#include "HierarchicalGrid.h"
//#include "Hash.h"

namespace
{
    /// \brief 셀 상에서의 위치 해쉬값을 반환한다.
    /// \param pos 오브젝트의 실제 위치
    /// \param cellSize 셀의 크기
    /// \return DWORD 해쉬값
    DWORD GetCellPositionHash(const cPoint3D& pos, float cellSize)
    {
        int cell[3] = {
            (int)(pos.x / cellSize),
            (int)(pos.y / cellSize),
            (int)(pos.z / cellSize)
        };

        // 적당한 해쉬 함수를 이용하도록 한다.
        return cHash::GetPjwHash((const char*)&cell, sizeof(int)*3);
    }

    /// \brief 셀 상에서의 해쉬값을 반환한다.
    /// \param x 셀 좌표
    /// \param y 셀 좌표
    /// \param z 셀 좌표
    /// \return DWORD 해쉬값
    DWORD GetCellPositionHash(int x, int y, int z)
    {
        int cell[3] = { x, y, z };
        
        // 적당한 해쉬 함수를 이용하도록 한다.
        return cHash::GetPjwHash((const char*)&cell, sizeof(int)*3);
    }

    /// \brief 두 오브젝트가 충돌하는지의 여부를 반환한다.
    /// \param lhs 오브젝트
    /// \param rhs 오브젝트
    /// \param epsilon 오차 수정값
    /// \return bool 충돌하는 경우 true, 아니라면 false
    bool IsCollide(const cObject* lhs, const cObject* rhs, float epsilon)
    {
        const cPoint3D& from = lhs->GetPosition();
        const cPoint3D& to = rhs->GetPosition();

        float x = from.x - to.x;
        float y = from.y - to.y;
        float z = from.z - to.z;

        float dist = sqrt( x * x + y * y + z * z );
        return dist <= sqrt(lhs->GetRadius() + rhs->GetRadius() + epsilon);
    }

    /// \brief 해당 영역와 오브젝트가 충돌하는지의 여부를 반환한다.
    /// \param from 영역 중심점
    /// \param radius 영역 반지름
    /// \param target 오브젝트
    /// \param epsilon 오차 수정값
    /// \return bool 충돌하는 경우 true, 아니라면 false
    bool IsCollide(const cPoint3D& from, float radius, const cObject* target, float epsilon)
    {
        const cPoint3D& to = target->GetPosition();

        float x = from.x - to.x;
        float y = from.y - to.y;
        float z = from.z - to.z;

        float dist = sqrt( x * x + y * y + z * z );
        return dist <= sqrt(radius + target->GetRadius() + epsilon);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// \class cHierarchicalGrid::cLevel
/// \brief 하나의 레벨에 대한 객체
////////////////////////////////////////////////////////////////////////////////

class cHierarchicalGrid::cLevel
{
private:
    struct CELLREGION
    {
        int minX; int minY; int minZ;
        int maxX; int maxY; int maxZ;
    };

    typedef stdext::hash_map<DWORD, cObject*> OBJECTS;

    const size_t m_Level;          ///< 레벨
    const float  m_CellSize;       ///< 각각의 셀 크기
    const float  m_MaxObjectSize;  ///< 셀에 들어갈 수 있는 오브젝트의 최대 크기
    OBJECTS      m_Objects;        ///< 현재 레벨에 존재하는 오브젝트들


public:
    /// \brief 생성자
    /// \param level 레벨
    /// \param cellSize 셀 크기
    /// \param maxObjectSize 셀에 들어갈 수 있는 오브젝트의 최대 크기
    cLevel(size_t level, float cellSize, float maxObjectSize)
    : m_Level(level), m_CellSize(cellSize), m_MaxObjectSize(maxObjectSize)
    {
    }

    /// \brief 소멸자
    ~cLevel()
    {
        // 오브젝트는 다른 컬렉션에 포함되어 있을 것이므로 삭제하지 않는다.
    }


public:
    /// \brief 객체를 추가한다.
    /// \param object 추가할 객체
    void AddObject(cObject* object)
    {
        // 삭제를 위하여 레벨과 해쉬값 등을 기억해둔다.
        object->SetGridLevel(m_Level);
        object->SetGridHash(GetCellPositionHash(object->GetPosition(), m_CellSize));

        // 레벨에다 추가한다.
        OBJECTS::iterator itr(m_Objects.find(object->GetGridHash()));
        if (itr == m_Objects.end())
        {
            m_Objects.insert(OBJECTS::value_type(object->GetGridHash(), object));
        }
        else
        {
            cObject* prev = itr->second;
            object->SetPrev(prev);
            object->SetNext(prev->GetNext());
            prev->SetNext(object);
        }
    }

    /// \brief 객체를 제거한다.
    /// \param object 제거할 객체
    /// \return bool 무사히 제거한 경우 true, 해당 객체가 존재하지 않는 경우 false
    bool RemoveObject(cObject* object)
    {
        Assert(object->GetGridLevel() == m_Level);

        // 레벨에서 찾아본다.
        OBJECTS::iterator itr(m_Objects.find(object->GetGridHash()));
        if (itr == m_Objects.end())
        {
            Assert(false && "cannot find specified object");
            return false;
        }

        // 리스트 헤더라면...
        if ((itr->second) == object)
        {
            cObject* next = object->GetNext();
            if (next == NULL)
            {
                m_Objects.erase(itr);
            }
            else
            {
                itr->second = next;
            }
        }
        // 리스트 헤더가 아니라면...
        else
        {
            cObject* prev = object->GetPrev();
            if (prev != NULL)
                prev->SetNext(object->GetNext());

            cObject* next = object->GetNext();
            if (next != NULL)
                prev->SetPrev(object->GetPrev());
        }

        // 포인터 초기화해준다.
        object->SetPrev(NULL);
        object->SetNext(NULL);

        return true;
    }

    /// \brief 해당 객체와 충돌하는 객체가 있는지의 여부를 반환한다.
    /// \param object 충돌 체크를 수행할 객체
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
    bool CheckObject(cObject* object, float epsilon) const
    {
        const cPoint3D& from = object->GetPosition();

        // 체크해야할 셀의 범위를 계산한다.
        CELLREGION r;
        GetCellRegion(from, object->GetRadius(), epsilon, r);

        // 모든 셀을 검사한다.
        for (int x = r.minX; x <= r.maxX; x++) 
        {
            for (int y = r.minY; y <= r.maxY; y++) 
            {
                for (int z = r.minZ; z <= r.maxZ; z++) 
                {
                    DWORD hash = GetCellPositionHash(x, y, z);

                    // 셀에 아무 것도 없다면 패스.
                    OBJECTS::const_iterator itr(m_Objects.find(hash));
                    if (itr == m_Objects.end()) continue;

                    // 셀 안의 모든 오브젝트를 검사한다.
                    cObject* current = itr->second;
                    while (current != NULL)
                    {
                        if (current != object && IsCollide(object, current, epsilon))
                            return true;

                        current = current->GetNext();
                    }
                }
            }
        }

        return false;
    }

    /// \brief 해당 지점에 충돌하는 객체가 있는지의 여부를 반환한다.
    /// \param position 충돌 체크를 수행할 지점
    /// \param radius 체크할 영역의 반지름
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
    bool CheckObject(const cPoint3D& position, float radius, float epsilon) const
    {
        // 체크해야할 셀의 범위를 계산한다.
        CELLREGION r;
        GetCellRegion(position, radius, epsilon, r);

        // 모든 셀을 검사한다.
        for (int x = r.minX; x <= r.maxX; x++) 
        {
            for (int y = r.minY; y <= r.maxY; y++) 
            {
                for (int z = r.minZ; z <= r.maxZ; z++) 
                {
                    DWORD hash = GetCellPositionHash(x, y, z);

                    // 셀에 아무 것도 없다면 패스.
                    OBJECTS::const_iterator itr(m_Objects.find(hash));
                    if (itr == m_Objects.end()) continue;

                    // 셀 안의 모든 오브젝트를 검사한다.
                    cObject* current = itr->second;
                    while (current != NULL)
                    {
                        if (IsCollide(position, radius, current, epsilon))
                            return true;

                        current = current->GetNext();
                    }
                }
            }
        }

        return false;
    }

    /// \brief 해당 영역 안에 있는 모든 객체들을 반환한다.
    /// \param position 중심점
    /// \param radius 반경
    /// \param epsilon 충돌 체크시 사용할 오차허용값
    /// \param objects 객체들이 들어갈 컬렉션
    void QueryObjects(const cPoint3D& position, float radius, float epsilon, 
        cHierarchicalGrid::OBJECT_LIST& objects)
    {
        // 체크해야할 셀의 범위를 계산한다.
        CELLREGION r;
        GetCellRegion(position, radius, epsilon, r);

        // 모든 셀을 검사한다.
        for (int x = r.minX; x <= r.maxX; x++) 
        {
            for (int y = r.minY; y <= r.maxY; y++) 
            {
                for (int z = r.minZ; z <= r.maxZ; z++) 
                {
                    DWORD hash = GetCellPositionHash(x, y, z);

                    // 셀에 아무 것도 없다면 패스.
                    OBJECTS::const_iterator itr(m_Objects.find(hash));
                    if (itr == m_Objects.end()) continue;

                    // 셀 안의 모든 오브젝트를 검사한다.
                    cObject* current = itr->second;
                    while (current != NULL)
                    {
                        objects.push_back(current);
                        current = current->GetNext();
                    }
                }
            }
        }
    }


private:
    /// \brief 오브젝트의 좌표와 크기를 이용해 체크해야할 셀의 범위를 계산한다.
    /// \param from 중심점
    /// \param radius 반경
    /// \param epsilon 오차값
    /// \param region 체크해야할 영역
    void GetCellRegion(const cPoint3D& from, float radius, float epsilon, CELLREGION& region) const
    {
        float delta = radius + m_MaxObjectSize + epsilon;
        float ooSize = 1.0f / m_CellSize;
        region.minX = (int)floorf((from.x - delta) * ooSize);
        region.minY = (int)floorf((from.y - delta) * ooSize);
        region.minZ = (int)floorf((from.z - delta) * ooSize);
        region.maxX = (int)ceilf((from.x + delta) * ooSize);
        region.maxY = (int)ceilf((from.y + delta) * ooSize);
        region.maxZ = (int)ceilf((from.z + delta) * ooSize);
    }


public:
    /// \name Simple getter/setter
    /// \{ 
    size_t GetLevel() const { return m_Level; }
    float GetCellSize() const { return m_CellSize; }
    float GetMaxObjectSize() const { return m_MaxObjectSize; }
    bool IsEmpty() const { return m_Objects.empty(); }
    /// \} 
};

////////////////////////////////////////////////////////////////////////////////
/// \brief 생성자
/// \param maxLevel 최대 레벨
/// \param minCellSize 최하위 셀의 크기
/// \param cellToCellRatio 레벨이 하나 올라갈 때마다 셀이 얼마나 커지는가?
/// \param objectToCellRatio 셀에 들어갈 수 있는 오브젝트 크기 vs 셀 크기의 비율
////////////////////////////////////////////////////////////////////////////////
cHierarchicalGrid::cHierarchicalGrid(
    size_t maxLevel, float minCellSize, float cellToCellRatio, float objectToCellRatio)
: m_MaxLevel(maxLevel)
{
    Assert(maxLevel > 1);
    Assert(minCellSize > 0.0f);
    Assert(cellToCellRatio > 1.0f);
    Assert(objectToCellRatio <= 1.0f);

    m_Levels = new cLevel*[m_MaxLevel];
    AssertPtr(m_Levels);

    float cellSize = minCellSize;
    for (size_t level=0; level<m_MaxLevel; ++level, cellSize *= cellToCellRatio)
    {
        m_Levels[level] = new cLevel(level, cellSize, cellSize * objectToCellRatio);
        AssertPtr(m_Levels[level]);
    }
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 소멸자
////////////////////////////////////////////////////////////////////////////////
cHierarchicalGrid::~cHierarchicalGrid()
{
    for (size_t i=0; i<m_MaxLevel; ++i)
    {
        delete m_Levels[i];
    }

    delete [] m_Levels;
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 객체를 추가한다.
/// \param object 추가할 객체
/// \return bool 무사히 추가한 경우 true, 충돌이 일어난 경우 false
////////////////////////////////////////////////////////////////////////////////
bool cHierarchicalGrid::AddObject(cObject* object)
{
    AssertPtr(object);

    // 오브젝트의 지름을 구한다.
    float diameter = object->GetRadius() * 2.0f;

    // 오브젝트를 완전히 감쌀 수 있는 가장 낮은 레벨을 구한다.
    size_t level = 0;
    for (level = 0; level<m_MaxLevel; ++level)
    {
        if (diameter < m_Levels[level]->GetMaxObjectSize())
            break;
    }

    // 해당 오브젝트를 수용할 수 있는 레벨이 없다면 에러다.
    if (level < m_MaxLevel)
    {
        Assert(false && "cannot accommodate object");
        return false;
    }

    // 레벨에다 추가한다.
    m_Levels[level]->AddObject(object);

    return true;
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 객체를 제거한다.
/// \param object 제거할 객체
/// \return bool 무사히 제거한 경우 true, 해당 객체가 존재하지 않는 경우 false
////////////////////////////////////////////////////////////////////////////////
bool cHierarchicalGrid::RemoveObject(cObject* object)
{
    AssertPtr(object);
    Assert(object->GetGridLevel() < m_MaxLevel);

    // 레벨에서 삭제한다.
    return m_Levels[object->GetGridLevel()]->RemoveObject(object);
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 해당 객체와 충돌하는 객체가 있는지의 여부를 반환한다.
/// \param object 충돌 체크를 수행할 객체
/// \param epsilon 충돌 체크시 사용할 오차허용값
/// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
////////////////////////////////////////////////////////////////////////////////
bool cHierarchicalGrid::CheckObject(cObject* object, float epsilon) const
{
    AssertPtr(object);

    for (size_t level = 0; level < m_MaxLevel; level++) 
    {
        if (m_Levels[level]->IsEmpty())
            continue;

        if (m_Levels[level]->CheckObject(object, epsilon))
            return true;
    }

    return false;
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 해당 객체와 충돌하는 객체가 있는지의 여부를 반환한다.
/// \param position 충돌 체크를 수행할 지점
/// \param radius 체크할 영역의 반지름
/// \param epsilon 충돌 체크시 사용할 오차허용값
/// \return bool 충돌하는 객체가 하나라도 존재하는 경우 true, 없다면 false
////////////////////////////////////////////////////////////////////////////////
bool cHierarchicalGrid::CheckObject(const cPoint3D& position, float radius, float epsilon) const
{
    for (size_t level = 0; level < m_MaxLevel; level++) 
    {
        if (m_Levels[level]->IsEmpty())
            continue;

        if (m_Levels[level]->CheckObject(position, radius, epsilon))
            return true;
    }

    return false;
}

////////////////////////////////////////////////////////////////////////////////
/// \brief 해당 영역 안에 있는 모든 객체들을 반환한다.
/// \param position 중심점
/// \param radius 반경
/// \param epsilon 충돌 체크시 사용할 오차허용값
/// \param objects 객체들이 들어갈 컬렉션
/// \return size_t 컬렉션 안에 들어간 객체의 갯수
////////////////////////////////////////////////////////////////////////////////
void cHierarchicalGrid::QueryObjects(
    const cPoint3D& position, float radius, float epsilon, cHierarchicalGrid::OBJECT_LIST& objects)
{
    for (size_t level = 0; level < m_MaxLevel; level++) 
        m_Levels[level]->QueryObjects(position, radius, epsilon, objects);
}

5 응용 분야 및 한계점

일단 정적인 지형 정보 같은 것을 저장하기에는 알맞지 않다. 정적인 지형 정보는 상당히 양이 많고, 고르게 퍼져 있지도 않기 때문이다. MMORPG 게임 서버에서 움직이는 객체들을 추적하는 정도에는 어울릴 것 같다. 약간 응용을 하면 AreaOfInterestManagement에도 어떻게 이용할 수 있을 듯 한데...

• see also MultidimensionalAccessMethod
  

• CategoryAlgorithm