ecvPointCloudLOD.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// CV_DB_LIB
#include "ecvFrustum.h"
#include "ecvOctree.h"
 
// Qt
#include <QMutex>
 
// system
#include <stdint.h>
 
#include <array>
#include <functional>
 
class ccPointCloud;
class ccPointCloudLODThread;
 
struct LODLevelDesc {
    LODLevelDesc() : startIndex(0), count(0) {}
    LODLevelDesc(unsigned _startIndex, unsigned _count)
        : startIndex(_startIndex), count(_count) {}
    unsigned startIndex;
    unsigned count;
};
 
typedef std::vector<unsigned> LODIndexSet;
 
class ccPointCloudLOD {
public:
    enum State { NOT_INITIALIZED, UNDER_CONSTRUCTION, INITIALIZED, BROKEN };
 
    ccPointCloudLOD();
    virtual ~ccPointCloudLOD();
 
    bool init(ccPointCloud* cloud);
 
    inline void lock() { m_mutex.lock(); }
    inline void unlock() { m_mutex.unlock(); }
 
    inline State getState() {
        lock();
        State state = m_state;
        unlock();
        return state;
    }
 
    void clear();
 
    const ccOctree::Shared& octree() const { return m_octree; }
 
    inline bool isNull() { return getState() == NOT_INITIALIZED; }
 
    inline bool isInitialized() { return getState() == INITIALIZED; }
 
    inline bool isUnderConstruction() {
        return getState() == UNDER_CONSTRUCTION;
    }
 
    inline bool isBroken() { return getState() == BROKEN; }
 
    inline unsigned char maxLevel() {
        QMutexLocker locker(&m_mutex);
        return (m_state == INITIALIZED
                        ? static_cast<unsigned char>(
                                  std::max<size_t>(1, m_levels.size())) -
                                  1
                        : 0);
    }
 
    static const unsigned char UNDEFINED = 255;
 
    struct Node {
        // Warning: put the non aligned members (< 4 bytes) at the end to avoid
        // too much alignment padding!
        uint32_t pointCount;                  //  4 bytes
        float radius;                         //  4 bytes
        CCVector3f center;                    // 12 bytes
        std::array<int32_t, 8> childIndexes;  // 32 bytes
        uint32_t firstCodeIndex;              //  4 bytes
        uint32_t displayedPointCount;         //  4 bytes
        uint8_t level;                        //  1 byte
        uint8_t childCount;                   //  1 byte
        uint8_t intersection;                 //  1 byte
 
        // Total
        // // 63 bytes (64 with alignment)
 
        Node(uint8_t _level = 0)
            : pointCount(0),
              radius(0),
              center(0, 0, 0),
              firstCodeIndex(0),
              displayedPointCount(0),
              level(_level),
              childCount(0),
              intersection(UNDEFINED) {
            childIndexes.fill(-1);
        }
    };
 
    inline Node& node(int32_t index, unsigned char level) {
        assert(level < m_levels.size() && index >= 0 &&
               index < m_levels[level].data.size());
        return m_levels[level].data[index];
    }
 
    inline const Node& node(int32_t index, unsigned char level) const {
        assert(level < m_levels.size() && index >= 0 &&
               index < m_levels[level].data.size());
        return m_levels[level].data[index];
    }
 
    inline Node& root() { return node(0, 0); }
 
    inline const Node& root() const { return node(0, 0); }
 
    // inline float maxRadius(unsigned char level) const
    //{
    //  assert(level < m_levels.size());
    //  return (level < m_levels.size() ? m_levels[level].maxRadius : 0);
    // }
 
 
    uint32_t flagVisibility(const Frustum& frustum,
                            ccClipPlaneSet* clipPlanes = 0);
 
    LODIndexSet& getIndexMap(unsigned char level,
                             unsigned& maxCount,
                             unsigned& remainingPointsAtThisLevel);
 
    inline const LODIndexSet& getLasIndexMap() const { return m_lastIndexMap; }
 
    inline bool allDisplayed() const {
        return m_currentState.displayedPoints >= m_currentState.visiblePoints;
    }
 
    size_t memory() const;
 
protected:  // methods
    friend ccPointCloudLODThread;
 
    bool initInternal(ccOctree::Shared octree);
 
    inline void setState(State state) {
        lock();
        m_state = state;
        unlock();
    }
 
    void clearExtended(bool autoStopThread, State newState);
 
    void clearData();
 
 
    int32_t newCell(unsigned char level);
 
    void shrink_to_fit();
 
    // void updateMaxRadii();
 
 
    void resetVisibility();
 
    uint32_t addNPointsToIndexMap(Node& node, uint32_t count);
 
protected:  // members
    struct Level {
        Level()
        //: maxRadius(0)
        {}
 
        std::vector<Node> data;
        // float maxRadius;
    };
 
    std::vector<Level> m_levels;
 
    struct RenderParams {
        RenderParams()
            : visiblePoints(0),
              displayedPoints(0),
              unfinishedLevel(-1),
              unfinishedPoints(0) {}
 
        uint32_t visiblePoints;
        uint32_t displayedPoints;
        int unfinishedLevel;
        unsigned unfinishedPoints;
    };
 
    RenderParams m_currentState;
 
    LODIndexSet m_indexMap;
 
    LODIndexSet m_lastIndexMap;
 
    ccOctree::Shared m_octree;
 
    ccPointCloudLODThread* m_thread;
 
    QMutex m_mutex;
 
    State m_state;
};
 
class PointCloudLODRenderer {
public:
    typedef std::function<void(const ccPointCloudLOD::Node&)> RenderFunc;
 
    PointCloudLODRenderer(ccPointCloudLOD& lod,
                          RenderFunc& func,
                          const Frustum& frustum,
                          unsigned char maxLevel)
        : m_func(func), m_frustum(frustum), m_lod(lod), m_maxLevel(maxLevel) {}
 
    void render(const ccPointCloudLOD::Node& node, bool testVisibility) {
        if (testVisibility) {
            switch (m_frustum.sphereInFrustum(node.center, node.radius)) {
                case Frustum::INSIDE:
                    testVisibility = false;
                    break;
 
                case Frustum::INTERSECT:
                    testVisibility = true;
                    break;
 
                case Frustum::OUTSIDE:
                    return;
            }
        }
 
        // go on with the display of the children first
        if (node.childCount && node.level < m_maxLevel) {
            for (int i = 0; i < 8; ++i) {
                if (node.childIndexes[i] >= 0) {
                    const ccPointCloudLOD::Node& childNode =
                            m_lod.node(node.childIndexes[i], node.level + 1);
                    render(childNode, testVisibility);
                }
            }
        } else {
            m_func(node);
        }
    }
 
    RenderFunc m_func;
    const Frustum& m_frustum;
    ccPointCloudLOD& m_lod;
    unsigned char m_maxLevel;
};