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;

    QVector<QgsPointCloudNodeId> childrenNodes() const;

    static QgsPointCloudNodeId fromString( const QString &str );

    QString toString() const;

    int d() const;

    int x() const;

    int y() const;

    int z() const;
 
    // clang-format off
#ifdef SIP_RUN
    long __hash__() const;
    % MethodCode
    sipRes = qHash( *sipCpp );
    % End
#endif
 
  private:
    int mD = -1, mX = -1, mY = -1, mZ = -1;
    // clang-format on
};
 
Q_DECLARE_TYPEINFO( QgsPointCloudNodeId, Q_PRIMITIVE_TYPE );

inline size_t qHash( QgsPointCloudNodeId id, size_t seed = 0 )
{
  return qHashMulti( seed, id.d(), id.x(), id.y(), id.z() );
}
 
 
#ifndef SIP_RUN

class CORE_EXPORT QgsPointCloudCacheKey
{
  public:
    QgsPointCloudCacheKey( 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;
};

inline size_t qHash( const QgsPointCloudCacheKey &key, size_t seed = 0 )
{
  return qHashMulti( seed, key.node(), key.request(), key.uri(), key.subsetString() );
}
 
#endif // !SIP_RUN

class CORE_EXPORT QgsPointCloudNode
{
  public:
    QgsPointCloudNode( 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( QgsPointCloudNodeId n ) const;

    virtual QgsPointCloudNode getNode( QgsPointCloudNodeId id ) const;

    QgsPointCloudAttributeCollection attributes() const;

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

    virtual QgsPointCloudBlockRequest *asyncNodeData( 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( QgsPointCloudNodeId node, const QgsPointCloudRequest &request );

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

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

    virtual QVariantMap extraMetadata() const;

    QString uri() const { return mUri; }

    virtual bool needsHierarchyFetching( const QgsPointCloudNodeId & ) const { return false; }
 
  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( QgsPointCloudNodeId id ) const;

    QgsPointCloudNode getNode( QgsPointCloudNodeId id ) const;

    QgsPointCloudAttributeCollection attributes() const;

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

    QgsPointCloudBlockRequest *asyncNodeData( 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( QgsPointCloudNodeId node, const QgsPointCloudRequest &request ) SIP_SKIP;

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

    QVariantMap extraMetadata() const;

    bool commitChanges( QString *errorMessage SIP_OUT = nullptr );

    bool isModified() const;

    QList<QgsPointCloudNodeId> updatedNodes() const;

    QString uri() const;

    bool needsHierarchyFetching( const QgsPointCloudNodeId &node ) const;
 
  private:
    std::shared_ptr<QgsAbstractPointCloudIndex> mIndex;
 
    friend class TestQgsPointCloudEditing;
};
 
 
#endif // QGSPOINTCLOUDINDEX_H