MercatorImageManager.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/String.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/RGBColor.h>
namespace NDEVR
{
    class ProgressInfo;
    /**--------------------------------------------------------------------------------------------------
    \brief enum specifying what type of image to fetch. Options for terrain, satellite, or road views
    **/
    enum class AerialImageMode
    {
        e_google_satellite
        , e_google_road
        , e_google_terrain
        , e_google_hybrid
        , e_open_maps
        , e_aerial_image_mode_size//always last
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Contains a list of common features that may be provided by Aerial tile services
    **/
    enum class ArialFeatureList
    {
          e_all = 0
        , e_administrative
        , e_administrative_country
        , administrative_land_parcel
        , administrative_locality
        , administrative_neighborhood
        , administrative_province
        , landscape
        , landscape_man_made
        , landscape_natural
        , poi
        , poi_attraction
        , poi_business
        , poi_government
        , poi_medical
        , poi_park
        , poi_place_of_worship
        , poi_school
        , poi_sports_complex
        , road
        , road_arterial
        , road_highway
        , road_local
        , transit
        , transit_line
        , transit_station
        , water
        , e_feature_list_size
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Allows the user to specify a color theme for a Aerial image request. For example Google allows various colors for roads, buildings, etc
    **/
    struct ArialColorTheme
    {
        ArialColorTheme() {};
        static RGBColor DefaultColor(ArialFeatureList item);
        RGBColor pen = Constant<RGBColor>::Invalid;
        RGBColor brush = Constant<RGBColor>::Invalid;
        bool is_on = true;
 
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A "Tile" containing data for
    **/
    struct NDEVR_DESIGN_API WebMercatorTile
    {
        enum class DPI : uint04
        {
              e_low = 1
            , e_high = 2
            , e_auto
        };
 
        enum class Resolution : uint04
        {
            e_low_256 = 1,
            e_high_512 = 2,
        };
        WebMercatorTile() {};
        WebMercatorTile(uint04 x, uint04 y, uint04 zoom, Resolution resolution, DPI dpi, bool include_labels);
        UUID getUUID(UUID parent_id) const;
 
        static uint04 convertResolutionToPixels(Resolution resolution);
        String language;
        Vector<2, uint04> tile = Vector < 2, uint04>(0U);
        uint04 zoom = 0;
        Resolution resolution = Resolution::e_low_256;
        DPI dpi = DPI::e_low;
        
 
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Information output from a specific Aerial Tile request
    **/
    struct MercatorImage
    {
        UUID request_id;
        bool success = false;
        void* raw_image;
        String image_id;
        Bounds<2, fltp08> wgs_84_bounds;
        Vector<2, fltp08> pixelToLatLon(Vector<2, uint04> pixel) const;
 
    };
    struct MercatorImageRequest;
 
    /**--------------------------------------------------------------------------------------------------
    \brief A wrapper for logic that uses a web engine to provide an Image Tile service.
    **/
    class NDEVR_DESIGN_API WebMercatorTileService
    {
    public:
        virtual ~WebMercatorTileService() = default;
        virtual String getUrl(WebMercatorTile tile, const MercatorImageRequest& request) const = 0;
        virtual UUID getUUID(WebMercatorTile tile, const MercatorImageRequest& request) const = 0;
        virtual Buffer<WebMercatorTile::Resolution> getSupportedResolutions() const = 0;
        virtual Buffer<WebMercatorTile::DPI> getSupportedDPIs() const = 0;
 
        WebMercatorTileService() = default;
        WebMercatorTileService(const WebMercatorTileService& other) = default;
        WebMercatorTileService(WebMercatorTileService&& other) = default;
        WebMercatorTileService& operator=(const WebMercatorTileService& other) = default;
        WebMercatorTileService& operator=(WebMercatorTileService&& other) = default;
    };
 
    /** ----------------------------------------------------------------------------
    Class: AerialImageRequest
 
    \brief Contains the information for requesting a 2D top-down view of a geographic 
        location to be used with a AerialImage service such as google earth.
    =*/
    struct NDEVR_DESIGN_API MercatorImageRequest
    {
        MercatorImageRequest()
        {}
        MercatorImageRequest(const ConstPointer<WebMercatorTileService>& service, Bounds<2, fltp08> bounds, Vector<2, uint04> size, WebMercatorTile::DPI dpi = WebMercatorTile::DPI::e_auto);
        void setBrushToDefault();
        UUID getUUID() const;
        String generated_image;
        ConstPointer<WebMercatorTileService> service = nullptr;
        WebMercatorTile::Resolution getResolution() const;
        fltp08 getScaleFactor() const;
        WebMercatorTile::DPI getDPI() const;
    public:
        ArialColorTheme color_theme[cast<uint04>(ArialFeatureList::e_feature_list_size)];
        Bounds<2, fltp08> bounds_wgs84;
        Vector<2, uint04> size;
        WebMercatorTile::DPI dpi = WebMercatorTile::DPI::e_auto;
        UUID request_id;
        ProgressInfo* log = nullptr;
        bool include_labels = false;
    };
    /** ----------------------------------------------------------------------------
    \brief Contains the information for requesting a 2D top-down view of a geographic 
        location to be used with a AerialImage service such as google earth.
    */
    struct NDEVR_DESIGN_API AerialImageRequest
    {
        AerialImageRequest()
            : request_id(UUID::CreateUUID())
        { }
 
        MercatorImageRequest convertToWebRequest(const DynamicPointer<WebMercatorTileService>& service) const;
        UUID request_id;
        AerialImageMode image_mode = AerialImageMode::e_google_road;
        UUID projection_id = Constant<UUID>::Invalid;
        Bounds<3, fltp08> bounds = Constant<Bounds<3, fltp08>>::Invalid;
        Vector<2, uint04> pixel_size = Constant<Vector<2, uint04>>::Invalid;
        ProgressInfo* log = nullptr;
        std::function<void(const MercatorImage& generated_image)> finished_callback;
    };
    class MercatorProcessThread;
    /** ----------------------------------------------------------------------------
    \brief Place where service can be registered to provide aerial image support.
    */
    class NDEVR_DESIGN_API MercatorImageManager : public SoftwareService
    {
    public:
        MercatorImageManager();
        virtual bool postRequest(const MercatorImageRequest& request, std::function<void(const MercatorImage&)> finished_callback) = 0;
        virtual bool postRequest(const AerialImageRequest& request);
        virtual void setDevicePixelRatio(fltp08) {};
        [[nodiscard]] static MercatorImageManager* PrimaryManager() { return s_manager; }
        [[nodiscard]] virtual DynamicPointer<WebMercatorTileService> defaultService(AerialImageMode mode) const = 0;
    protected:
        static void SetPrimaryManager(MercatorImageManager* manager);
    protected:
        static MercatorImageManager* s_manager;
    };
 
    template class NDEVR_DESIGN_API StringStream<AerialImageMode>;
}