class mrpt::maps::CPointsMapXYZIRT

Overview

Deserialization-only compatibility stub for the old CPointsMapXYZIRT class.

This class carries no functionality of its own beyond decoding the binary layout that CPointsMapXYZIRT used before it was replaced by CGenericPointsMap. Its only purpose is to keep pre-existing .simplemap / .rawlog files (or any other CSerializable-based archive) that were saved with a CPointsMapXYZIRT layer loadable: without this class being registered under its original name, CArchive::ReadObject() throws on any such file with “Stored object has class ‘mrpt::maps::CPointsMapXYZIRT’ which is not registered!”.

Once loaded, the point cloud is a regular CGenericPointsMap with fields intensity, ring, and t populated as applicable, so all normal CPointsMap/CGenericPointsMap APIs apply.

See also:

mrpt::maps::CGenericPointsMap

#include <mrpt/maps/CPointsMapXYZIRT.h>

class CPointsMapXYZIRT: public mrpt::maps::CGenericPointsMap
{
public:
    // typedefs

    typedef std::shared_ptr<mrpt::maps ::CPointsMapXYZIRT> Ptr;
    typedef std::shared_ptr<const mrpt::maps ::CPointsMapXYZIRT> ConstPtr;
    typedef std::unique_ptr<mrpt::maps ::CPointsMapXYZIRT> UniquePtr;
    typedef std::unique_ptr<const mrpt::maps ::CPointsMapXYZIRT> ConstUniquePtr;

    // fields

    static constexpr const char* className = "mrpt::maps" "::" "CPointsMapXYZIRT";

    // construction

    CPointsMapXYZIRT();

    // methods

    static constexpr auto getClassName();
    static const mrpt::rtti::TRuntimeClassId& GetRuntimeClassIdStatic();
    static std::shared_ptr<CObject> CreateObject();

    template <typename... Args>
    static Ptr Create(Args&&... args);

    template <typename Alloc, typename... Args>
    static Ptr CreateAlloc(
        const Alloc& alloc,
        Args&&... args
        );

    template <typename... Args>
    static UniquePtr CreateUnique(Args&&... args);

    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    virtual mrpt::rtti::CObject* clone() const;
    static std::shared_ptr<mrpt::maps::CMetricMap> internal_CreateFromMapDefinition(const mrpt::maps::TMetricMapInitializer& def);
    bool registerField_double(const std::string& fieldName);
    bool registerField_uint16(const std::string& fieldName);
    bool registerField_uint8(const std::string& fieldName);
    bool registerField_uint32(const std::string& fieldName);

    double getPointField_double(
        size_t index,
        const std::string& fieldName
        ) const;

    uint16_t getPointField_uint16(
        size_t index,
        const std::string& fieldName
        ) const;

    uint8_t getPointField_uint8(
        size_t index,
        const std::string& fieldName
        ) const;

    uint32_t getPointField_uint32(
        size_t index,
        const std::string& fieldName
        ) const;

    void setPointField_double(
        size_t index,
        const std::string& fieldName,
        double value
        );

    void setPointField_uint16(
        size_t index,
        const std::string& fieldName,
        uint16_t value
        );

    void setPointField_uint8(
        size_t index,
        const std::string& fieldName,
        uint8_t value
        );

    void setPointField_uint32(
        size_t index,
        const std::string& fieldName,
        uint32_t value
        );

    void reserveField_float(
        const std::string& fieldName,
        size_t n
        );

    void reserveField_double(
        const std::string& fieldName,
        size_t n
        );

    void reserveField_uint16(
        const std::string& fieldName,
        size_t n
        );

    void reserveField_uint8(
        const std::string& fieldName,
        size_t n
        );

    void reserveField_uint32(
        const std::string& fieldName,
        size_t n
        );

    void resizeField_float(
        const std::string& fieldName,
        size_t n
        );

    void resizeField_double(
        const std::string& fieldName,
        size_t n
        );

    void resizeField_uint16(
        const std::string& fieldName,
        size_t n
        );

    void resizeField_uint8(
        const std::string& fieldName,
        size_t n
        );

    void resizeField_uint32(
        const std::string& fieldName,
        size_t n
        );

    virtual auto getPointsBufferRef_float_field(const std::string& fieldName) const;
    virtual auto getPointsBufferRef_float_field(const std::string& fieldName);
    auto getPointsBufferRef_double_field(const std::string& fieldName) const;
    auto getPointsBufferRef_double_field(const std::string& fieldName);
    auto getPointsBufferRef_uint16_field(const std::string& fieldName) const;
    auto getPointsBufferRef_uint16_field(const std::string& fieldName);
    auto getPointsBufferRef_uint8_field(const std::string& fieldName) const;
    auto getPointsBufferRef_uint8_field(const std::string& fieldName);
    auto getPointsBufferRef_uint32_field(const std::string& fieldName) const;
    auto getPointsBufferRef_uint32_field(const std::string& fieldName);
};

Inherited Members

public:
    // typedefs

    typedef std::shared_ptr<CSerializable> Ptr;
    typedef std::shared_ptr<const CSerializable> ConstPtr;
    typedef KDTreeCapable<Derived, num_t, metric_t> self_t;
    typedef std::shared_ptr<CPointsMap> Ptr;
    typedef std::shared_ptr<const CPointsMap> ConstPtr;
    typedef std::shared_ptr<mrpt::maps ::CGenericPointsMap> Ptr;
    typedef std::shared_ptr<const mrpt::maps ::CGenericPointsMap> ConstPtr;
    typedef std::unique_ptr<mrpt::maps ::CGenericPointsMap> UniquePtr;
    typedef std::unique_ptr<const mrpt::maps ::CGenericPointsMap> ConstUniquePtr;

    // structs

    template <int _DIM = -1>
    struct TKDTreeDataHolder;

    struct TKDTreeSearchParams;
    struct InsertCtx;
    struct TInsertionOptions;
    struct TLaserRange2DInsertContext;
    struct TLaserRange3DInsertContext;
    struct TLikelihoodOptions;
    struct TRenderOptions;
    struct TMapDefinition;
    struct TMapDefinitionBase;

    // fields

    static constexpr const char* className = "mrpt::maps" "::" "CGenericPointsMap";
    static const size_t m_private_map_register_id =   mrpt::maps::internal::TMetricMapTypesRegistry::Instance().doRegister("mrpt::maps::CGenericPointsMap" ,& mrpt::maps::CGenericPointsMap ::MapDefinition,& mrpt::maps::CGenericPointsMap ::internal_CreateFromMapDefinition);
    static constexpr static const char* POINT_FIELD_COLOR_Ru8 = "color_r";
    static constexpr static const char* POINT_FIELD_COLOR_Gu8 = "color_g";
    static constexpr static const char* POINT_FIELD_COLOR_Bu8 = "color_b";
    static constexpr static const char* POINT_FIELD_COLOR_Rf = "color_rf";
    static constexpr static const char* POINT_FIELD_COLOR_Gf = "color_gf";
    static constexpr static const char* POINT_FIELD_COLOR_Bf = "color_bf";
    TInsertionOptions insertionOptions;
    TKDTreeSearchParams kdtree_search_params;

    // methods

    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    static const mrpt::rtti::TRuntimeClassId& GetRuntimeClassIdStatic();
    Visualizable& operator = (const Visualizable&);
    Visualizable& operator = (Visualizable&&);
    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    virtual bool isEmpty() const = 0;
    virtual void saveMetricMapRepresentationToFile(const std::string& filNamePrefix) const = 0;
    virtual std::string asString() const = 0;
    virtual void getVisualizationInto(mrpt::viz::CSetOfObjects& o) const = 0;
    float kdTreeClosestPoint2DsqrError(const TPoint2D& p0) const;
    void kdTreeTwoClosestPoint2D(const TPoint2D& p0, TPoint2D& pOut1, TPoint2D& pOut2, float& outDistSqr1, float& outDistSqr2) const;

    std::vector<size_t> kdTreeNClosestPoint2D(
        const TPoint2D& p0,
        size_t N,
        std::vector<TPoint2D>& pOut,
        std::vector<float>& outDistSqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    void kdTreeNClosestPoint2DIdx(
        const TPoint2D& p0,
        size_t N,
        std::vector<size_t>& outIdx,
        std::vector<float>& outDistSqr
        ) const;

    void kdTreeNClosestPoint3D(
        const TPoint3D& p0,
        size_t N,
        std::vector<TPoint3D>& pOut,
        std::vector<float>& outDistSqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    void kdTreeNClosestPoint3DIdx(
        const TPoint3D& p0,
        size_t N,
        std::vector<size_t>& outIdx,
        std::vector<float>& outDistSqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    void kdTreeEnsureIndexBuilt3D();
    void kdTreeEnsureIndexBuilt2D();
    KDTreeCapable& operator = (const KDTreeCapable& o);
    virtual bool nn_has_indices_or_ids() const = 0;
    virtual size_t nn_index_count() const = 0;

    virtual bool nn_single_search(
        const mrpt::math::TPoint3Df& query,
        mrpt::math::TPoint3Df& result,
        float& out_dist_sqr,
        uint64_t& resultIndexOrIDOrID
        ) const = 0;

    virtual bool nn_single_search(
        const mrpt::math::TPoint2Df& query,
        mrpt::math::TPoint2Df& result,
        float& out_dist_sqr,
        uint64_t& resultIndexOrIDOrID
        ) const = 0;

    virtual void nn_multiple_search(
        const mrpt::math::TPoint3Df& query,
        size_t N,
        std::vector<mrpt::math::TPoint3Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs
        ) const = 0;

    virtual void nn_multiple_search(
        const mrpt::math::TPoint2Df& query,
        size_t N,
        std::vector<mrpt::math::TPoint2Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs
        ) const = 0;

    virtual void nn_radius_search(
        const mrpt::math::TPoint3Df& query,
        float search_radius_sqr,
        std::vector<mrpt::math::TPoint3Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs,
        size_t maxPoints = 0
        ) const = 0;

    virtual void nn_radius_search(
        const mrpt::math::TPoint2Df& query,
        float search_radius_sqr,
        std::vector<mrpt::math::TPoint2Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs,
        size_t maxPoints = 0
        ) const = 0;

    NearestNeighborsCapable& operator = (const NearestNeighborsCapable&);
    NearestNeighborsCapable& operator = (NearestNeighborsCapable&&);
    OptionsCapable& operator = (const OptionsCapable&);
    OptionsCapable& operator = (OptionsCapable&&);
    virtual std::map<std::string, mrpt::config::CLoadableOptions*> optionsByName() = 0;
    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    static const mrpt::rtti::TRuntimeClassId& GetRuntimeClassIdStatic();
    virtual bool registerField_float(const std::string& fieldName);
    virtual void reserve(size_t newLength) = 0;
    virtual void resize(size_t newLength) = 0;
    virtual void setSize(size_t newLength) = 0;
    virtual void getPointAllFieldsFast(size_t index, std::vector<float>& point_data) const = 0;
    virtual void setPointAllFieldsFast(size_t index, const std::vector<float>& point_data) = 0;
    virtual bool hasPointField(const std::string& fieldName) const;
    virtual std::vector<std::string> getPointFieldNames_float() const;
    virtual std::vector<std::string> getPointFieldNames_double() const;
    virtual std::vector<std::string> getPointFieldNames_uint16() const;
    virtual std::vector<std::string> getPointFieldNames_uint8() const;
    virtual std::vector<std::string> getPointFieldNames_uint32() const;
    virtual float getPointField_float(size_t index, const std::string& fieldName) const;
    virtual void setPointField_float(size_t index, const std::string& fieldName, float value);
    CPointsMap& operator = (const CPointsMap& o);
    CPointsMap& operator = (CPointsMap&& o);
    virtual void loadFromRangeScan(const mrpt::obs::CObservation2DRangeScan& rangeScan, const std::optional<const mrpt::poses::CPose3D>& robotPose) = 0;
    virtual void loadFromRangeScan(const mrpt::obs::CObservation3DRangeScan& rangeScan, const std::optional<const mrpt::poses::CPose3D>& robotPose) = 0;
    static constexpr auto getClassName();
    static const mrpt::rtti::TRuntimeClassId& GetRuntimeClassIdStatic();
    static std::shared_ptr<CObject> CreateObject();

    template <typename... Args>
    static Ptr Create(Args&&... args);

    template <typename Alloc, typename... Args>
    static Ptr CreateAlloc(
        const Alloc& alloc,
        Args&&... args
        );

    template <typename... Args>
    static UniquePtr CreateUnique(Args&&... args);

    virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const;
    virtual mrpt::rtti::CObject* clone() const;
    static std::shared_ptr<mrpt::maps::TMetricMapInitializer> MapDefinition();
    static std::shared_ptr<CGenericPointsMap> CreateFromMapDefinition(const mrpt::maps::TMetricMapInitializer& def);
    virtual bool registerField_uint16(] const std::string& fieldName);
    virtual bool registerField_uint8(] const std::string& fieldName);
    virtual bool registerField_uint32(] const std::string& fieldName);
    virtual bool registerField_double(] const std::string& fieldName);
    virtual bool registerField_float(const std::string& fieldName);
    bool unregisterField(const std::string& fieldName);
    const std::map<std::string, mrpt::aligned_std_vector<float>>& float_fields() const;
    const std::map<std::string, mrpt::aligned_std_vector<double>>& double_fields() const;
    const std::map<std::string, mrpt::aligned_std_vector<uint16_t>>& uint16_fields() const;
    const std::map<std::string, mrpt::aligned_std_vector<uint8_t>>& uint8_fields() const;
    const std::map<std::string, mrpt::aligned_std_vector<uint32_t>>& uint32_fields() const;
    virtual void reserve(size_t newLength);
    virtual void resize(size_t newLength);
    virtual void setSize(size_t newLength);
    virtual void getPointAllFieldsFast(size_t index, std::vector<float>& point_data) const;
    virtual void setPointAllFieldsFast(size_t index, const std::vector<float>& point_data);
    virtual void loadFromRangeScan(const mrpt::obs::CObservation2DRangeScan& rangeScan, const std::optional<const mrpt::poses::CPose3D>& robotPose);
    virtual void loadFromRangeScan(const mrpt::obs::CObservation3DRangeScan& rangeScan, const std::optional<const mrpt::poses::CPose3D>& robotPose);
    virtual bool hasPointField(const std::string& fieldName) const;
    virtual std::vector<std::string> getPointFieldNames_float() const;
    virtual std::vector<std::string> getPointFieldNames_double() const;
    virtual std::vector<std::string> getPointFieldNames_uint16() const;
    virtual std::vector<std::string> getPointFieldNames_uint8() const;
    virtual std::vector<std::string> getPointFieldNames_uint32() const;
    virtual float getPointField_float(size_t index, const std::string& fieldName) const;
    virtual void setPointField_float(size_t index, const std::string& fieldName, float value);
    void insertPointField_float(const std::string& fieldName, float value);
    void insertPointField_double(const std::string& fieldName, double value);
    void insertPointField_uint16(const std::string& fieldName, uint16_t value);
    void insertPointField_uint8(const std::string& fieldName, uint8_t value);
    void insertPointField_uint32(const std::string& fieldName, uint32_t value);
    void setPointFast(size_t index, float x, float y, float z);
    void insertPointFast(float x, float y, float z);
    bool loadFromKittiVelodyneFile(const std::string& filename);
    bool saveToKittiVelodyneFile(const std::string& filename) const;
    bool load2D_from_text_file(const std::string& file);
    bool load3D_from_text_file(const std::string& file);
    bool load2Dor3D_from_text_file(const std::string& file, bool is_3D);
    bool save2D_to_text_file(const std::string& file) const;
    bool save3D_to_text_file(const std::string& file) const;
    virtual void saveMetricMapRepresentationToFile(const std::string& filNamePrefix) const;
    std::vector<std::string> getPointFieldNames_float_except_xyz() const;
    virtual double getPointField_double(] size_t index, ] const std::string& fieldName) const;
    virtual uint16_t getPointField_uint16(] size_t index, ] const std::string& fieldName) const;
    virtual uint8_t getPointField_uint8(] size_t index, ] const std::string& fieldName) const;
    virtual uint32_t getPointField_uint32(] size_t index, ] const std::string& fieldName) const;
    virtual void setPointField_double(] size_t index, ] const std::string& fieldName, ] double value);
    virtual void setPointField_uint16(] size_t index, ] const std::string& fieldName, ] uint16_t value);
    virtual void setPointField_uint8(] size_t index, ] const std::string& fieldName, ] uint8_t value);
    virtual void setPointField_uint32(] size_t index, ] const std::string& fieldName, ] uint32_t value);
    virtual void insertPointField_float(] const std::string& fieldName, ] float value);
    virtual void insertPointField_double(] const std::string& fieldName, ] double value);
    virtual void insertPointField_uint16(] const std::string& fieldName, ] uint16_t value);
    virtual void insertPointField_uint8(] const std::string& fieldName, ] uint8_t value);
    virtual void insertPointField_uint32(] const std::string& fieldName, ] uint32_t value);
    void enableFilterByHeight(bool enable = true);
    bool isFilterByHeightEnabled() const;
    void setHeightFilterLevels(const double _z_min, const double _z_max);
    void getHeightFilterLevels(double& _z_min, double& _z_max) const;
    std::pair<double, double> getHeightFilterLevels() const;

    template <class POINTCLOUD>
    void getPCLPointCloud(POINTCLOUD& cloud) const;

    template <class POINTCLOUD>
    void setFromPCLPointCloud(const POINTCLOUD& cloud);

    size_t kdtree_get_point_count() const;
    float kdtree_get_pt(size_t idx, int dim) const;
    float kdtree_distance(const float* p1, size_t idx_p2, size_t size) const;
    virtual void nn_prepare_for_2d_queries() const;
    virtual void nn_prepare_for_3d_queries() const;
    virtual bool nn_has_indices_or_ids() const;
    virtual size_t nn_index_count() const;

    virtual bool nn_single_search(
        const mrpt::math::TPoint3Df& query,
        mrpt::math::TPoint3Df& result,
        float& out_dist_sqr,
        uint64_t& resultIndexOrIDOrID
        ) const;

    virtual void nn_multiple_search(
        const mrpt::math::TPoint3Df& query,
        size_t N,
        std::vector<mrpt::math::TPoint3Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs
        ) const;

    virtual void nn_radius_search(
        const mrpt::math::TPoint3Df& query,
        float search_radius_sqr,
        std::vector<mrpt::math::TPoint3Df>& results,
        std::vector<float>& out_dists_sqr,
        std::vector<uint64_t>& resultIndicesOrIDs,
        size_t maxPoints
        ) const;

    size_t kdTreeClosestPoint2D(float x0, float y0, float& out_x, float& out_y, float& out_dist_sqr) const;
    size_t kdTreeClosestPoint2D(float x0, float y0, float& out_dist_sqr) const;
    size_t kdTreeClosestPoint2D(const TPoint2D& p0, TPoint2D& pOut, float& outDistSqr) const;
    float kdTreeClosestPoint2DsqrError(float x0, float y0) const;

    void kdTreeTwoClosestPoint2D(
        float x0,
        float y0,
        float& out_x1,
        float& out_y1,
        float& out_x2,
        float& out_y2,
        float& out_dist_sqr1,
        float& out_dist_sqr2
        ) const;

    std::vector<size_t> kdTreeNClosestPoint2D(
        float x0,
        float y0,
        size_t knn,
        std::vector<float>& out_x,
        std::vector<float>& out_y,
        std::vector<float>& out_dist_sqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    void kdTreeNClosestPoint2DIdx(
        float x0,
        float y0,
        size_t knn,
        std::vector<size_t>& out_idx,
        std::vector<float>& out_dist_sqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    size_t kdTreeClosestPoint3D(
        float x0,
        float y0,
        float z0,
        float& out_x,
        float& out_y,
        float& out_z,
        float& out_dist_sqr
        ) const;

    size_t kdTreeClosestPoint3D(float x0, float y0, float z0, float& out_dist_sqr) const;
    size_t kdTreeClosestPoint3D(const TPoint3D& p0, TPoint3D& pOut, float& outDistSqr) const;

    void kdTreeNClosestPoint3D(
        float x0,
        float y0,
        float z0,
        size_t knn,
        std::vector<float>& out_x,
        std::vector<float>& out_y,
        std::vector<float>& out_z,
        std::vector<float>& out_dist_sqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    void kdTreeNClosestPoint3DWithIdx(
        float x0,
        float y0,
        float z0,
        size_t knn,
        std::vector<float>& out_x,
        std::vector<float>& out_y,
        std::vector<float>& out_z,
        std::vector<size_t>& out_idx,
        std::vector<float>& out_dist_sqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    size_t kdTreeRadiusSearch3D(
        const float x0,
        const float y0,
        const float z0,
        const float maxRadiusSqr,
        std::vector<nanoflann::ResultItem<size_t, float>>& out_indices_dist
        ) const;

    size_t kdTreeRadiusSearch2D(
        const float x0,
        const float y0,
        const float maxRadiusSqr,
        std::vector<nanoflann::ResultItem<size_t, float>>& out_indices_dist
        ) const;

    void kdTreeNClosestPoint3DIdx(
        float x0,
        float y0,
        float z0,
        size_t knn,
        std::vector<size_t>& out_idx,
        std::vector<float>& out_dist_sqr,
        const std::optional<float>& maximumSearchDistanceSqr = std::nullopt
        ) const;

    bool kdtree_save_index_3D(] std::ostream& out) const;
    void kdtree_load_index_3D(] std::istream& in) const;
    bool kdtree_save_index_2D(] std::ostream& out) const;
    void kdtree_load_index_2D(] std::istream& in) const;
    CGenericPointsMap& operator = (const CGenericPointsMap& o);
    virtual float squareDistanceToClosestCorrespondence(float x0, float y0) const;
    virtual std::map<std::string, mrpt::config::CLoadableOptions*> optionsByName();

    void insertAnotherMap(
        const CPointsMap* otherMap,
        const mrpt::poses::CPose3D& otherPose,
        bool filterOutPointsAtZero = false,
        bool autoRegisterAllSourceFields = true
        );

    void operator += (const CPointsMap& anotherMap);
    size_t size() const;
    void getPoint(size_t index, float& x, float& y, float& z) const;
    void getPoint(size_t index, float& x, float& y) const;
    void getPoint(size_t index, double& x, double& y, double& z) const;
    void getPoint(size_t index, double& x, double& y) const;
    void getPoint(size_t index, mrpt::math::TPoint2D& p) const;
    void getPoint(size_t index, mrpt::math::TPoint3D& p) const;
    void getPointFast(size_t index, float& x, float& y, float& z) const;
    bool hasColor_u8() const;
    bool hasColor_f() const;
    void setPoint(size_t index, float x, float y, float z);
    void setPoint(size_t index, const mrpt::math::TPoint2D& p);
    void setPoint(size_t index, const mrpt::math::TPoint3D& p);
    void setPoint(size_t index, float x, float y);
    const mrpt::aligned_std_vector<float>& getPointsBufferRef_x() const;
    const mrpt::aligned_std_vector<float>& getPointsBufferRef_y() const;
    const mrpt::aligned_std_vector<float>& getPointsBufferRef_z() const;

    template <class VECTOR>
    void getAllPoints(
        VECTOR& xs,
        VECTOR& ys,
        VECTOR& zs,
        size_t decimation = 1
        ) const;

    void getAllPoints(std::vector<float>& xs, std::vector<float>& ys, size_t decimation = 1) const;
    void insertPoint(float x, float y, float z = 0);
    void insertPoint(const mrpt::math::TPoint3D& p);
    bool registerPointFieldsFrom(const mrpt::maps::CPointsMap& source);
    InsertCtx prepareForInsertPointsFrom(const CPointsMap& source);
    void insertPointFrom(size_t sourcePointIndex, const InsertCtx& ctx);

    template <typename VECTOR>
    void setAllPointsTemplate(
        const VECTOR& X,
        const VECTOR& Y,
        const VECTOR& Z = VECTOR()
        );

    void setAllPoints(
        const std::vector<float>& X,
        const std::vector<float>& Y,
        const std::vector<float>& Z
        );

    void setAllPoints(const std::vector<float>& X, const std::vector<float>& Y);
    void getPointAllFields(size_t index, std::vector<float>& point_data) const;
    void setPointAllFields(size_t index, const std::vector<float>& point_data);
    void clipOutOfRangeInZ(float zMin, float zMax, mrpt::maps::CPointsMap& result) const;
    void clipOutOfRange(const mrpt::math::TPoint2D& point, float maxRange, mrpt::maps::CPointsMap& result) const;

    virtual void determineMatching2D(
        const mrpt::maps::CMetricMap* otherMap,
        const mrpt::poses::CPose2D& otherMapPose,
        mrpt::tfest::TMatchingPairList& correspondences,
        const TMatchingParams& params,
        TMatchingExtraResults& extraResults
        ) const;

    virtual void determineMatching3D(
        const mrpt::maps::CMetricMap* otherMap,
        const mrpt::poses::CPose3D& otherMapPose,
        mrpt::tfest::TMatchingPairList& correspondences,
        const TMatchingParams& params,
        TMatchingExtraResults& extraResults
        ) const;

    virtual float compute3DMatchingRatio(const mrpt::maps::CMetricMap* otherMap, const mrpt::poses::CPose3D& otherMapPose, const TMatchingRatioParams& params) const;

    void compute3DDistanceToMesh(
        const mrpt::maps::CMetricMap* otherMap2,
        const mrpt::poses::CPose3D& otherMapPose,
        float maxDistForCorrespondence,
        mrpt::tfest::TMatchingPairList& correspondences,
        float& correspondencesRatio
        );

    void loadFromVelodyneScan(const mrpt::obs::CObservationVelodyneScan& scan, const std::optional<const mrpt::poses::CPose3D>& robotPose = std::nullopt);

    void fuseWith(
        CPointsMap* anotherMap,
        float minDistForFuse = 0.02f,
        std::vector<bool>* notFusedPoints = nullptr
        );

    void changeCoordinatesReference(const mrpt::poses::CPose2D& b);
    void changeCoordinatesReference(const mrpt::poses::CPose3D& b);
    void changeCoordinatesReference(const CPointsMap& other, const mrpt::poses::CPose3D& b);
    virtual bool isEmpty() const;
    bool empty() const;
    virtual void getVisualizationInto(mrpt::viz::CSetOfObjects& outObj) const;
    virtual mrpt::math::TBoundingBoxf boundingBox() const;
    void extractCylinder(const mrpt::math::TPoint2D& center, double radius, double zmin, double zmax, CPointsMap& outMap);
    void extractPoints(const mrpt::math::TBoundingBoxf& bbox, CPointsMap& outMap);
    virtual double internal_computeObservationLikelihood(const mrpt::obs::CObservation& obs, const mrpt::poses::CPose3D& takenFrom) const;
    void mark_as_modified() const;
    virtual std::string asString() const;
    const CPointsMap& derived() const;
    CPointsMap& derived();

    bool loadFromPlyFile(
        const std::string& filename,
        std::vector<std::string>* file_comments = nullptr,
        std::vector<std::string>* file_obj_info = nullptr
        );

    std::string getLoadPLYErrorString() const;

    bool saveToPlyFile(
        const std::string& filename,
        bool save_in_binary = false,
        const std::vector<std::string>& file_comments = std::vector<std::string>(),
        const std::vector<std::string>& file_obj_info = std::vector<std::string>()
        ) const;

    std::string getSavePLYErrorString() const;

Typedefs

typedef std::shared_ptr<mrpt::maps ::CPointsMapXYZIRT> Ptr

A type for the associated smart pointer.

Methods

virtual const mrpt::rtti::TRuntimeClassId* GetRuntimeClass() const

Returns information about the class of an object in runtime.

virtual mrpt::rtti::CObject* clone() const

Returns a deep copy (clone) of the object, indepently of its class.