qgspointcloudlayerexporter.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgspointcloudlayerexporter.cpp
                         ---------------------
    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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgspointcloudlayerexporter.h"
 
#include "qgsgeos.h"
#include "qgsmemoryproviderutils.h"
#include "qgspointcloudrequest.h"
#include "qgsrectangle.h"
#include "qgsvectorfilewriter.h"
 
#include <QApplication>
#include <QFileInfo>
#include <QQueue>
#include <QString>
#include <QThread>
 
#include "moc_qgspointcloudlayerexporter.cpp"
 
using namespace Qt::StringLiterals;
 
#ifdef HAVE_PDAL_QGIS
#include <memory>
#include <pdal/StageFactory.hpp>
#include <pdal/io/BufferReader.hpp>
#include <pdal/Dimension.hpp>
#endif
 
QString QgsPointCloudLayerExporter::getOgrDriverName( ExportFormat format )
{
  switch ( format )
  {
    case ExportFormat::Gpkg:
      return u"GPKG"_s;
    case ExportFormat::Dxf:
      return u"DXF"_s;
    case ExportFormat::Shp:
      return u"ESRI Shapefile"_s;
    case ExportFormat::Csv:
      return u"CSV"_s;
    case ExportFormat::Memory:
    case ExportFormat::Las:
      break;
  }
  return QString();
}
 
QgsPointCloudLayerExporter::QgsPointCloudLayerExporter( QgsPointCloudLayer *layer )
  : mLayerAttributeCollection( layer->attributes() )
  , mIndex( layer->index() )
  , mSourceCrs( QgsCoordinateReferenceSystem( layer->crs() ) )
  , mTargetCrs( QgsCoordinateReferenceSystem( layer->crs() ) )
{
  bool ok;
  mPointRecordFormat = layer->dataProvider()->originalMetadata().value( u"dataformat_id"_s ).toInt( &ok );
  if ( !ok )
    mPointRecordFormat = 3;
 
  setAllAttributes();
}
 
QgsPointCloudLayerExporter::~QgsPointCloudLayerExporter()
{}
 
bool QgsPointCloudLayerExporter::setFormat( const ExportFormat format )
{
  if ( supportedFormats().contains( format ) )
  {
    mFormat = format;
    return true;
  }
  return false;
}
 
void QgsPointCloudLayerExporter::setFilterGeometry( const QgsAbstractGeometry *geometry )
{
  mFilterGeometryEngine = std::make_unique<QgsGeos>( geometry );
  mFilterGeometryEngine->prepareGeometry();
}
 
void QgsPointCloudLayerExporter::setFilterGeometry( QgsMapLayer *layer, bool selectedFeaturesOnly )
{
  QgsVectorLayer *vlayer = dynamic_cast< QgsVectorLayer * >( layer );
  if ( !vlayer )
    return;
 
  QVector< QgsGeometry > allGeometries;
  QgsFeatureIterator fit;
  const QgsFeatureRequest request = QgsFeatureRequest( mExtent ).setNoAttributes();
  if ( selectedFeaturesOnly )
    fit = vlayer->getSelectedFeatures( request );
  else
    fit = vlayer->getFeatures( request );
 
  QgsCoordinateTransform transform( vlayer->crs(), mSourceCrs, mTransformContext );
 
  QgsFeature f;
  while ( fit.nextFeature( f ) )
  {
    if ( f.hasGeometry() )
    {
      allGeometries.append( f.geometry() );
    }
  }
  QgsGeometry unaryUnion = QgsGeometry::unaryUnion( allGeometries );
  try
  {
    unaryUnion.transform( transform );
  }
  catch ( const QgsCsException &cse )
  {
    QgsDebugError( u"Error transforming union of filter layer: %1"_s.arg( cse.what() ) );
    QgsDebugError( u"FilterGeometry will be ignored."_s );
    return;
  }
  setFilterGeometry( unaryUnion.constGet() );
}
 
void QgsPointCloudLayerExporter::setAttributes( const QStringList &attributeList )
{
  mRequestedAttributes.clear();
 
  const QVector<QgsPointCloudAttribute> allAttributes = mLayerAttributeCollection.attributes();
  for ( const QgsPointCloudAttribute &attribute : allAttributes )
  {
    // Don't add x, y, z or duplicate attributes
    if ( attribute.name().compare( 'X'_L1, Qt::CaseInsensitive )
         && attribute.name().compare( 'Y'_L1, Qt::CaseInsensitive )
         && attribute.name().compare( 'Z'_L1, Qt::CaseInsensitive )
         && attributeList.contains( attribute.name() )
         && !mRequestedAttributes.contains( attribute.name() ) )
    {
      mRequestedAttributes.append( attribute.name() );
    }
  }
}
 
void QgsPointCloudLayerExporter::setAllAttributes()
{
  QStringList allAttributeNames;
  const QVector<QgsPointCloudAttribute> allAttributes = mLayerAttributeCollection.attributes();
  for ( const QgsPointCloudAttribute &attribute : allAttributes )
  {
    allAttributeNames.append( attribute.name() );
  }
  setAttributes( allAttributeNames );
}
 
const QgsPointCloudAttributeCollection QgsPointCloudLayerExporter::requestedAttributeCollection()
{
  const QVector<QgsPointCloudAttribute> allAttributes = mLayerAttributeCollection.attributes();
  QgsPointCloudAttributeCollection requestAttributes;
  for ( const QgsPointCloudAttribute &attribute : allAttributes )
  {
    // For this collection we also need x, y, z apart from the requested attributes
    if ( attribute.name().compare( 'X'_L1, Qt::CaseInsensitive )
         || attribute.name().compare( 'Y'_L1, Qt::CaseInsensitive )
         || attribute.name().compare( 'Z'_L1, Qt::CaseInsensitive )
         || mRequestedAttributes.contains( attribute.name(), Qt::CaseInsensitive ) )
    {
      requestAttributes.push_back( attribute );
    }
  }
  return requestAttributes;
}
 
QgsFields QgsPointCloudLayerExporter::outputFields()
{
  const QVector<QgsPointCloudAttribute> attributes = mLayerAttributeCollection.attributes();
 
  QgsFields fields;
  for ( const QgsPointCloudAttribute &attribute : attributes )
  {
    if ( mRequestedAttributes.contains( attribute.name(), Qt::CaseInsensitive ) )
      fields.append( QgsField( attribute.name(), attribute.variantType(), attribute.displayType() ) );
  }
  return fields;
}
 
void QgsPointCloudLayerExporter::prepareExport()
{
  mMemoryLayer.reset();
 
 
  if ( mFormat == ExportFormat::Memory )
  {
#ifdef QGISDEBUG
    if ( QApplication::instance()->thread() != QThread::currentThread() )
    {
      QgsDebugMsgLevel( u"prepareExport() should better be called from the main thread!"_s, 2 );
    }
#endif
 
    mMemoryLayer.reset( QgsMemoryProviderUtils::createMemoryLayer( mName, outputFields(), Qgis::WkbType::PointZ, mTargetCrs ) );
  }
}
 
void QgsPointCloudLayerExporter::doExport()
{
  mTransform = QgsCoordinateTransform( mSourceCrs, mTargetCrs, mTransformContext );
  if ( mExtent.isFinite() )
  {
    try
    {
      mExtent = mTransform.transformBoundingBox( mExtent, Qgis::TransformDirection::Reverse );
    }
    catch ( const QgsCsException &cse )
    {
      QgsDebugError( u"Error transforming extent: %1"_s.arg( cse.what() ) );
    }
  }
 
  QStringList layerCreationOptions;
 
  switch ( mFormat )
  {
    case ExportFormat::Memory:
    {
      if ( !mMemoryLayer )
        prepareExport();
 
      ExporterMemory exp( this );
      exp.run();
      break;
    }
 
    case ExportFormat::Las:
    {
#ifdef HAVE_PDAL_QGIS
      setAllAttributes();
      // PDAL may throw exceptions
      try
      {
        ExporterPdal exp( this );
        exp.run();
      }
      catch ( std::runtime_error &e )
      {
        setLastError( QString::fromLatin1( e.what() ) );
        QgsDebugError( u"PDAL has thrown an exception: {}"_s.arg( e.what() ) );
      }
#endif
      break;
    }
 
    case ExportFormat::Csv:
      layerCreationOptions << u"GEOMETRY=AS_XYZ"_s << u"SEPARATOR=COMMA"_s; // just in case ogr changes the default lco
      [[fallthrough]];
    case ExportFormat::Gpkg:
    case ExportFormat::Dxf:
    case ExportFormat::Shp:
    {
      const QString ogrDriver = getOgrDriverName( mFormat );
      QgsVectorFileWriter::SaveVectorOptions saveOptions;
      saveOptions.layerName = mName;
      saveOptions.driverName = ogrDriver;
      saveOptions.datasourceOptions = QgsVectorFileWriter::defaultDatasetOptions( ogrDriver );
      saveOptions.layerOptions = QgsVectorFileWriter::defaultLayerOptions( ogrDriver );
      saveOptions.layerOptions << layerCreationOptions;
      saveOptions.symbologyExport = Qgis::FeatureSymbologyExport::NoSymbology;
      saveOptions.actionOnExistingFile = mActionOnExistingFile;
      saveOptions.feedback = mFeedback;
      mVectorSink.reset( QgsVectorFileWriter::create( mFilename, outputFields(), Qgis::WkbType::PointZ, mTargetCrs, QgsCoordinateTransformContext(), saveOptions ) );
      ExporterVector exp( this );
      exp.run();
      return;
    }
  }
}
 
QgsMapLayer *QgsPointCloudLayerExporter::takeExportedLayer()
{
  switch ( mFormat )
  {
    case ExportFormat::Memory:
    {
      return mMemoryLayer.release();
    }
 
    case ExportFormat::Las:
    {
      const QFileInfo fileInfo( mFilename );
      return new QgsPointCloudLayer( mFilename, fileInfo.completeBaseName(), u"pdal"_s );
    }
 
    case ExportFormat::Gpkg:
    {
      QString uri( mFilename );
      uri += "|layername=" + mName;
      return new QgsVectorLayer( uri, mName, u"ogr"_s );
    }
 
    case ExportFormat::Dxf:
    case ExportFormat::Shp:
    case ExportFormat::Csv:
    {
      const QFileInfo fileInfo( mFilename );
      return new QgsVectorLayer( mFilename, fileInfo.completeBaseName(), u"ogr"_s );
    }
  }
  BUILTIN_UNREACHABLE
}
 
//
// ExporterBase
//
 
void QgsPointCloudLayerExporter::ExporterBase::run()
{
  QgsRectangle
    geometryFilterRectangle( -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), false );
  if ( mParent->mFilterGeometryEngine )
  {
    const QgsAbstractGeometry *envelope = mParent->mFilterGeometryEngine->envelope();
    if ( envelope )
      geometryFilterRectangle = envelope->boundingBox();
  }
 
  QVector<QgsPointCloudNodeId> nodes;
  qint64 pointCount = 0;
  QQueue<QgsPointCloudNodeId> queue;
  queue.push_back( mParent->mIndex.root() );
  while ( !queue.empty() )
  {
    QgsPointCloudNode node = mParent->mIndex.getNode( queue.front() );
    queue.pop_front();
    const QgsBox3D nodeBounds = node.bounds();
    if ( mParent->mExtent.intersects( nodeBounds.toRectangle() )
         && mParent->mZRange.overlaps( { nodeBounds.zMinimum(), nodeBounds.zMaximum() } )
         && geometryFilterRectangle.intersects( nodeBounds.toRectangle() ) )
    {
      pointCount += node.pointCount();
      nodes.push_back( node.id() );
    }
    for ( QgsPointCloudNodeId child : node.children() )
    {
      queue.push_back( child );
    }
  }
 
  const qint64 pointsToExport = mParent->mPointsLimit > 0 ? std::min( mParent->mPointsLimit, pointCount ) : pointCount;
  QgsPointCloudRequest request;
  request.setAttributes( mParent->requestedAttributeCollection() );
  std::unique_ptr<QgsPointCloudBlock> block = nullptr;
  qint64 pointsExported = 0;
  for ( QgsPointCloudNodeId node : nodes )
  {
    block = mParent->mIndex.nodeData( node, request );
    const QgsPointCloudAttributeCollection attributesCollection = block->attributes();
    const char *ptr = block->data();
    int count = block->pointCount();
    int recordSize = attributesCollection.pointRecordSize();
    const QgsVector3D scale = block->scale();
    const QgsVector3D offset = block->offset();
    int xOffset = 0, yOffset = 0, zOffset = 0;
    const QgsPointCloudAttribute::DataType xType = attributesCollection.find( u"X"_s, xOffset )->type();
    const QgsPointCloudAttribute::DataType yType = attributesCollection.find( u"Y"_s, yOffset )->type();
    const QgsPointCloudAttribute::DataType zType = attributesCollection.find( u"Z"_s, zOffset )->type();
    for ( int i = 0; i < count; ++i )
    {
      if ( mParent->mFeedback && i % 1000 == 0 )
      {
        if ( pointsToExport > 0 )
        {
          mParent->mFeedback->setProgress( 100 * static_cast< float >( pointsExported ) / pointsToExport );
        }
        if ( mParent->mFeedback->isCanceled() )
        {
          mParent->setLastError( QObject::tr( "Canceled by user" ) );
          return;
        }
      }
 
      if ( pointsExported >= pointsToExport )
        break;
 
      double x, y, z;
      QgsPointCloudAttribute::getPointXYZ( ptr, i, recordSize, xOffset, xType, yOffset, yType, zOffset, zType, scale, offset, x, y, z );
      if ( !mParent->mZRange.contains( z ) || !mParent->mExtent.contains( x, y ) || ( mParent->mFilterGeometryEngine && !mParent->mFilterGeometryEngine->contains( x, y ) ) )
      {
        continue;
      }
 
      try
      {
        mParent->mTransform.transformInPlace( x, y, z );
        const QVariantMap attributeMap = QgsPointCloudAttribute::getAttributeMap( ptr, i * recordSize, attributesCollection );
        handlePoint( x, y, z, attributeMap, pointsExported );
        ++pointsExported;
      }
      catch ( const QgsCsException &cse )
      {
        QgsDebugError( u"Error transforming point: %1"_s.arg( cse.what() ) );
      }
    }
    handleNode();
  }
  handleAll();
}
 
//
// ExporterMemory
//
 
QgsPointCloudLayerExporter::ExporterMemory::ExporterMemory( QgsPointCloudLayerExporter *exp )
{
  mParent = exp;
}
 
QgsPointCloudLayerExporter::ExporterMemory::~ExporterMemory()
{
  mParent->mMemoryLayer->moveToThread( QApplication::instance()->thread() );
}
 
void QgsPointCloudLayerExporter::ExporterMemory::handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber )
{
  Q_UNUSED( pointNumber )
 
  QgsFeature feature;
  feature.setGeometry( QgsGeometry( new QgsPoint( x, y, z ) ) );
  QgsAttributes featureAttributes;
  for ( const QString &attribute : std::as_const( mParent->mRequestedAttributes ) )
  {
    const double val = map[attribute].toDouble();
    featureAttributes.append( val );
  }
  feature.setAttributes( featureAttributes );
  mFeatures.append( feature );
}
 
void QgsPointCloudLayerExporter::ExporterMemory::handleNode()
{
  QgsVectorLayer *vl = qgis::down_cast<QgsVectorLayer *>( mParent->mMemoryLayer.get() );
  if ( vl )
  {
    if ( !vl->dataProvider()->addFeatures( mFeatures ) )
    {
      mParent->setLastError( vl->dataProvider()->lastError() );
    }
  }
  mFeatures.clear();
}
 
void QgsPointCloudLayerExporter::ExporterMemory::handleAll()
{}
 
//
// ExporterVector
//
 
QgsPointCloudLayerExporter::ExporterVector::ExporterVector( QgsPointCloudLayerExporter *exp )
{
  mParent = exp;
}
 
QgsPointCloudLayerExporter::ExporterVector::~ExporterVector()
{
  mParent->mVectorSink.reset();
}
 
void QgsPointCloudLayerExporter::ExporterVector::handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber )
{
  Q_UNUSED( pointNumber )
 
  QgsFeature feature;
  feature.setGeometry( QgsGeometry( new QgsPoint( x, y, z ) ) );
  QgsAttributes featureAttributes;
  for ( const QString &attribute : std::as_const( mParent->mRequestedAttributes ) )
  {
    const double val = map[attribute].toDouble();
    featureAttributes.append( val );
  }
  feature.setAttributes( featureAttributes );
  mFeatures.append( feature );
}
 
void QgsPointCloudLayerExporter::ExporterVector::handleNode()
{
  if ( !mParent->mVectorSink->addFeatures( mFeatures ) )
  {
    mParent->setLastError( mParent->mVectorSink->lastError() );
  }
  mFeatures.clear();
}
 
void QgsPointCloudLayerExporter::ExporterVector::handleAll()
{}
 
//
// ExporterPdal
//
 
#ifdef HAVE_PDAL_QGIS
 
QgsPointCloudLayerExporter::ExporterPdal::ExporterPdal( QgsPointCloudLayerExporter *exp )
  : mPointFormat( exp->mPointRecordFormat )
{
  mParent = exp;
 
  mOptions.add( "filename", mParent->mFilename.toStdString() );
  mOptions.add( "a_srs", mParent->mTargetCrs.toWkt().toStdString() );
  mOptions.add( "minor_version", u"4"_s.toStdString() ); // delault to LAZ 1.4 to properly handle pdrf >= 6
  mOptions.add( "format", QString::number( mPointFormat ).toStdString() );
  if ( mParent->mTransform.isShortCircuited() )
  {
    mOptions.add( "offset_x", QString::number( mParent->mIndex.offset().x() ).toStdString() );
    mOptions.add( "offset_y", QString::number( mParent->mIndex.offset().y() ).toStdString() );
    mOptions.add( "offset_z", QString::number( mParent->mIndex.offset().z() ).toStdString() );
    mOptions.add( "scale_x", QString::number( mParent->mIndex.scale().x() ).toStdString() );
    mOptions.add( "scale_y", QString::number( mParent->mIndex.scale().y() ).toStdString() );
    mOptions.add( "scale_z", QString::number( mParent->mIndex.scale().z() ).toStdString() );
  }
 
  mTable.layout()->registerDim( pdal::Dimension::Id::X );
  mTable.layout()->registerDim( pdal::Dimension::Id::Y );
  mTable.layout()->registerDim( pdal::Dimension::Id::Z );
 
  mTable.layout()->registerDim( pdal::Dimension::Id::Classification );
  mTable.layout()->registerDim( pdal::Dimension::Id::Intensity );
  mTable.layout()->registerDim( pdal::Dimension::Id::ReturnNumber );
  mTable.layout()->registerDim( pdal::Dimension::Id::NumberOfReturns );
  mTable.layout()->registerDim( pdal::Dimension::Id::ScanDirectionFlag );
  mTable.layout()->registerDim( pdal::Dimension::Id::EdgeOfFlightLine );
  mTable.layout()->registerDim( pdal::Dimension::Id::ScanAngleRank );
  mTable.layout()->registerDim( pdal::Dimension::Id::UserData );
  mTable.layout()->registerDim( pdal::Dimension::Id::PointSourceId );
 
  if ( mPointFormat == 6 || mPointFormat == 7 || mPointFormat == 8 || mPointFormat == 9 || mPointFormat == 10 )
  {
    mTable.layout()->registerDim( pdal::Dimension::Id::ScanChannel );
    mTable.layout()->registerDim( pdal::Dimension::Id::ClassFlags );
  }
 
  if ( mPointFormat != 0 && mPointFormat != 2 )
  {
    mTable.layout()->registerDim( pdal::Dimension::Id::GpsTime );
  }
 
  if ( mPointFormat == 2 || mPointFormat == 3 || mPointFormat == 5 || mPointFormat == 7 || mPointFormat == 8 || mPointFormat == 10 )
  {
    mTable.layout()->registerDim( pdal::Dimension::Id::Red );
    mTable.layout()->registerDim( pdal::Dimension::Id::Green );
    mTable.layout()->registerDim( pdal::Dimension::Id::Blue );
  }
 
  if ( mPointFormat == 8 || mPointFormat == 10 )
  {
    mTable.layout()->registerDim( pdal::Dimension::Id::Infrared );
  }
 
  mView = std::make_shared<pdal::PointView>( mTable );
}
 
void QgsPointCloudLayerExporter::ExporterPdal::handlePoint( double x, double y, double z, const QVariantMap &map, const qint64 pointNumber )
{
  mView->setField( pdal::Dimension::Id::X, pointNumber, x );
  mView->setField( pdal::Dimension::Id::Y, pointNumber, y );
  mView->setField( pdal::Dimension::Id::Z, pointNumber, z );
 
 
  mView->setField( pdal::Dimension::Id::Classification, pointNumber, map[u"Classification"_s].toInt() );
  mView->setField( pdal::Dimension::Id::Intensity, pointNumber, map[u"Intensity"_s].toInt() );
  mView->setField( pdal::Dimension::Id::ReturnNumber, pointNumber, map[u"ReturnNumber"_s].toInt() );
  mView->setField( pdal::Dimension::Id::NumberOfReturns, pointNumber, map[u"NumberOfReturns"_s].toInt() );
  mView->setField( pdal::Dimension::Id::ScanDirectionFlag, pointNumber, map[u"ScanDirectionFlag"_s].toInt() );
  mView->setField( pdal::Dimension::Id::EdgeOfFlightLine, pointNumber, map[u"EdgeOfFlightLine"_s].toInt() );
  mView->setField( pdal::Dimension::Id::ScanAngleRank, pointNumber, map[u"ScanAngleRank"_s].toFloat() );
  mView->setField( pdal::Dimension::Id::UserData, pointNumber, map[u"UserData"_s].toInt() );
  mView->setField( pdal::Dimension::Id::PointSourceId, pointNumber, map[u"PointSourceId"_s].toInt() );
 
  if ( mPointFormat == 6 || mPointFormat == 7 || mPointFormat == 8 || mPointFormat == 9 || mPointFormat == 10 )
  {
    mView->setField( pdal::Dimension::Id::ScanChannel, pointNumber, map[u"ScannerChannel"_s].toInt() );
    const int classificationFlags = ( map[u"Synthetic"_s].toInt() & 0x01 ) << 0
                                    | ( map[u"KeyPoint"_s].toInt() & 0x01 ) << 1
                                    | ( map[u"Withheld"_s].toInt() & 0x01 ) << 2
                                    | ( map[u"Overlap"_s].toInt() & 0x01 ) << 3;
    mView->setField( pdal::Dimension::Id::ClassFlags, pointNumber, classificationFlags );
  }
 
  if ( mPointFormat != 0 && mPointFormat != 2 )
  {
    mView->setField( pdal::Dimension::Id::GpsTime, pointNumber, map[u"GpsTime"_s].toDouble() );
  }
 
  if ( mPointFormat == 2 || mPointFormat == 3 || mPointFormat == 5 || mPointFormat == 7 || mPointFormat == 8 || mPointFormat == 10 )
  {
    mView->setField( pdal::Dimension::Id::Red, pointNumber, map[u"Red"_s].toInt() );
    mView->setField( pdal::Dimension::Id::Green, pointNumber, map[u"Green"_s].toInt() );
    mView->setField( pdal::Dimension::Id::Blue, pointNumber, map[u"Blue"_s].toInt() );
  }
 
  if ( mPointFormat == 8 || mPointFormat == 10 )
  {
    mView->setField( pdal::Dimension::Id::Infrared, pointNumber, map[u"Infrared"_s].toInt() );
  }
}
 
void QgsPointCloudLayerExporter::ExporterPdal::handleNode()
{}
 
void QgsPointCloudLayerExporter::ExporterPdal::handleAll()
{
  pdal::BufferReader reader;
  reader.addView( mView );
 
  pdal::StageFactory factory;
 
  pdal::Stage *writer = factory.createStage( "writers.las" );
 
  writer->setInput( reader );
  writer->setOptions( mOptions );
  writer->prepare( mTable );
  writer->execute( mTable );
}
#endif
 
//
// QgsPointCloudLayerExporterTask
//
 
QgsPointCloudLayerExporterTask::QgsPointCloudLayerExporterTask( QgsPointCloudLayerExporter *exporter )
  : QgsTask( tr( "Exporting point cloud" ), QgsTask::CanCancel )
  , mExp( exporter )
  , mOwnedFeedback( new QgsFeedback() )
{}
 
void QgsPointCloudLayerExporterTask::cancel()
{
  mOwnedFeedback->cancel();
  QgsTask::cancel();
}
 
bool QgsPointCloudLayerExporterTask::run()
{
  if ( !mExp )
    return false;
 
  connect( mOwnedFeedback.get(), &QgsFeedback::progressChanged, this, &QgsPointCloudLayerExporterTask::setProgress );
  mExp->setFeedback( mOwnedFeedback.get() );
 
  mExp->doExport();
 
  return true;
}
 
void QgsPointCloudLayerExporterTask::finished( bool result )
{
  Q_UNUSED( result )
 
  emit exportComplete();
  delete mExp;
}