namespace mrpt::maps::internal

Overview

namespace internal {

// typedefs

typedef std::function<std::shared_ptr<mrpt::maps::TMetricMapInitializer>(void)> MapDefCtorFunctor;
typedef std::function<std::shared_ptr<mrpt::maps::CMetricMap>(const mrpt::maps::TMetricMapInitializer&)> MapCtorFromDefFunctor;

// structs

struct PointColumn;
struct TMetricMapTypesRegistry;

template <class T>
struct has_color<T, std::void_t<decltype(T::color)>>;

template <class T, class = void>
struct has_color;

// global variables

constexpr uint8_t kPointsEncodingRaw = 0;
constexpr uint8_t kPointsEncodingCloudini = 1;

// global functions

bool cloudini_available();
void cloudini_require();

template <typename T>
void cloudini_encode(
    ] const T* data,
    ] std::size_t n,
    ] std::optional<float> resolution,
    ] std::vector<uint8_t>& out
    );

template <typename T>
void cloudini_decode(
    ] const uint8_t* stream,
    ] std::size_t streamSize,
    ] T* data,
    ] std::size_t n
    );

template void cloudini_encode< float >(
    const float*,
    std::size_t,
    std::optional<float>,
    std::vector<uint8_t>&
    );

template void cloudini_decode< float >(
    const uint8_t*,
    std::size_t,
    float*,
    std::size_t
    );

template void cloudini_encode< double >(
    const double*,
    std::size_t,
    std::optional<float>,
    std::vector<uint8_t>&
    );

template void cloudini_decode< double >(
    const uint8_t*,
    std::size_t,
    double*,
    std::size_t
    );

template void cloudini_encode< uint8_t >(
    const uint8_t*,
    std::size_t,
    std::optional<float>,
    std::vector<uint8_t>&
    );

template void cloudini_decode< uint8_t >(
    const uint8_t*,
    std::size_t,
    uint8_t*,
    std::size_t
    );

template void cloudini_encode< uint16_t >(
    const uint16_t*,
    std::size_t,
    std::optional<float>,
    std::vector<uint8_t>&
    );

template void cloudini_decode< uint16_t >(
    const uint8_t*,
    std::size_t,
    uint16_t*,
    std::size_t
    );

template void cloudini_encode< uint32_t >(
    const uint32_t*,
    std::size_t,
    std::optional<float>,
    std::vector<uint8_t>&
    );

template void cloudini_decode< uint32_t >(
    const uint8_t*,
    std::size_t,
    uint32_t*,
    std::size_t
    );

template <typename T>
void cloudini_encode(
    const T* data,
    std::size_t n,
    std::optional<float> resolution,
    std::vector<uint8_t>& out
    );

template <typename T>
void cloudini_decode(
    const uint8_t* stream,
    std::size_t streamSize,
    T* data,
    std::size_t n
    );

uint8_t points_encoding_for_writing(std::size_t numPoints);
float xyz_resolution();
std::optional<float> field_resolution(const std::string& fieldName);
void write_point_columns(mrpt::serialization::CArchive& out, uint8_t encoding, const std::vector<PointColumn>& columns);
void read_point_columns(mrpt::serialization::CArchive& in, uint8_t encoding, const std::vector<PointColumn>& columns);

} // namespace internal

Global Variables

constexpr uint8_t kPointsEncodingRaw = 0

Values of the “encoding” byte written before the point fields.

Global Functions

bool cloudini_available()

Whether this build of MRPT can encode and decode Cloudini streams.

void cloudini_require()

Parameters:

std::exception

If this build of MRPT does not support Cloudini.

template <typename T>
void cloudini_encode(
    const T* data,
    std::size_t n,
    std::optional<float> resolution,
    std::vector<uint8_t>& out
    )

Encodes n values of one point field (a contiguous array) into out.

resolution : quantization step for float/double fields (max error resolution/2); std::nullopt stores the values exactly. Integer fields are always lossless.

Parameters:

std::exception

If built without Cloudini.

template <typename T>
void cloudini_decode(
    const uint8_t* stream,
    std::size_t streamSize,
    T* data,
    std::size_t n
    )

Decodes a stream written by cloudini_encode<T>() into n values at data.

Parameters:

std::exception

If built without Cloudini, or if the stream does not hold n values of type T.

uint8_t points_encoding_for_writing(std::size_t numPoints)

The encoding to write a point map with: Cloudini if this build supports it and CPointsMap::serializationOptions() enable it for this number of points, raw otherwise.

float xyz_resolution()

Quantization step for the x,y,z columns.

std::optional<float> field_resolution(const std::string& fieldName)

Quantization step for a float/double field, std::nullopt for an exact one.

void write_point_columns(mrpt::serialization::CArchive& out, uint8_t encoding, const std::vector<PointColumn>& columns)

Writes the data of the columns with the given encoding.

With Cloudini, the columns are split into chunks, encoded in parallel for large clouds.

void read_point_columns(mrpt::serialization::CArchive& in, uint8_t encoding, const std::vector<PointColumn>& columns)

Reads what write_point_columns() wrote into the given columns: their arrays must hold n values, or be resized by PointColumn::allocate.

Parameters:

std::exception

On an unknown encoding, or a Cloudini one if this build does not support it.