DgmOctreeReferenceCloud.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
 
// Local
#include "DgmOctree.h"
#include "GenericIndexedCloudPersist.h"
 
namespace cloudViewer {
 
class CV_CORE_LIB_API DgmOctreeReferenceCloud
    : public GenericIndexedCloudPersist {
public:
 
    DgmOctreeReferenceCloud(DgmOctree::NeighboursSet* associatedSet,
                            unsigned count = 0);
 
    //**** inherited form GenericCloud ****//
    inline unsigned size() const override { return m_size; }
    void forEach(genericPointAction action) override;
    void getBoundingBox(CCVector3& bbMin, CCVector3& bbMax) override;
    // virtual unsigned char testVisibility(const CCVector3& P) const; //not
    // supported
    inline void placeIteratorAtBeginning() override { m_globalIterator = 0; }
    inline const CCVector3* getNextPoint() override {
        return (m_globalIterator < size() ? m_set->at(m_globalIterator++).point
                                          : nullptr);
    }
    inline bool enableScalarField() override {
        return true;
    }  // use DgmOctree::PointDescriptor::squareDistd by default
    inline bool isScalarFieldEnabled() const override {
        return true;
    }  // use DgmOctree::PointDescriptor::squareDistd by default
    inline void setPointScalarValue(unsigned pointIndex,
                                    ScalarType value) override {
        assert(pointIndex < size());
        m_set->at(pointIndex).squareDistd = static_cast<double>(value);
    }
    inline ScalarType getPointScalarValue(unsigned pointIndex) const override {
        assert(pointIndex < size());
        return static_cast<ScalarType>(m_set->at(pointIndex).squareDistd);
    }
    //**** inherited form GenericIndexedCloud ****//
    inline const CCVector3* getPoint(unsigned index) const override {
        assert(index < size());
        return m_set->at(index).point;
    }
    inline void getPoint(unsigned index, CCVector3& P) const override {
        assert(index < size());
        P = *m_set->at(index).point;
    }
    inline void getPoint(unsigned index, double P[3]) const override {
        assert(index < size());
        P[0] = m_set->at(index).point->x;
        P[1] = m_set->at(index).point->y;
        P[2] = m_set->at(index).point->z;
    }
    //**** inherited form GenericIndexedCloudPersist ****//
    inline const CCVector3* getPointPersistentPtr(unsigned index) override {
        assert(index < size());
        return m_set->at(index).point;
    }
 
    inline void forwardIterator() { ++m_globalIterator; }
 
protected:
    virtual void computeBB();
 
    unsigned m_globalIterator;
 
    CCVector3 m_bbMin;
    CCVector3 m_bbMax;
    bool m_validBB;
 
    DgmOctree::NeighboursSet* m_set;
 
    unsigned m_size;
};
 
}  // namespace cloudViewer