Patch.h

#pragma once
 
#include <QFlags>
#include <QSharedDataPointer>
 
#include <kDBGIS/Forward.h>
 
#include <clog_qt>
#include <cres_qt>
 
#include <knowValues/Forward.h>
 
#include "Point.h"
 
namespace kDBPointClouds
{
  class Patch
  {
  public:
    enum class PGWKBFlag
    {
      Default = 0,
      IgnorePCID = 1
    };
    Q_DECLARE_FLAGS(PGWKBFlags, PGWKBFlag)
  public:
    Patch();
    Patch(const PointSpecification& _specification, const QByteArray& _data = QByteArray());
    Patch(const Patch& _rhs);
    Patch& operator=(const Patch& _rhs);
    ~Patch();
    bool operator==(const Patch& _rhs) const;
    PointSpecification specification() const;
    bool synchroniseSpecification(const kDB::Repository::Connection& _connection);
    Cartography::CoordinateSystem coordinateSystem() const;
    void reserve(std::size_t _pts);
    void append(const Point& _point);
    template<typename... Types>
    inline void append(const std::tuple<Types...>& _values);
    template<typename... Types>
    void append(Types... _values)
    {
      append(std::make_tuple(_values...));
    }
    std::size_t pointsCount() const;
    template<typename... Types>
    inline std::tuple<Types...> get(std::size_t _index) const;
    Point get(std::size_t _index) const;
    QByteArray toPGWKB(PGWKBFlags _flags = PGWKBFlag::Default) const;
    static cres_qresult<Patch> fromPGWKB(const QByteArray&,
                                         const PointSpecification& _pointSpecification,
                                         PGWKBFlags _flags = PGWKBFlag::Default);
    static cres_qresult<Patch> fromPGWKB(const QByteArray& _data,
                                         const kDB::Repository::Connection& _connection,
                                         PGWKBFlags _flags = PGWKBFlag::Default);
    bool isValid() const;
    QByteArray data() const;
    Patch transform(const Cartography::CoordinateSystem& _coordinateSystem, double _tx = 0.0,
                    double _ty = 0.0, double _tz = 0.0) const;
    cres_qresult<QByteArray> md5() const;
  public:
    knowValues::Values::PointCloud toValuesPointCloud(const knowGIS::Pose& _pose,
                                                      const knowGIS::GeometryObject& _geometry,
                                                      const knowCore::Timestamp& _timestamp);
    knowValues::Values::Lidar3DScan toValuesLidar3DScan(const knowGIS::Pose& _pose,
                                                        const knowCore::Timestamp& _timestamp);
    static Patch create(const knowValues::Values::PointCloud& _rhs);
  private:
    std::size_t prepareNextPointInsertion();
    std::size_t pointSize() const;
    QByteArray& data_ref();
  private:
    struct Private;
    QSharedDataPointer<Private> d;
  };
 
  template<typename... Types>
  void Patch::append(const std::tuple<Types...>& _values)
  {
    Point::setter<sizeof...(Types)>::doit(prepareNextPointInsertion(), data_ref(), _values);
  }
  template<typename... Types>
  inline std::tuple<Types...> Patch::get(std::size_t _index) const
  {
    std::tuple<Types...> values;
    Point::getter<sizeof...(Types)>::doit(_index * pointSize(), data(), values);
    return values;
  }
} // namespace kDBPointClouds
 
#include <knowCore/MetaType.h>
KNOWCORE_DECLARE_FULL_METATYPE(kDBPointClouds, Patch);