qgspointclouddataprovider.h

Go to the documentation of this file.

/***************************************************************************
                         qgspointclouddataprovider.h
                         ---------------------
    begin                : October 2020
    copyright            : (C) 2020 by Peter Petrik
    email                : zilolv 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 QGSPOINTCLOUDDATAPROVIDER_H
#define QGSPOINTCLOUDDATAPROVIDER_H
 
#include "qgis_core.h"
#include "qgsdataprovider.h"
#include "qgspointcloudattribute.h"
#include "qgspointcloudindex.h"
#include "qgspointcloudsubindex.h"
#include "qgspoint.h"
#include "qgsray3d.h"
#include <memory>
 
class IndexedPointCloudNode;
class QgsPointCloudIndex;
class QgsPointCloudRenderer;
class QgsGeometry;
class QgsPointCloudStatistics;
 
class CORE_EXPORT QgsPointCloudDataProvider: public QgsDataProvider
{
    Q_OBJECT
  public:
 
    enum Capability SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0,       
      ReadLayerMetadata = 1 << 0, 
      WriteLayerMetadata = 1 << 1, 
      CreateRenderer = 1 << 2, 
      ContainSubIndexes = 1 << 3, 
    };
 
    Q_DECLARE_FLAGS( Capabilities, Capability )
 
    
    enum PointCloudIndexGenerationState SIP_ENUM_BASETYPE( IntFlag )
    {
      NotIndexed = 0, 
      Indexing = 1 << 0, 
      Indexed = 1 << 1 
    };
 
    QgsPointCloudDataProvider( const QString &uri,
                               const QgsDataProvider::ProviderOptions &providerOptions,
                               QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags() );
 
    ~QgsPointCloudDataProvider() override;
 
#ifndef SIP_RUN
 
    QVector<QVariantMap> identify( double maxError, const QgsGeometry &extentGeometry, const QgsDoubleRange &extentZRange = QgsDoubleRange(), int pointsLimit = 1000 );
#else
 
    SIP_PYLIST identify( float maxErrorInMapCoords, QgsGeometry extentGeometry, const QgsDoubleRange extentZRange = QgsDoubleRange(), int pointsLimit = 1000 );
    % MethodCode
    {
      QVector<QMap<QString, QVariant>> res = sipCpp->identify( a0, *a1, *a2, a3 );
      sipRes = PyList_New( res.size() );
      for ( int i = 0; i < res.size(); ++i )
      {
        PyObject *dict = PyDict_New();
        for ( QString key : res[i].keys() )
        {
          PyObject *keyObj = sipConvertFromNewType( new QString( key ), sipType_QString, Py_None );
          PyObject *valObj = sipConvertFromNewType( new QVariant( res[i][key] ), sipType_QVariant, Py_None );
          PyDict_SetItem( dict, keyObj, valObj );
        }
        PyList_SET_ITEM( sipRes, i, dict );
      }
    }
    % End
#endif
 
    virtual QgsPointCloudDataProvider::Capabilities capabilities() const;
 
    virtual QgsPointCloudAttributeCollection attributes() const = 0;
 
    virtual void loadIndex( ) = 0;
 
    virtual void generateIndex( ) = 0;
 
 
    virtual PointCloudIndexGenerationState indexingState( ) = 0;
 
    virtual QgsPointCloudIndex *index() const SIP_SKIP {return nullptr;}
 
    virtual QVector<QgsPointCloudSubIndex> subIndexes() SIP_SKIP { return QVector<QgsPointCloudSubIndex>(); }
 
    virtual void loadSubIndex( int n ) SIP_SKIP { Q_UNUSED( n ) return; }
 
    bool hasValidIndex() const;
 
    virtual qint64 pointCount() const = 0;
 
    virtual QgsGeometry polygonBounds() const;
 
    virtual QVariantMap originalMetadata() const;
 
    virtual QgsPointCloudRenderer *createRenderer( const QVariantMap &configuration = QVariantMap() ) const SIP_FACTORY;
 
    virtual bool hasStatisticsMetadata() const;
 
#ifndef SIP_RUN
 
    virtual QVariant metadataStatistic( const QString &attribute, Qgis::Statistic statistic ) const;
#else
 
    SIP_PYOBJECT metadataStatistic( const QString &attribute, Qgis::Statistic statistic ) const;
    % MethodCode
    {
      const QVariant res = sipCpp->metadataStatistic( *a0, a1 );
      if ( !res.isValid() )
      {
        PyErr_SetString( PyExc_ValueError, QStringLiteral( "Statistic is not available" ).toUtf8().constData() );
        sipIsErr = 1;
      }
      else
      {
        QVariant *v = new QVariant( res );
        sipRes = sipConvertFromNewType( v, sipType_QVariant, Py_None );
      }
    }
    % End
#endif
 
    virtual QVariantList metadataClasses( const QString &attribute ) const;
 
 
#ifndef SIP_RUN
 
    virtual QVariant metadataClassStatistic( const QString &attribute, const QVariant &value, Qgis::Statistic statistic ) const;
 
#else
 
    SIP_PYOBJECT metadataClassStatistic( const QString &attribute, const QVariant &value, Qgis::Statistic statistic ) const;
    % MethodCode
    {
      const QVariant res = sipCpp->metadataClassStatistic( *a0, *a1, a2 );
      if ( !res.isValid() )
      {
        PyErr_SetString( PyExc_ValueError, QStringLiteral( "Statistic is not available" ).toUtf8().constData() );
        sipIsErr = 1;
      }
      else
      {
        QVariant *v = new QVariant( res );
        sipRes = sipConvertFromNewType( v, sipType_QVariant, Py_None );
      }
    }
    % End
#endif
 
 
    QgsPointCloudStatistics metadataStatistics();
 
    bool supportsSubsetString() const override { return true; }
    QString subsetString() const override;
    bool setSubsetString( const QString &subset, bool updateFeatureCount = false ) override;
 
    static QMap< int, QString > lasClassificationCodes();
 
    static QMap< int, QString > translatedLasClassificationCodes();
 
    static QMap< int, QString > dataFormatIds();
 
    static QMap< int, QString > translatedDataFormatIds();
 
  signals:
 
    void indexGenerationStateChanged( QgsPointCloudDataProvider::PointCloudIndexGenerationState state );
 
  protected:
    QString mSubsetString;
 
  private:
    QVector<IndexedPointCloudNode> traverseTree( const QgsPointCloudIndex *pc, IndexedPointCloudNode n, double maxError, double nodeError, const QgsGeometry &extentGeometry, const QgsDoubleRange &extentZRange );
 
};
 
#endif // QGSMESHDATAPROVIDER_H