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 "qgis_core.h"
#include "qgsrectangle.h"
#include "qgsvector3d.h"
#include "qgis_sip.h"
#include "qgspointcloudblock.h"
#include "qgsrange.h"
#include "qgspointcloudattribute.h"
#include "qgsstatisticalsummary.h"
 
#define SIP_NO_FILE
 
class QgsPointCloudRequest;
class QgsPointCloudAttributeCollection;
class QgsCoordinateReferenceSystem;
class QgsPointCloudBlockRequest;
 
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 QgsPointCloudDataBounds
{
  public:
    QgsPointCloudDataBounds();
    QgsPointCloudDataBounds( qint32 xmin, qint32 ymin, qint32 zmin, qint32 xmax, qint32 ymax, qint32 zmax );
 
    qint32 xMin() const;
 
    qint32 yMin() const;
 
    qint32 zMin() const;
 
    qint32 xMax() const;
 
    qint32 yMax() const;
 
    qint32 zMax() const;
 
    QgsRectangle mapExtent( const QgsVector3D &offset, const QgsVector3D &scale ) const;
 
    QgsDoubleRange zRange( const QgsVector3D &offset, const QgsVector3D &scale ) const;
 
  private:
    qint32 mXMin, mYMin, mZMin, mXMax, mYMax, mZMax;
};
 
class CORE_EXPORT QgsPointCloudIndex: public QObject
{
    Q_OBJECT
  public:
    enum AccessType
    {
      Local, 
      Remote 
    };
 
    explicit QgsPointCloudIndex();
    ~QgsPointCloudIndex();
 
    virtual void load( const QString &fileName ) = 0;
 
    virtual bool isValid() const = 0;
 
    virtual AccessType accessType() const = 0;
 
    virtual QgsCoordinateReferenceSystem crs() const = 0;
    virtual qint64 pointCount() const = 0;
    virtual QVariant metadataStatistic( const QString &attribute, QgsStatisticalSummary::Statistic statistic ) const = 0;
    virtual QVariantList metadataClasses( const QString &attribute ) const = 0;
    virtual QVariant metadataClassStatistic( const QString &attribute, const QVariant &value, QgsStatisticalSummary::Statistic statistic ) const = 0;
    virtual QVariantMap originalMetadata() const = 0;
 
    IndexedPointCloudNode root() { return IndexedPointCloudNode( 0, 0, 0, 0 ); }
 
    virtual bool hasNode( const IndexedPointCloudNode &n ) const;
 
    virtual QList<IndexedPointCloudNode> nodeChildren( const IndexedPointCloudNode &n ) const;
 
    QgsPointCloudAttributeCollection attributes() const;
 
    virtual 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 );
 
  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;  
};
 
#endif // QGSPOINTCLOUDINDEX_H