HeatmapShapeModel.h

#pragma once

#include "HeatmapShapes.h"
#include "ShapeModelBase.h"
#include "DoublePlane.h"
#include "StencilMapLayerMask.h"

namespace Eegeo
{
    namespace Shapes
    {
        namespace Heatmaps
        {
            class HeatmapShapeModel : public ShapeModelBase
            {
            public:
                typedef TShapeModelChangedEvent<HeatmapShapeModel> ShapeModelChangedEvent;

                HeatmapShapeModel(
                    IShapeModel::IdType heatmapId,
                    const Resources::Interiors::InteriorId& indoorMapId,
                    int indoorMapFloorId,
                    const dv3& originEcef,
                    const ShapeModelBase::PointOnMapVector& points,
                    const std::vector<double>& perPointElevations,
                    double elevation,
                    const std::vector<u16>& geometryIndices,
                    const Space::LatLong& boundsSouthWest,
                    const Space::LatLong& boundsNorthEast,
                    const std::vector<v3>& untransformedPointsLocalEcef,
                    const Geometry::DoublePlane& polygonBestFitPlane,
                    const std::vector<Eegeo::Space::WeightedLatLongAltitude>& weightedPoints,
                    double weightMin,
                    double weightMax,
                    const v2& textureDimensions,
                    float textureBorderPercent,
                    const std::vector<float>& heatmapDensityStops,
                    const std::vector<double>& heatmapRadiiMeters,
                    const std::vector<double>& heatmapGains,
                    bool useApproximation,
                    float densityBlend,
                    bool interpolateDensityByZoom,
                    double zoomMin,
                    double zoomMax,
                    float opacity,
                    float intensityBias,
                    float intensityScale,
                    u32 occludedStencilMapLayerMask,
                    float occludedAlpha,
                    float occludedSaturation,
                    float occludedBrightness,
                    const std::vector<float>& gradientStops,
                    const std::vector<v4>& gradientColors,
                    ShapeModelChangedEvent& shapeModelChangedEvent,
                    IHeatmapGeometryChangedEvent& heatmapGeometryChangedEvent,
                    IHeatmapGradientChangedEvent& heatmapGradientChangedEvent,
                    IHeatmapDataChangedEvent& heatmapDataChangedEvent,
                    IHeatmapUniformsChangedEvent& heatmapUniformsChangedEvent
                );

                virtual ~HeatmapShapeModel();

                void SetData(
                    const std::vector<Eegeo::Space::WeightedLatLongAltitude>& weightedPoints,
                    double weightMin,
                    double weightMax
                );

                void SetHeatmapDensities(
                    const std::vector<float>& heatmapDensityStops,
                    const std::vector<double>& heatmapRadiiMeters,
                    const std::vector<double>& heatmapGains
                );

                void SetUseApproximation(bool useApproximation);

                void SetDensityBlend(float densityBlend);

                void SetInterpolateDensityByZoom(bool interpolateDensityByZoom);

                void SetZoomMin(double zoomMin);

                void SetZoomMax(double zoomMax);

                void SetIntensityBias(float intensityBias);

                void SetIntensityScale(float intensityScale);

                void SetOpacity(float opacity);

                void SetOccludedStyleAlpha(float alpha);

                void SetOccludedStyleSaturation(float alpha);

                void SetOccludedStyleBrightness(float brightness);

                // Eegeo::Rendering::StencilMapLayerMask::Type
                void SetOccludedStencilMapLayerMask(u32 occludedStencilMapLayerMask);

                void SetGradient(
                    const std::vector<float>& gradientStops,
                    const std::vector<v4>& gradientColors
                );

                void SetTextureDimensions(const v2& textureDimensions);

                const std::vector<Eegeo::Space::WeightedLatLongAltitude>& GetWeightedPoints() const { return m_weightedPoints; }

                double GetWeightMin() const { return m_weightMin; }

                double GetWeightMax() const { return m_weightMax; }

                const v2& GetTextureDimensions() const { return m_textureDimensions; }

                float GetTextureBorderPercent() const { return m_textureBorderPercent; }

                const std::vector<float>& GetHeatmapDensityStops() const { return m_heatmapDensityStops; }

                const std::vector<double>& GetHeatmapRadiiMeters() const { return m_heatmapRadiiMeters; }

                const std::vector<double>& GetHeatmapGains() const { return m_heatmapGains; }

                bool GetUseApproximation() const { return m_useApproximation; }

                float GetDensityBlend() const { return m_densityBlend; }

                bool GetInterpolateDensityByZoom() const { return m_interpolateDensityByZoom; }

                double GetZoomMin() const { return m_zoomMin; }

                double GetZoomMax() const { return m_zoomMax; }

                float GetIntensityBias() const { return m_intensityBias; }

                float GetIntensityScale() const { return m_intensityScale; }

                float GetOpacity() const { return m_opacity; }

                u32 GetOccludedStencilMapLayerMask() const { return m_occludedStencilMapLayerMask; }
                u32 GetNonOccludedStencilMapLayerMask() const;
                float GetOccludedAlpha() const { return m_occludedAlpha; }
                float GetOccludedSaturation() const { return m_occludedSaturation; }
                float GetOccludedBrightness() const { return m_occludedBrightness; }

                const std::vector<float>& GetGradientStops() const { return m_gradientStops; }
                const std::vector<v4>& GetGradientColors() const { return m_gradientColors; }

                const Geometry::DoublePlane& GetProjectionPlane() const { return m_polygonBestFitPlane; }

                const std::vector<v3>& GetUntransformedPointsLocalEcef() const { return m_untransformedPointsLocalEcef; }

                HeatmapStats CalculateStats() const;

            protected:
                virtual void NotifyPointOnMapChanged();

            private:

                const std::vector<v3> m_untransformedPointsLocalEcef;
                Geometry::DoublePlane m_polygonBestFitPlane;

                std::vector<Eegeo::Space::WeightedLatLongAltitude> m_weightedPoints;
                double m_weightMin;
                double m_weightMax;

                v2 m_textureDimensions;
                float m_textureBorderPercent;
                std::vector<float> m_heatmapDensityStops;
                std::vector<double> m_heatmapRadiiMeters;
                std::vector<double> m_heatmapGains;
                bool m_useApproximation;
                float m_densityBlend;
                bool m_interpolateDensityByZoom;
                double m_zoomMin;
                double m_zoomMax;
                float m_opacity;
                float m_intensityBias;
                float m_intensityScale;

                // StencilMapLayerMask
                u32 m_occludedStencilMapLayerMask;

                float m_occludedAlpha;
                float m_occludedSaturation;
                float m_occludedBrightness;

                std::vector<float> m_gradientStops;
                std::vector<v4> m_gradientColors;

                ShapeModelChangedEvent& m_shapeModelChangedEvent;
                IHeatmapGeometryChangedEvent& m_heatmapGeometryChangedEvent;
                IHeatmapGradientChangedEvent& m_heatmapGradientChangedEvent;
                IHeatmapDataChangedEvent& m_heatmapDataChangedEvent;
                IHeatmapUniformsChangedEvent& m_heatmapUniformsChangedEvent;
            };

            struct HeatmapStats
            {
            public:
                HeatmapStats(
                    double dataMin,
                    double dataMax,
                    double dataMean,
                    double dataStandardDeviation
                );

                double GetDataMin() const { return m_dataMin; }
                double GetDataMax() const { return m_dataMax; }
                double GetDataMean() const { return m_dataMean; }
                double GetDataStandardDeviation() const { return m_dataStandardDeviation; }
            private:
                double m_dataMin;
                double m_dataMax;
                double m_dataMean;
                double m_dataStandardDeviation;
            };
        }
    }
}