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 <QString>
#include <QHash>
#include <QStringList>
#include <QVector>
#include <QList>
#include <QMutex>
#include <QCache>
#include <QByteArray>
 
#include "qgis_core.h"
#include "qgspointcloudstatistics.h"
#include "qgsrectangle.h"
#include "qgsbox3d.h"
#include "qgis_sip.h"
#include "qgspointcloudblock.h"
#include "qgspointcloudattribute.h"
#include "qgspointcloudexpression.h"
#include "qgspointcloudrequest.h"
 
 
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 &fileName ) = 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;
    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 &fileName );
 
    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