ReferenceCloud.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 "BoundingBox.h"
#include "GenericIndexedCloudPersist.h"
 
// System
#include <atomic>
#include <cassert>
#include <mutex>
#include <vector>
 
namespace cloudViewer {
 
 
class CV_CORE_LIB_API ReferenceCloud : public GenericIndexedCloudPersist {
public:
    explicit ReferenceCloud(GenericIndexedCloudPersist* associatedCloud);
 
    ReferenceCloud(const ReferenceCloud& refCloud);
 
    ~ReferenceCloud() override = default;
 
    //**** inherited form GenericCloud ****//
    inline unsigned size() const override {
        return static_cast<unsigned>(m_theIndexes.size());
    }
    void forEach(genericPointAction action) override;
    void getBoundingBox(CCVector3& bbMin, CCVector3& bbMax) override;
    inline unsigned char testVisibility(const CCVector3& P) const override {
        assert(m_theAssociatedCloud);
        return m_theAssociatedCloud->testVisibility(P);
    }
    inline void placeIteratorAtBeginning() override { m_globalIterator = 0; }
    inline const CCVector3* getNextPoint() override {
        assert(m_theAssociatedCloud);
        return (m_globalIterator < size()
                        ? m_theAssociatedCloud->getPoint(
                                  m_theIndexes[m_globalIterator++])
                        : nullptr);
    }
    inline bool enableScalarField() override {
        assert(m_theAssociatedCloud);
        return m_theAssociatedCloud->enableScalarField();
    }
    inline bool isScalarFieldEnabled() const override {
        assert(m_theAssociatedCloud);
        return m_theAssociatedCloud->isScalarFieldEnabled();
    }
    inline void setPointScalarValue(unsigned pointIndex,
                                    ScalarType value) override {
        assert(m_theAssociatedCloud && pointIndex < size());
        m_theAssociatedCloud->setPointScalarValue(m_theIndexes[pointIndex],
                                                  value);
    }
    inline ScalarType getPointScalarValue(unsigned pointIndex) const override {
        assert(m_theAssociatedCloud && pointIndex < size());
        return m_theAssociatedCloud->getPointScalarValue(
                m_theIndexes[pointIndex]);
    }
 
    //**** inherited form GenericIndexedCloud ****//
    inline const CCVector3* getPoint(unsigned index) const override {
        assert(m_theAssociatedCloud && index < size());
        return m_theAssociatedCloud->getPoint(m_theIndexes[index]);
    }
    inline void getPoint(unsigned index, CCVector3& P) const override {
        assert(m_theAssociatedCloud && index < size());
        m_theAssociatedCloud->getPoint(m_theIndexes[index], P);
    }
    inline void getPoint(unsigned index, double P[3]) const override {
        assert(m_theAssociatedCloud && index < size());
        m_theAssociatedCloud->getPoint(m_theIndexes[index], P);
    }
 
    //**** inherited form GenericIndexedCloudPersist ****//
    inline const CCVector3* getPointPersistentPtr(unsigned index) override {
        assert(m_theAssociatedCloud && index < size());
        return m_theAssociatedCloud->getPointPersistentPtr(m_theIndexes[index]);
    }
 
 
    inline virtual unsigned getPointGlobalIndex(unsigned localIndex) const {
        return m_theIndexes[localIndex];
    }
 
 
    virtual const CCVector3* getCurrentPointCoordinates() const;
 
    inline virtual unsigned getCurrentPointGlobalIndex() const {
        assert(m_globalIterator < size());
        return m_theIndexes[m_globalIterator];
    }
 
    inline virtual ScalarType getCurrentPointScalarValue() const {
        assert(m_theAssociatedCloud && m_globalIterator < size());
        return m_theAssociatedCloud->getPointScalarValue(
                m_theIndexes[m_globalIterator]);
    }
 
    inline virtual void setCurrentPointScalarValue(ScalarType value) {
        assert(m_theAssociatedCloud && m_globalIterator < size());
        m_theAssociatedCloud->setPointScalarValue(
                m_theIndexes[m_globalIterator], value);
    }
 
    inline virtual void forwardIterator() { ++m_globalIterator; }
 
 
    virtual void clear(bool releaseMemory = false);
 
 
    virtual bool addPointIndex(unsigned globalIndex);
 
 
    virtual bool addPointIndex(unsigned firstIndex, unsigned lastIndex);
 
 
    virtual void setPointIndex(unsigned localIndex, unsigned globalIndex);
 
 
    virtual bool reserve(unsigned n);
 
 
    virtual bool resize(unsigned n);
 
    inline virtual unsigned capacity() const {
        return static_cast<unsigned>(m_theIndexes.capacity());
    }
 
 
    inline virtual void swap(unsigned i, unsigned j) {
        m_mutex.lock();
        std::swap(m_theIndexes[i], m_theIndexes[j]);
        m_mutex.unlock();
    }
 
 
    inline virtual void removeCurrentPointGlobalIndex() {
        removePointGlobalIndex(m_globalIterator);
    }
 
 
    virtual void removePointGlobalIndex(unsigned localIndex);
 
    inline virtual GenericIndexedCloudPersist* getAssociatedCloud() {
        return m_theAssociatedCloud;
    }
 
    inline virtual const GenericIndexedCloudPersist* getAssociatedCloud()
            const {
        return m_theAssociatedCloud;
    }
 
    virtual void setAssociatedCloud(GenericIndexedCloudPersist* cloud);
 
 
    bool add(const ReferenceCloud& cloud);
 
    inline void invalidateBoundingBox() { m_bbox.setValidity(false); }
 
protected:
    using ReferencesContainer = std::vector<unsigned int>;
 
    ReferencesContainer m_theIndexes;
 
    std::atomic<unsigned> m_globalIterator;
 
    BoundingBox m_bbox;
 
 
    GenericIndexedCloudPersist* m_theAssociatedCloud;
 
    std::mutex m_mutex;
};
 
}  // namespace cloudViewer