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 virtual 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 : public 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)
            {
                return Property<T>::operator[](idx);
            }
 
            typename Property<T>::const_reference operator[](size_t idx) const
            {
                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 (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() < (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 VertexContainer(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