PointCloud.h

浏览该文件的文档.

//
// Created by ALSON08 on 2023/10/9.
//
 
#ifndef ALSON_CLASSIC_BASE_ENTITY_POINT_CLOUD_H
#define ALSON_CLASSIC_BASE_ENTITY_POINT_CLOUD_H
 
 
// std
#include <cstdint>
#include <string>
#include <exception>
#include <memory>
 
// alson
#include <alson/communication_base.h>
 
 
namespace ALSON {
 
 
enum class PointType : int {
    UNKNOWN = 0,                        
    ALSON_POINT_XYZ = 1,                
    ALSON_POINT_XYZI = 2,               
    ALSON_POINT_XYZRGB = 3,             
    ALSON_POINT_XYZI_NORMAL = 4,        
    ALSON_POINT_XYZRGB_NORMAL = 5       
};
 
 
enum class PclPointType : int {
    PCL_POINT_XYZ = 101,                
    PCL_POINT_XYZI = 102,               
    PCL_POINT_XYZRGB = 103,             
    PCL_POINT_XYZI_NORMAL = 104,        
    PCL_POINT_XYZRGB_NORMAL = 105       
};
 
 
class ALSON_API PointCloud {
public:
    PointCloud();
    
    PointCloud(int w, int h, PointType t);
    
    PointCloud(int w, int h, PointType t, uint8_t* d);
    ~PointCloud();
    
    PointCloud(const PointCloud& a);
    PointCloud& operator=(const PointCloud& a);
    PointCloud(PointCloud&& a) noexcept;
    PointCloud& operator=(PointCloud&& a) noexcept;
 
public:
    int size() const { return width * height; }
    
    template<typename T>
    T* ptr();
    
    template<typename T>
    const T* ptr() const;
    
    template<typename T>
    T& at(int i, int j = 0);
    
    template<typename T>
    const T& at(int i, int j = 0) const;
    
    static PointCloud create(int width, int height, PointType pointType);
    
    static PointCloud create(int width, int height, PointType pointType, uint8_t* data);
    
    static PointCloud createFromPcl(int width, int height, PointType pointType, void* pclData);
    
    PointCloud clone() const;
    
    void cloneToPcl(void* pclData, PclPointType pclPointType) const;
    
    static PointCloud load(const std::string& filename, PointType pointType = PointType::ALSON_POINT_XYZ);
    
    void save(const std::string& filename) const;
    
    int getXPos() const;
    
    int getYPos() const;
    
    int getZPos() const;
    
    int getIPos() const;
    
    int getRPos() const;
    
    int getGPos() const;
    
    int getBPos() const;
    
    int getNXPos() const;
    
    int getNYPos() const;
    
    int getNZPos() const;
    
    static int getElementSize(PointType type);
 
private:
    void fromPclPointXYZ(void* pclData) const;
    void fromPclPointXYZI(void* pclData) const;
    void fromPclPointXYZRGB(void* pclData) const;
    void fromPclPointXYZINormal(void* pclData) const;
    void fromPclPointXYZRGBNormal(void* pclData) const;
    
    void toPclPointXYZ(void* pclData) const;
    void toPclPointXYZI(void* pclData) const;
    void toPclPointXYZRGB(void* pclData) const;
    void toPclPointXYZINormal(void* pclData) const;
    void toPclPointXYZRGBNormal(void* pclData) const;
 
public:
    int width;
    int height;
    PointType type;
    int elementSize;
    uint8_t* data;
 
private:
    std::allocator<uint8_t> m_allocator;
    int* m_refCount;
}; // class PointCloud
 
 
template<typename T>
inline T* PointCloud::ptr() {
    return (T*) data;
}
 
template<typename T>
inline const T* PointCloud::ptr() const {
    return (T*) data;
}
 
template<typename T>
inline T& PointCloud::at(int i, int j) {
    auto* p = (T*) data + i + j * width;
    return *p;
}
 
template<typename T>
inline const T& PointCloud::at(int i, int j) const {
    const auto* p = (T*) data + i * width + j;
    return *p;
}
 
 
} // namespace ALSON
 
 
#endif // !ALSON_CLASSIC_BASE_ENTITY_POINT_CLOUD_H