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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgsbox3d.h"
#include "qgspointcloudattribute.h"
#include "qgspointcloudblock.h"
#include "qgspointcloudexpression.h"
#include "qgspointcloudrequest.h"
#include "qgspointcloudstatistics.h"
#include "qgsrectangle.h"
 
#include <QByteArray>
#include <QCache>
#include <QHash>
#include <QList>
#include <QMutex>
#include <QString>
#include <QStringList>
#include <QVector>
 
class QgsPointCloudAttributeCollection;
class QgsCoordinateReferenceSystem;
class QgsPointCloudBlockRequest;
class QgsPointCloudStatistics;
class QgsAbstractPointCloudIndex;

class CORE_EXPORT QgsPointCloudNodeId
{
  public:
    QgsPointCloudNodeId();
    QgsPointCloudNodeId( int _d, int _x, int _y, int _z );

    bool isValid() const { return mD >= 0; }
 
    // TODO c++20 - replace with = default
 
    bool operator==( QgsPointCloudNodeId other ) const
    {
      return mD == other.d() && mX == other.x() && mY == other.y() && mZ == other.z();
    }

    QgsPointCloudNodeId parentNode() const;

    static QgsPointCloudNodeId 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( QgsPointCloudNodeId, Q_PRIMITIVE_TYPE );

CORE_EXPORT uint qHash( QgsPointCloudNodeId id );
 
#ifndef SIP_RUN

class CORE_EXPORT QgsPointCloudCacheKey
{
  public:
    QgsPointCloudCacheKey( const QgsPointCloudNodeId &n, const QgsPointCloudRequest &request, const QString &subset, const QString &uri );
 
    bool operator==( const QgsPointCloudCacheKey &other ) const;

    QgsPointCloudNodeId node() const { return mNode; }

    QString uri() const { return mUri; }

    QgsPointCloudRequest request() const { return mRequest; }

    QString subsetString() const { return mSubsetString; }
 
  private:
    QgsPointCloudNodeId mNode;
    QString mUri;
    QgsPointCloudRequest mRequest;
    QString mSubsetString;
};

uint qHash( const QgsPointCloudCacheKey &key );
 
#endif // !SIP_RUN

class CORE_EXPORT QgsPointCloudNode
{
  public:

    QgsPointCloudNode( const QgsPointCloudNodeId &id,
                       qint64 pointCount,
                       const QList<QgsPointCloudNodeId> &childIds,
                       float error,
                       const QgsBox3D &bounds )
      : mId( id )
      , mPointCount( pointCount )
      , mChildIds( childIds )
      , mError( error )
      , mBounds( bounds )
    {
    }

    QgsPointCloudNodeId id() const { return mId; }
    qint64 pointCount() const { return mPointCount; }
    QList<QgsPointCloudNodeId> children() const { return mChildIds; }
    float error() const;
    QgsBox3D bounds() const;

    static QgsBox3D bounds( QgsBox3D rootBounds, QgsPointCloudNodeId id );
 
  private:
    // Specific node metadata:
    QgsPointCloudNodeId mId;
    qint64 mPointCount;
    QList<QgsPointCloudNodeId> mChildIds;
    float mError;
    QgsBox3D mBounds;
};
 
 
#ifndef SIP_RUN

class CORE_EXPORT QgsAbstractPointCloudIndex
{
  public:
    explicit QgsAbstractPointCloudIndex();
    virtual ~QgsAbstractPointCloudIndex();

    virtual void load( const QString &uri, const QString &authcfg = QString() ) = 0;

    virtual bool isValid() const = 0;

    QString error() const { return mError; }

    virtual Qgis::PointCloudAccessType accessType() const = 0;

    virtual QgsCoordinateReferenceSystem crs() const = 0;
    virtual qint64 pointCount() const = 0;
    virtual QVariantMap originalMetadata() const = 0;

    virtual QgsPointCloudStatistics metadataStatistics() const;

    virtual bool writeStatistics( QgsPointCloudStatistics &stats );

    QgsPointCloudNodeId root() const { return QgsPointCloudNodeId( 0, 0, 0, 0 ); }

    virtual bool hasNode( const QgsPointCloudNodeId &n ) const;

    virtual QgsPointCloudNode getNode( const QgsPointCloudNodeId &id ) const;

    QgsPointCloudAttributeCollection attributes() const;

    virtual std::unique_ptr< QgsPointCloudBlock > nodeData( const QgsPointCloudNodeId &n, const QgsPointCloudRequest &request ) = 0;

    virtual QgsPointCloudBlockRequest *asyncNodeData( const QgsPointCloudNodeId &n, const QgsPointCloudRequest &request ) = 0;

    virtual bool updateNodeData( const QHash<QgsPointCloudNodeId, QByteArray> &data );

    QgsRectangle extent() const { return mExtent; }

    double zMin() const { return mZMin; }
    double zMax() const { return mZMax; }

    QgsBox3D rootNodeBounds() const { return mRootBounds; }

    QgsVector3D scale() const;

    QgsVector3D offset() const;

    int span() const;

    virtual bool setSubsetString( const QString &subset );

    virtual QString subsetString() const;

    void copyCommonProperties( QgsAbstractPointCloudIndex *destination ) const;

    QgsPointCloudBlock *getNodeDataFromCache( const QgsPointCloudNodeId &node, const QgsPointCloudRequest &request );

    void storeNodeDataToCache( QgsPointCloudBlock *data, const QgsPointCloudNodeId &node, const QgsPointCloudRequest &request ) const;

    static void storeNodeDataToCacheStatic( QgsPointCloudBlock *data, const QgsPointCloudNodeId &node, const QgsPointCloudRequest &request,
                                            const QgsPointCloudExpression &expression, const QString &uri );

    virtual QVariantMap extraMetadata() const;
 
  protected: //TODO private
    void setAttributes( const QgsPointCloudAttributeCollection &attributes );
 
    QgsRectangle mExtent;  
    double mZMin = 0, mZMax = 0;   
 
    mutable QMutex mHierarchyMutex;
    mutable QHash<QgsPointCloudNodeId, int> mHierarchy; 
    QgsVector3D mScale; 
    QgsVector3D mOffset; 
    QgsBox3D mRootBounds;  
    QgsPointCloudAttributeCollection mAttributes; 
    int mSpan = 0;  
    QgsPointCloudExpression mFilterExpression;  
 
    QString mError;
    QString mUri;
    QString mAuthCfg;
    static QMutex sBlockCacheMutex;
    static QCache<QgsPointCloudCacheKey, QgsPointCloudBlock> sBlockCache;
};
 
#endif // !SIP_RUN
 

class CORE_EXPORT QgsPointCloudIndex SIP_NODEFAULTCTORS
{
  public:
    explicit QgsPointCloudIndex( QgsAbstractPointCloudIndex *index = nullptr ) SIP_SKIP;

    operator bool() const;

    QgsAbstractPointCloudIndex *get() SIP_SKIP { return mIndex.get(); }

    void load( const QString &url, const QString &authcfg = QString() );

    bool isValid() const;

    QString error() const;

    Qgis::PointCloudAccessType accessType() const;

    QgsCoordinateReferenceSystem crs() const;

    qint64 pointCount() const;

    QVariantMap originalMetadata() const;

    QgsPointCloudStatistics metadataStatistics() const;

    bool writeStatistics( QgsPointCloudStatistics &stats );

    QgsPointCloudNodeId root() const;

    bool hasNode( const QgsPointCloudNodeId &id ) const;

    QgsPointCloudNode getNode( const QgsPointCloudNodeId &id ) const;

    QgsPointCloudAttributeCollection attributes() const;

    std::unique_ptr< QgsPointCloudBlock > nodeData( const QgsPointCloudNodeId &n, const QgsPointCloudRequest &request ) SIP_SKIP;

    QgsPointCloudBlockRequest *asyncNodeData( const QgsPointCloudNodeId &n, const QgsPointCloudRequest &request ) SIP_SKIP;

    bool updateNodeData( const QHash<QgsPointCloudNodeId, QByteArray> &data );

    QgsRectangle extent() const;

    double zMin() const;

    double zMax() const;

    QgsBox3D rootNodeBounds() const;

    QgsVector3D scale() const;

    QgsVector3D offset() const;

    int span() const;

    bool setSubsetString( const QString &subset );

    QString subsetString() const;

    QgsPointCloudBlock *getNodeDataFromCache( const QgsPointCloudNodeId &node, const QgsPointCloudRequest &request ) SIP_SKIP;

    void storeNodeDataToCache( QgsPointCloudBlock *data, const QgsPointCloudNodeId &node, const QgsPointCloudRequest &request ) SIP_SKIP;

    QVariantMap extraMetadata() const;

    bool commitChanges( QString *errorMessage SIP_OUT = nullptr );

    bool isModified() const;

    QList<QgsPointCloudNodeId> updatedNodes() const;
 
  private:
    std::shared_ptr<QgsAbstractPointCloudIndex> mIndex;
 
    friend class TestQgsPointCloudEditing;
};
 
 
#endif // QGSPOINTCLOUDINDEX_H