WebMercatorTiledImageManager.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: NDEVR
File: WebMercatorTiledImageManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/ProgressInfo.h>
#include <NDEVR/MercatorImageManager.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/QueueBuffer.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/UUID.h>
#include <QImage>
class QNetworkAccessManager;
namespace NDEVR
{
    struct WebMercatorTileReply;
    struct WebMercatorTileRequest
    {
        WebMercatorTileRequest() {};
        WebMercatorTileRequest(MercatorImageRequest request, WebMercatorTile tile)
            : tile(tile)
            , request(request)
        {}
        WebMercatorTile tile; 
        MercatorImageRequest request; 
        std::function<void(WebMercatorTileReply& reply)> finished_callback; 
    };

    class GoogleWebMercatorTileService : public WebMercatorTileService
    {
    public:
        enum class GoogleLayer
        {
            e_satellite, 
            e_road, 
            e_terrain, 
            e_hybrid, 
        };

        GoogleWebMercatorTileService(GoogleLayer layer);
 
        GoogleWebMercatorTileService() = delete;
        virtual ~GoogleWebMercatorTileService() = default;
        GoogleWebMercatorTileService(const GoogleWebMercatorTileService& other) = default;
        GoogleWebMercatorTileService(GoogleWebMercatorTileService&& other) = default;
        GoogleWebMercatorTileService& operator=(const GoogleWebMercatorTileService& other) = default;
        GoogleWebMercatorTileService& operator=(GoogleWebMercatorTileService&& other) = default;

        String getUrl(WebMercatorTile tile, const MercatorImageRequest& request) const final override;
        UUID getUUID(WebMercatorTile tile, const MercatorImageRequest& request) const final override;
        static uint04 URLFeatureCode(ArialFeatureList item);

        Buffer<WebMercatorTile::Resolution> getSupportedResolutions() const final override;
        Buffer<WebMercatorTile::DPI> getSupportedDPIs() const final override;
    protected:
        GoogleLayer m_layer = GoogleLayer::e_satellite; 
        String m_secret; 
        void buildSecrets(WebMercatorTile tile, String& secret_1, String& secret_2) const;
    };

    class OpenStreetMapWebMercatorTileService : public WebMercatorTileService
    {
    public:
        OpenStreetMapWebMercatorTileService() = default;
        virtual ~OpenStreetMapWebMercatorTileService() = default;
        OpenStreetMapWebMercatorTileService(const OpenStreetMapWebMercatorTileService& other) = default;
        OpenStreetMapWebMercatorTileService(OpenStreetMapWebMercatorTileService&& other) = default;
        OpenStreetMapWebMercatorTileService& operator=(const OpenStreetMapWebMercatorTileService& other) = default;
        OpenStreetMapWebMercatorTileService& operator=(OpenStreetMapWebMercatorTileService&& other) = default;

        String getUrl(WebMercatorTile tile, const MercatorImageRequest& request) const final override;
        UUID getUUID(WebMercatorTile tile, const MercatorImageRequest& request) const final override;
        Buffer<WebMercatorTile::Resolution> getSupportedResolutions() const final override;
        Buffer<WebMercatorTile::DPI> getSupportedDPIs() const final override;
    };

    struct WebMercatorTileReply
    {
        Vector<2, uint04> tile_location; 
        bool success = false; 
        QImage image; 
    };

    class EPSG4326TileHelper
    {
    public:
        enum class TileLocation
        {
            e_center, 
            e_north_east, 
            e_south_west, 
            e_south_east, 
            e_north_west, 
        };

        static fltp08 EPSG4326(uint01 dim, fltp08 lon_deg, uint01 z, fltp08 scale_factor = 1.0);

        fltp08 tile_x_to_EPSG4326_lon_deg(uint04 x, uint04 z, TileLocation location, fltp08 scale_factor = 1.0) const;
        fltp08 tile_x_to_EPSG4326_lon_deg(uint04 x, uint04 z, fltp08 percent_x, fltp08 scale_factor = 1.0) const;

        fltp08 tile_y_to_EPSG4326_lat_deg(uint04 y, uint04 z, TileLocation location, fltp08 scale_factor = 1.0) const;
        fltp08 tile_y_to_EPSG4326_lat_deg(uint04 y, uint04 z, fltp08 percent_y, fltp08 scale_factor = 1.0) const;

        static Bounds<2, fltp08> TileSpace(Bounds<2, fltp08> lat_long_bounds, Vector<2, uint04> size, fltp08 scale_factor = 1.0);
        static uint01 CalcZoom(Bounds<2, fltp08> lat_long_bounds_wgs84_dd, Vector<2, uint04> size);
 
    public:
        static EPSG4326TileHelper& DefaultHelper();
    };

    class MercatorWebImageManager : public MercatorImageManager
    {
    public:
        MercatorWebImageManager();
        static void Initialize();

        DynamicPointer<WebMercatorTileService> defaultService(AerialImageMode mode) const override;
        bool getTile(const WebMercatorTileRequest& request);
        virtual bool postRequest(const MercatorImageRequest& request, std::function<void(const MercatorImage&)> finished_callback) override;
        virtual bool postRequest(const AerialImageRequest& request) override;
        bool getImage(const MercatorImageRequest& request, std::function<void(const MercatorImage&)> finished_callback);
    public:
        static MercatorWebImageManager& DefaultManager();
        fltp08 devicePixelRatio() const { return m_device_pixel_ratio; };
        void setDevicePixelRatio(fltp08 device_pixel_ratio) override { m_device_pixel_ratio = device_pixel_ratio; };
    protected:
        bool getImage(const AerialImageRequest& request);
        void finish(const String& id, const WebMercatorTileRequest& request);
        bool hasPendingRequest(const UUID& id) const;
        void finish(bool success, const MercatorImageRequest& request, std::function<void(const MercatorImage&)> finished_callback);
        void executePendingRequest(const UUID& id);
        Dictionary<UUID, QueueBuffer<WebMercatorTileRequest>> m_pending_web_requests; 
        Dictionary<UUID, QImage> m_image_buffers; 
        Dictionary<UUID, UUID> m_image_get_id; 
        fltp08 m_device_pixel_ratio = 1.0; 
        QNetworkAccessManager* m_network_manager = nullptr; 
        UUID m_wgs_84 = Constant<UUID>::Invalid; 
        friend class MercatorProcessThread;
#if NDEVR_SUPPORTS_THREADING
        MercatorProcessThread* m_thread; 
#endif
        ProgressInfo m_progress; 
    };
}