qgspointcloudlayerexporter.h

Go to the documentation of this file.

/***************************************************************************
                         qgspointcloudlayerexporter.h
                         ---------------------
    begin                : July 2022
    copyright            : (C) 2022 by Stefanos Natsis
    email                : uclaros at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSPOINTCLOUDLAYEREXPORTER_H
#define QGSPOINTCLOUDLAYEREXPORTER_H
 
#include "qgis_core.h"
#include "qgsvectorlayer.h"
#include "qgspointcloudlayer.h"
#include "qgstaskmanager.h"
#include "qgsvectorfilewriter.h"
 
#ifdef HAVE_PDAL_QGIS
#include <pdal/PointView.hpp>
#include <pdal/PointTable.hpp>
#include <pdal/Options.hpp>
#endif
 
class QgsCoordinateTransform;
class QgsGeos;
 
class CORE_EXPORT QgsPointCloudLayerExporter SIP_NODEFAULTCTORS
{
  public:
 
    enum class ExportFormat : int
    {
      Memory = 0, 
      Las = 1, 
      Gpkg = 2, 
      Shp = 3, 
      Dxf = 4, 
      Csv = 5, 
    };
 
    static QList< ExportFormat > supportedFormats() SIP_SKIP
    {
      QList< ExportFormat > formats;
      formats << ExportFormat::Memory
#ifdef HAVE_PDAL_QGIS
              << ExportFormat::Las
#endif
              << ExportFormat::Gpkg
              << ExportFormat::Shp
              << ExportFormat::Dxf
              << ExportFormat::Csv;
      return formats;
    }
 
    static QString getOgrDriverName( ExportFormat format ) SIP_SKIP;
 
    QgsPointCloudLayerExporter( QgsPointCloudLayer *layer );
 
    ~QgsPointCloudLayerExporter();
 
    void setFileName( const QString &filename ) { mFilename = filename; }
 
    QString fileName() const { return mFilename; }
 
    void setLayerName( const QString &name ) { mName = name; }
 
    QString layerName() const { return mName; }
 
    void setFilterExtent( const QgsRectangle extent ) { mExtent = extent; }
 
    QgsRectangle filterExtent() const { return mExtent; }
 
    void setFilterGeometry( const QgsAbstractGeometry *geometry );
 
    void setFilterGeometry( QgsMapLayer *layer, bool selectedFeaturesOnly = false );
 
    void setZRange( const QgsDoubleRange zRange ) { mZRange = zRange; }
 
    QgsDoubleRange zRange() const { return mZRange; }
 
    void setFeedback( QgsFeedback *feedback ) { mFeedback = feedback; }
 
    QgsFeedback *feedback() const { return mFeedback; }
 
    void setAttributes( const QStringList &attributes );
 
    void setNoAttributes() { mRequestedAttributes.clear(); }
 
    void setAllAttributes();
 
    QStringList attributes() const { return mRequestedAttributes; }
 
    void setCrs( const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context = QgsCoordinateTransformContext() ) { mTargetCrs = crs; mTransformContext = context; }
 
    QgsCoordinateReferenceSystem crs() const { return mTargetCrs; }
 
    bool setFormat( const ExportFormat format );
 
    ExportFormat format() const { return mFormat; }
 
    void setPointsLimit( qint64 limit ) { mPointsLimit = std::max< qint64 >( limit, 0 ); }
 
    qint64 pointsLimit() { return mPointsLimit; }
 
    void setActionOnExistingFile( const QgsVectorFileWriter::ActionOnExistingFile action ) { mActionOnExistingFile = action; }
 
    void prepareExport();
 
    void doExport();
 
    QgsMapLayer *takeExportedLayer() SIP_FACTORY;
 
    QString lastError() const { return mLastError; }
 
  private:
 
    void exportToSink( QgsFeatureSink * );
 
    QgsFields outputFields();
    const QgsPointCloudAttributeCollection requestedAttributeCollection();
    void setLastError( QString error ) { mLastError = error; }
 
    const QgsPointCloudAttributeCollection mLayerAttributeCollection;
 
    std::unique_ptr< QgsPointCloudIndex > mIndex;
    QString mName = QObject::tr( "Exported" );
    ExportFormat mFormat = ExportFormat::Memory;
    QString mFilename;
    QString mLastError;
    QgsRectangle mExtent = QgsRectangle( -std::numeric_limits<double>::infinity(),
                                         -std::numeric_limits<double>::infinity(),
                                         std::numeric_limits<double>::infinity(),
                                         std::numeric_limits<double>::infinity(),
                                         false );
    std::unique_ptr< QgsGeos > mFilterGeometryEngine;
    QgsDoubleRange mZRange;
    QgsFeedback *mFeedback = nullptr;
    qint64 mPointsLimit = 0;
    QStringList mRequestedAttributes;
    QgsCoordinateReferenceSystem mSourceCrs;
    QgsCoordinateReferenceSystem mTargetCrs;
    QgsCoordinateTransformContext mTransformContext;
    int mPointRecordFormat;
    QgsVectorFileWriter::ActionOnExistingFile mActionOnExistingFile = QgsVectorFileWriter::ActionOnExistingFile::CreateOrOverwriteFile;
 
    QgsMapLayer *mMemoryLayer = nullptr;
    QgsFeatureSink *mVectorSink = nullptr;
    QgsCoordinateTransform *mTransform = nullptr;
 
 
    class ExporterBase
    {
      public:
        ExporterBase() = default;
        virtual ~ExporterBase() = default;
        void run();
      protected:
        virtual void handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber ) = 0;
        virtual void handleNode() = 0;
        virtual void handleAll() = 0;
        QgsPointCloudLayerExporter *mParent = nullptr;
    };
 
    class ExporterMemory : public ExporterBase
    {
      public:
        ExporterMemory( QgsPointCloudLayerExporter *exp );
        ~ExporterMemory() override;
 
      private:
        void handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber ) override;
        void handleNode() override;
        void handleAll() override;
        QgsFeatureList mFeatures;
    };
 
    class ExporterVector : public ExporterBase
    {
      public:
        ExporterVector( QgsPointCloudLayerExporter *exp );
        ~ExporterVector() override;
 
      private:
        void handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber ) override;
        void handleNode() override;
        void handleAll() override;
        QgsFeatureList mFeatures;
    };
 
#ifdef HAVE_PDAL_QGIS
    class ExporterPdal : public ExporterBase
    {
      public:
        ExporterPdal( QgsPointCloudLayerExporter *exp );
 
      private:
        void handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber ) override;
        void handleNode() override;
        void handleAll() override;
        const int mPointFormat;
        pdal::Options mOptions;
        pdal::PointTable mTable;
        pdal::PointViewPtr mView;
    };
#endif
 
};
 
 
 
class CORE_EXPORT QgsPointCloudLayerExporterTask : public QgsTask
{
    Q_OBJECT
 
  public:
 
    QgsPointCloudLayerExporterTask( QgsPointCloudLayerExporter *exporter );
 
    void cancel() override;
 
  signals:
 
    void exportComplete();
 
  protected:
 
    bool run() override;
    void finished( bool result ) override;
 
  private:
    QgsPointCloudLayerExporter *mExp = nullptr;
 
    std::unique_ptr< QgsFeedback > mOwnedFeedback;
 
};
#endif // QGSPOINTCLOUDLAYEREXPORTER_H