OctreeNode.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_DATASTRUCTURES_OCTREENODE_H
#define SURGSIM_DATASTRUCTURES_OCTREENODE_H

#include <array>
#include <memory>
#include <functional>

#include "SurgSim/DataStructures/EmptyData.h"
#include "SurgSim/Framework/Asset.h"
#include "SurgSim/Math/Vector.h"
#include "SurgSim/Math/Aabb.h"


namespace SurgSim
{

namespace Math
{
class OctreeShape;
}

namespace DataStructures
{

typedef std::vector<size_t> OctreePath;

class OctreePathHash
{
public:
    size_t operator()(const OctreePath& path) const
    {
        size_t result = 0;
        for (auto i : path)
        {
            result = (result << 3) | i;
        }

        return m_hasher(result);
    }
private:
    std::hash<size_t> m_hasher;
};

enum Neighborhood
{
    NEIGHBORHOOD_NONE = 0x0,
    NEIGHBORHOOD_FACE = 0x1,
    NEIGHBORHOOD_EDGE = 0x2,
    NEIGHBORHOOD_VERTEX  = 0x4,
    NEIGHBORHOOD_ALL = 0x1 | 0x2 | 0x4
};

enum Symbol
{
    SYMBOL_HALT = -1,
    SYMBOL_DOWN = 0,
    SYMBOL_UP = 1,
    SYMBOL_RIGHT = 2,
    SYMBOL_LEFT = 3,
    SYMBOL_BACK = 4,
    SYMBOL_FRONT = 5
};

OctreePath getNeighbor(const OctreePath& origin, const std::array<Symbol, 3>& direction);

std::vector<OctreePath> getNeighbors(const OctreePath& origin, int type);

template <typename Data>
class OctreeNodePlyReaderDelegate;

template<class Data>
class OctreeNode : public SurgSim::Framework::Asset,
    public std::enable_shared_from_this<OctreeNode<Data>>
{
    friend class SurgSim::Math::OctreeShape;
    friend class SurgSim::DataStructures::OctreeNodePlyReaderDelegate<Data>;

public:

    typedef Eigen::AlignedBox<double, 3> AxisAlignedBoundingBox;

    OctreeNode();

    OctreeNode(const OctreeNode& other);

    template <class T>
    OctreeNode(const OctreeNode<T>& other);

    std::string getClassName() const override;

    explicit OctreeNode(const SurgSim::Math::Aabbd& boundingBox);

    virtual ~OctreeNode();

    const SurgSim::Math::Aabbd& getBoundingBox() const;

    bool isActive() const;

    void setIsActive(bool isActive);

    bool hasChildren() const;

    void subdivide();

    bool addData(const SurgSim::Math::Vector3d& position, const int level, const Data& nodeData = Data());

    std::array<std::shared_ptr<OctreeNode<Data>>, 8>& getChildren();

    const std::array<std::shared_ptr<OctreeNode<Data>>, 8>& getChildren() const;

    std::shared_ptr<OctreeNode<Data>> getChild(size_t index);

    const std::shared_ptr<OctreeNode<Data>> getChild(size_t index) const;

    //                         the last node on a given path, otherwise it will throw.
    virtual std::shared_ptr<OctreeNode<Data>> getNode(const OctreePath& path, bool returnLastValid = false);

    Data data;

protected:
    bool doAddData(const SurgSim::Math::Vector3d& position, const Data& nodeData, const int level,
                   const int currentLevel);

    bool doLoad(const std::string& filePath) override;

    SurgSim::Math::Aabbd m_boundingBox;

    bool m_isActive;

    bool m_hasChildren;

    std::array<std::shared_ptr<OctreeNode<Data>>, 8> m_children;

private:
    static std::string m_className;
};

};  // namespace DataStructures
};  // namespace SurgSim

#include "SurgSim/DataStructures/OctreeNode-inl.h"

#endif // SURGSIM_DATASTRUCTURES_OCTREENODE_H