palrtree.h

Go to the documentation of this file.

/***************************************************************************
  parlrtree.h
  ------------------------
  Date                 : December 2019
  Copyright            : (C) 2019 by Nyall Dawson
  Email                : nyall dot dawson 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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include <array>
 
#include "RTree.h"
#include "qgsrectangle.h"
 
#define SIP_NO_FILE
 
#ifndef QGSPALRTREE_H
#define QGSPALRTREE_H
 

template <typename T>
class PalRtree : public RTree<T *, float, 2, float>
{
  public:

    PalRtree( const QgsRectangle &maxBounds )
      : mXMin( maxBounds.xMinimum() )
      , mYMin( maxBounds.yMinimum() )
      , mXRes( ( std::numeric_limits< float >::max() - 1 ) / ( maxBounds.xMaximum() - maxBounds.xMinimum() ) )
      , mYRes( ( std::numeric_limits< float >::max() - 1 ) / ( maxBounds.yMaximum() - maxBounds.yMinimum() ) )
      , mMaxBounds( maxBounds )
    {
 
    }

    void insert( T *data, const QgsRectangle &bounds )
    {
      std::array< float, 4 > scaledBounds = scaleBounds( bounds );
      const float aMin[2]
      {
        scaledBounds[0], scaledBounds[ 1]
      };
      const float aMax[2]
      {
        scaledBounds[2], scaledBounds[ 3]
      };
      this->Insert(
        aMin,
        aMax,
        data );
    }

    void remove( T *data, const QgsRectangle &bounds )
    {
      std::array< float, 4 > scaledBounds = scaleBounds( bounds );
      const float aMin[2]
      {
        scaledBounds[0], scaledBounds[ 1]
      };
      const float aMax[2]
      {
        scaledBounds[2], scaledBounds[ 3]
      };
      this->Remove(
        aMin,
        aMax,
        data );
    }

    bool intersects( const QgsRectangle &bounds, const std::function< bool( T *data )> &callback ) const
    {
      std::array< float, 4 > scaledBounds = scaleBounds( bounds );
      const float aMin[2]
      {
        scaledBounds[0], scaledBounds[ 1]
      };
      const float aMax[2]
      {
        scaledBounds[2], scaledBounds[ 3]
      };
      this->Search(
        aMin, aMax,
        callback );
      return true;
    }
 
  private:
 
    // Coordinates are scaled inside the index so that they cover the maximum range for float values
    double mXMin = 0;
    double mYMin = 0;
    double mXRes = 1;
    double mYRes = 1;
    const QgsRectangle mMaxBounds;
    std::array<float, 4> scaleBounds( const QgsRectangle &bounds ) const
    {
      return
      {
        static_cast< float >( ( std::max( bounds.xMinimum(), mMaxBounds.xMinimum() ) - mXMin ) / mXRes ),
        static_cast< float >( ( std::max( bounds.yMinimum(), mMaxBounds.yMinimum() ) - mYMin ) / mYRes ),
        static_cast< float >( ( std::min( bounds.xMaximum(), mMaxBounds.xMaximum() ) - mXMin ) / mXRes ),
        static_cast< float >( ( std::min( bounds.yMaximum(), mMaxBounds.yMaximum() ) - mYMin ) / mYRes )
      };
    }
};
 
#endif