point_cloud.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
 
#ifndef EASY3D_CORE_POINT_CLOUD_H
#define EASY3D_CORE_POINT_CLOUD_H
 
#include <easy3d/core/model.h>
#include <easy3d/core/types.h>
#include <easy3d/core/property.h>
 
namespace easy3d {

    class PointCloud : public Model
    {
 
    public: //------------------------------------------------------ topology types

        class BaseHandle
        {
        public:
            explicit BaseHandle(int _idx=-1) : idx_(_idx) {}

            int idx() const { return idx_; }

            void reset() { idx_=-1; }

            bool is_valid() const { return idx_ != -1; }

            bool operator==(const BaseHandle& _rhs) const {
                return idx_ == _rhs.idx_;
            }

            bool operator!=(const BaseHandle& _rhs) const {
                return idx_ != _rhs.idx_;
            }

            bool operator<(const BaseHandle& _rhs) const {
                return idx_ < _rhs.idx_;
            }

            struct Hash {
                std::size_t operator()(const BaseHandle& h) const { return h.idx(); }
            };
 
        private:
            friend class PointCloud;
            int idx_;
        };
 

        struct Vertex : BaseHandle {
            explicit Vertex(int _idx=-1) : BaseHandle(_idx) {}
            std::ostream& operator<<(std::ostream& os) const { return os << 'v' << idx(); }
        };
 
 
    public: //------------------------------------------------------ property types

        template <class T> class VertexProperty : public Property<T>
        {
        public:
            VertexProperty() = default;
            explicit VertexProperty(Property<T> p) : Property<T>(p) {}

            typename Property<T>::reference operator[](Vertex v)
            {
                return Property<T>::operator[](v.idx());
            }

            typename Property<T>::const_reference operator[](Vertex v) const
            {
                return Property<T>::operator[](v.idx());
            }
        };
 

        template <class T> class ModelProperty : public Property<T>
        {
        public:
            ModelProperty() = default;
            explicit ModelProperty(Property<T> p) : Property<T>(p) {}

            typename Property<T>::reference operator[](size_t idx) override {
                return Property<T>::operator[](idx);
            }

            typename Property<T>::const_reference operator[](size_t idx) const override {
                return Property<T>::operator[](idx);
            }
        };
 
 
 
    public: //------------------------------------------------------ iterator types

        class VertexIterator
        {
        public:
            explicit VertexIterator(Vertex v=Vertex(), const PointCloud* m=nullptr) : hnd_(v), cloud_(m)
            {
                if (cloud_ && cloud_->has_garbage()) while (cloud_->is_valid(hnd_) && cloud_->is_deleted(hnd_)) ++hnd_.idx_;
            }

            Vertex operator*()  const { return  hnd_; }

            bool operator==(const VertexIterator& rhs) const
            {
                return (hnd_==rhs.hnd_);
            }

            bool operator!=(const VertexIterator& rhs) const
            {
                return !operator==(rhs);
            }

            VertexIterator& operator++()
            {
                ++hnd_.idx_;
                assert(cloud_);
                while (cloud_->has_garbage() && cloud_->is_valid(hnd_) && cloud_->is_deleted(hnd_)) ++hnd_.idx_;
                return *this;
            }

            VertexIterator& operator--()
            {
                --hnd_.idx_;
                assert(cloud_);
                while (cloud_->has_garbage() && cloud_->is_valid(hnd_) && cloud_->is_deleted(hnd_)) --hnd_.idx_;
                return *this;
            }
 
        private:
            Vertex  hnd_;
            const PointCloud* cloud_;
        };
 
 
    public: //-------------------------- containers for C++11 range-based for loops

        class VertexContainer
        {
        public:
            VertexContainer(VertexIterator _begin, VertexIterator _end) : begin_(_begin), end_(_end) {}
            VertexIterator begin() const { return begin_; }
            VertexIterator end()   const { return end_;   }
        private:
            VertexIterator begin_, end_;
        };
 
 
    public: //-------------------------------------------- constructor / destructor



        PointCloud();

        ~PointCloud() override = default;

        PointCloud(const PointCloud& rhs) { operator=(rhs); }

        PointCloud& operator=(const PointCloud& rhs);

        PointCloud& operator+=(const PointCloud& other) { join(other); return *this; }

        PointCloud& join(const PointCloud& other);

        PointCloud& assign(const PointCloud& rhs);

 
 
    public: //----------------------------------------------- add new vertex



        Vertex add_vertex(const vec3& p);

 
 
    public: //--------------------------------------------------- memory management



        unsigned int vertices_size() const { return static_cast<unsigned int>(vprops_.size()); }

        unsigned int n_vertices() const { return vertices_size() - deleted_vertices_; }

        void clear();

        void resize(unsigned int nv) { vprops_.resize(nv); }

        bool has_garbage() const { return garbage_; }

        void collect_garbage();

        void delete_vertex(Vertex v);

        bool is_deleted(Vertex v) const {
            return vdeleted_[v];
        }

        bool is_valid(Vertex v) const {
            return (0 <= v.idx()) && (v.idx() < static_cast<int>(vertices_size()));
        }

 
    public: //--------------------------------------------------- property handling



        template <class T> VertexProperty<T> add_vertex_property(const std::string& name, const T t=T()) {
            return VertexProperty<T>(vprops_.add<T>(name, t));
        }

        template <class T> ModelProperty<T> add_model_property(const std::string& name, const T t = T()) {
            return ModelProperty<T>(mprops_.add<T>(name, t));
        }

        template <class T> VertexProperty<T> get_vertex_property(const std::string& name) const {
            return VertexProperty<T>(vprops_.get<T>(name));
        }

        template <class T> ModelProperty<T> get_model_property(const std::string& name) const {
            return ModelProperty<T>(mprops_.get<T>(name));
        }

        template <class T> VertexProperty<T> vertex_property(const std::string& name, const T t=T()) {
            return VertexProperty<T>(vprops_.get_or_add<T>(name, t));
        }

        template <class T> ModelProperty<T> model_property(const std::string& name, const T t = T()) {
            return ModelProperty<T>(mprops_.get_or_add<T>(name, t));
        }

        template<class T>
        bool remove_vertex_property(VertexProperty<T> &p) { return vprops_.remove(p); }

        bool remove_vertex_property(const std::string &n) { return vprops_.remove(n); }

        template<class T>
        bool remove_model_property(ModelProperty<T> &p) { return mprops_.remove(p); }

        bool remove_model_property(const std::string &n) { return mprops_.remove(n); }

        bool rename_vertex_property(const std::string &old_name, const std::string &new_name) {
            return vprops_.rename(old_name, new_name);
        }

        bool rename_model_property(const std::string &old_name, const std::string &new_name) {
            return mprops_.rename(old_name, new_name);
        }

        const std::type_info& get_vertex_property_type(const std::string& name) const {
            return vprops_.get_type(name);
        }

        const std::type_info& get_model_property_type(const std::string& name) const {
            return mprops_.get_type(name);
        }

        std::vector<std::string> vertex_properties() const {
            return vprops_.properties();
        }

        std::vector<std::string> model_properties() const {
            return mprops_.properties();
        }

        void property_stats(std::ostream &output) const override;

 
 
    public: //--------------------------------------------- iterators



        VertexIterator vertices_begin() const {
            return VertexIterator(Vertex(0), this);
        }

        VertexIterator vertices_end() const {
            return VertexIterator(Vertex(static_cast<int>(vertices_size())), this);
        }

        VertexContainer vertices() const {
            return {vertices_begin(), vertices_end()};
        }

 
    public: //------------------------------------------ geometry-related functions



        const vec3& position(Vertex v) const { return vpoint_[v]; }

        vec3& position(Vertex v) { return vpoint_[v]; }

        const std::vector<vec3>& points() const override { return vpoint_.vector(); }

        std::vector<vec3>& points() override { return vpoint_.vector(); }

 
    private: //---------------------------------------------- allocate new elements

        Vertex new_vertex()
        {
            vprops_.push_back();
            return Vertex(static_cast<int>(vertices_size()-1));
        }
 
 
    private: //------------------------------------------------------- private data
 
        PropertyContainer       vprops_;
        PropertyContainer       mprops_;
 
        VertexProperty<bool>    vdeleted_;
        VertexProperty<vec3>    vpoint_;
 
        unsigned int    deleted_vertices_;
        bool            garbage_;
    };
 
 
    //------------------------------------------------------------ output operators

    inline std::ostream& operator<<(std::ostream& os, PointCloud::Vertex v) {
        return (os << 'v' << v.idx());
    }
 
} // namespace easy3d
 
#endif // EASY3D_CORE_POINT_CLOUD_H