qgspointcloudindex.h

Go to the documentation of this file.

/***************************************************************************
                         qgspointcloudindex.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 QGSPOINTCLOUDINDEX_H
#define QGSPOINTCLOUDINDEX_H
 
#include <QObject>
#include <QString>
#include <QHash>
#include <QStringList>
#include <QVector>
#include <QList>
#include <QMutex>
#include <QCache>
 
#include "qgis_core.h"
#include "qgsrectangle.h"
#include "qgsvector3d.h"
#include "qgis_sip.h"
#include "qgspointcloudblock.h"
#include "qgsrange.h"
#include "qgspointcloudattribute.h"
#include "qgspointcloudexpression.h"
#include "qgspointcloudrequest.h"
 
#define SIP_NO_FILE
 
class QgsPointCloudRequest;
class QgsPointCloudAttributeCollection;
class QgsCoordinateReferenceSystem;
class QgsPointCloudBlockRequest;
class QgsPointCloudStatistics;
class QgsPointCloudIndex;
 
class CORE_EXPORT IndexedPointCloudNode
{
  public:
    IndexedPointCloudNode();
    IndexedPointCloudNode( int _d, int _x, int _y, int _z );
 
    bool isValid() const { return mD >= 0; }
 
    // TODO c++20 - replace with = default
 
    bool operator==( IndexedPointCloudNode other ) const
    {
      return mD == other.d() && mX == other.x() && mY == other.y() && mZ == other.z();
    }
 
    IndexedPointCloudNode parentNode() const;
 
    static IndexedPointCloudNode fromString( const QString &str );
 
    QString toString() const;
 
    int d() const;
 
    int x() const;
 
    int y() const;
 
    int z() const;
 
  private:
    int mD = -1, mX = -1, mY = -1, mZ = -1;
};
 
Q_DECLARE_TYPEINFO( IndexedPointCloudNode, Q_PRIMITIVE_TYPE );
 
CORE_EXPORT uint qHash( IndexedPointCloudNode id );
 
class CORE_EXPORT QgsPointCloudCacheKey
{
  public:
    QgsPointCloudCacheKey( const IndexedPointCloudNode &n, const QgsPointCloudRequest &request, const QgsPointCloudExpression &expression, const QString &uri );
 
    bool operator==( const QgsPointCloudCacheKey &other ) const;
 
    IndexedPointCloudNode node() const { return mNode; }
 
    QString uri() const { return mUri; }
 
    QgsPointCloudRequest request() const { return mRequest; }
 
    QgsPointCloudExpression filterExpression() const { return mFilterExpression; }
 
  private:
    IndexedPointCloudNode mNode;
    QString mUri;
    QgsPointCloudRequest mRequest;
    QgsPointCloudExpression mFilterExpression;
};
 
uint qHash( const QgsPointCloudCacheKey &key );
 
class CORE_EXPORT QgsPointCloudDataBounds
{
  public:
    QgsPointCloudDataBounds();
    QgsPointCloudDataBounds( qint64 xmin, qint64 ymin, qint64 zmin, qint64 xmax, qint64 ymax, qint64 zmax );
 
    qint64 xMin() const;
 
    qint64 yMin() const;
 
    qint64 zMin() const;
 
    qint64 xMax() const;
 
    qint64 yMax() const;
 
    qint64 zMax() const;
 
    QgsRectangle mapExtent( const QgsVector3D &offset, const QgsVector3D &scale ) const;
 
    QgsDoubleRange zRange( const QgsVector3D &offset, const QgsVector3D &scale ) const;
 
  private:
    qint64 mXMin = 0;
    qint64 mYMin = 0;
    qint64 mZMin = 0;
    qint64 mXMax = 0;
    qint64 mYMax = 0;
    qint64 mZMax = 0;
};
 
class CORE_EXPORT QgsPointCloudIndex: public QObject
{
    Q_OBJECT
  public:
    enum AccessType
    {
      Local, 
      Remote 
    };
 
    explicit QgsPointCloudIndex();
    ~QgsPointCloudIndex();
 
    virtual std::unique_ptr<QgsPointCloudIndex> clone() const = 0;
 
    virtual void load( const QString &fileName ) = 0;
 
    virtual bool isValid() const = 0;
 
    QString error() const { return mError; }
 
    virtual AccessType accessType() const = 0;
 
    virtual QgsCoordinateReferenceSystem crs() const = 0;
    virtual qint64 pointCount() const = 0;
    virtual bool hasStatisticsMetadata() const = 0;
    virtual QVariant metadataStatistic( const QString &attribute, Qgis::Statistic statistic ) const;
    virtual QVariantList metadataClasses( const QString &attribute ) const;
    virtual QVariant metadataClassStatistic( const QString &attribute, const QVariant &value, Qgis::Statistic statistic ) const;
    virtual QVariantMap originalMetadata() const = 0;
 
    virtual QgsPointCloudStatistics metadataStatistics() const;
 
    IndexedPointCloudNode root() { return IndexedPointCloudNode( 0, 0, 0, 0 ); }
 
    virtual bool hasNode( const IndexedPointCloudNode &n ) const;
 
    virtual qint64 nodePointCount( const IndexedPointCloudNode &n ) const;
 
    virtual QList<IndexedPointCloudNode> nodeChildren( const IndexedPointCloudNode &n ) const;
 
    QgsPointCloudAttributeCollection attributes() const;
 
    virtual std::unique_ptr< QgsPointCloudBlock > nodeData( const IndexedPointCloudNode &n, const QgsPointCloudRequest &request ) = 0;
 
    virtual QgsPointCloudBlockRequest *asyncNodeData( const IndexedPointCloudNode &n, const QgsPointCloudRequest &request ) = 0;
 
    QgsRectangle extent() const { return mExtent; }
 
    double zMin() const { return mZMin; }
    double zMax() const { return mZMax; }
 
    QgsPointCloudDataBounds nodeBounds( const IndexedPointCloudNode &node ) const;
 
    QgsRectangle nodeMapExtent( const IndexedPointCloudNode &node ) const;
 
    QgsDoubleRange nodeZRange( const IndexedPointCloudNode &node ) const;
 
    float nodeError( const IndexedPointCloudNode &n ) const;
 
    QgsVector3D scale() const;
 
    QgsVector3D offset() const;
 
    int span() const;
 
    int nodePointCount( const IndexedPointCloudNode &n );
 
    bool setSubsetString( const QString &subset );
 
    QString subsetString() const;
 
    void copyCommonProperties( QgsPointCloudIndex *destination ) const;
 
    QgsPointCloudBlock *getNodeDataFromCache( const IndexedPointCloudNode &node, const QgsPointCloudRequest &request );
 
    void storeNodeDataToCache( QgsPointCloudBlock *data, const IndexedPointCloudNode &node, const QgsPointCloudRequest &request );
 
    static void storeNodeDataToCacheStatic( QgsPointCloudBlock *data, const IndexedPointCloudNode &node, const QgsPointCloudRequest &request,
                                            const QgsPointCloudExpression &expression, const QString &uri );
 
  protected: //TODO private
    void setAttributes( const QgsPointCloudAttributeCollection &attributes );
 
    QgsRectangle mExtent;  
    double mZMin = 0, mZMax = 0;   
 
    mutable QMutex mHierarchyMutex;
    mutable QHash<IndexedPointCloudNode, int> mHierarchy; 
    QgsVector3D mScale; 
    QgsVector3D mOffset; 
    QgsPointCloudDataBounds mRootBounds;  
    QgsPointCloudAttributeCollection mAttributes; 
    int mSpan = 0;  
    QgsPointCloudExpression mFilterExpression;  
 
    QString mError;
    QString mUri;
    static QMutex sBlockCacheMutex;
    static QCache<QgsPointCloudCacheKey, QgsPointCloudBlock> sBlockCache;
};
 
#endif // QGSPOINTCLOUDINDEX_H