MRPalette.h

Go to the documentation of this file.

#pragma once
#include "MRViewerFwd.h"
#include "MRMesh/MRMeshFwd.h"
#include "MRMesh/MRVector4.h"
#include "MRMesh/MRMeshTexture.h"
#include "MRMesh/MRColor.h"
#include "MRMesh/MRExpected.h"
#include "MRViewer/MRImGui.h"
#include "MRMesh/MRBox.h"
#include "MRMesh/MRVector.h"
#include <algorithm>
#include <filesystem>
 
namespace Json{ class Value; }
 
namespace MR
{
 

class Palette
{
public:
    MRVIEWER_API static const std::vector<Color> DefaultColors;
    [[nodiscard]] static const std::vector<Color> & BlueGreenRedColors() { return DefaultColors; }

    [[nodiscard]] MRVIEWER_API static const std::vector<Color> & GreenRedColors();
 
    MRVIEWER_API Palette( const std::vector<Color>& colors );
    MRVIEWER_API void setBaseColors( const std::vector<Color>& colors );
    MRVIEWER_API void setRangeMinMax( float min, float max );
    MRVIEWER_API void setRangeMinMaxNegPos( float minNeg, float maxNeg, float minPos, float maxPos );

    MRVIEWER_API void setDiscretizationNumber( int discretization );
    MRVIEWER_API void setFilterType( FilterType type );

    MRVIEWER_API void draw( const std::string& windowName, const ImVec2& pose, const ImVec2& size, bool onlyTopHalf = false );

    MRVIEWER_API void draw( ImDrawList* drawList, float scaling, const ImVec2& pos, const ImVec2& size, const Color& labelBgColor, bool onlyTopHalf = false ) const;
    MRVIEWER_API void draw( ImDrawList* drawList, float scaling, const ImVec2& pos, const ImVec2& size, bool onlyTopHalf = false ) const;

    struct MRVIEWER_CLASS Label
    {
        float value = 0.f; 
        std::string text; 

        bool isZero = false;
 
        Label() = default;
        MRVIEWER_API Label( float val, std::string text );
    };

    MRVIEWER_API void resetLabels();
    MRVIEWER_API void setCustomLabels( const std::vector<Label>& labels );
    MRVIEWER_API void setLabelsVisible( bool visible );
 

    MRVIEWER_API bool loadFromJson( const Json::Value& root );
    MRVIEWER_API void saveCurrentToJson( Json::Value& root ) const;
 

    MRVIEWER_API Color getColor( float relativeValue ) const;
    Color getInvalidColor() const { return Color::gray(); }

    MRVIEWER_API VertColors getVertColors( const VertScalars& values, const VertBitSet& region, const VertBitSet* valids, const VertBitSet* validsForStats );
 
    const MeshTexture& getTexture() const { return texture_; };

    MRVIEWER_API float getRelativePos( float val ) const;

    UVCoord getUVcoord( float val, bool valid = true ) const
    {
        return {
            ( texEnd_ - texStart_ ) * getRelativePos( val ) + texStart_,
            valid ? 0.25f : 0.75f
        };
    }

    [[nodiscard]] MRVIEWER_API static VertPredicate predFromBitSet( const VertBitSet* bits );

    MRVIEWER_API VertUVCoords getUVcoords( const VertScalars & values, const VertBitSet & region, const VertPredicate & valids = {}, const VertPredicate & validsForStats = {} );
 
    VertUVCoords getUVcoords( const VertScalars & values, const VertBitSet & region, const VertBitSet * valids, const VertBitSet * validsForStats = nullptr )
    {
        return getUVcoords( values, region, predFromBitSet( valids ), predFromBitSet( validsForStats ) );
    }

    struct Parameters
    {
        std::vector<float> ranges = { 0.f, 1.f }; 
        std::vector<Color> baseColors; 
        MinMaxf legendLimits; 
        int discretization = 7; 
    };
 
    [[nodiscard]] const Parameters& getParameters() const { return parameters_; }

    [[nodiscard]] float getRangeMin() const { return parameters_.ranges.front(); }

    [[nodiscard]] float getRangeMax() const { return parameters_.ranges.back(); }

    [[nodiscard]] float getRangeSq() const { return std::max( sqr( getRangeMin() ), sqr( getRangeMax() ) ); }

    MRVIEWER_API std::string getStringValue( float value ) const;
    MRVIEWER_API int getMaxLabelCount();
    MRVIEWER_API void setMaxLabelCount( int val );

    MRVIEWER_API void setLegendLimits( const MinMaxf& limits );
 

 
    [[nodiscard]] bool isHistogramEnabled() const { return getNumHistogramBuckets() != 0; }
    [[nodiscard]] MRVIEWER_API int getNumHistogramBuckets() const;
    MRVIEWER_API void setNumHistogramBuckets( int n );
    [[nodiscard]] MRVIEWER_API int getDefaultNumHistogramBuckets() const;
 

    [[nodiscard]] bool isDiscretizationPercentagesEnabled() const { return enableHistogramDiscr_; }
    void enableDiscretizationPercentages( bool enable ) { histogramDiscr_.reset(); enableHistogramDiscr_ = enable; }
 

    MRVIEWER_API void updateStats( const VertScalars& values, const VertBitSet& region, const VertPredicate& vertPredicate );

    MRVIEWER_API std::vector<Label> createUniformLabels() const;
 
    struct Histogram
    {
        std::vector<int> buckets;
        int beforeBucket = 0;
        int afterBucket = 0;
        int numEntries = 0;
        int maxEntry = 0;

        bool needsUpdate = true;
 
        MRVIEWER_API void reset();
        MRVIEWER_API void addValue( float value );
        MRVIEWER_API void finalize();
    };

    [[nodiscard]] const Histogram &getHistogramValues() { return histogram_; }
    [[nodiscard]] const Histogram &getDiscrHistogramValues() const { return histogramDiscr_; }

    MRVIEWER_API void setDrawDelayFrames( int numFrames );
 
private:
    void setRangeLimits_( const std::vector<float>& ranges );
 
    void updateDiscretizatedColors_();
    Color getBaseColor_( float val );

    const Color& getBackgroundColor_() const;
 

    void setUniformLabels_();
    void makeUniformLabels_( std::vector<Label>& labels ) const;
    void setZeroCentredLabels_();
 
    void updateCustomLabels_();
 
    void sortLabels_( std::vector<Label>& labels ) const;
 
    void updateLegendLimits_( const MinMaxf& limits );
    void updateLegendLimitIndexes_();
 
    std::vector<Label> customLabels_;
    std::vector<Label> labels_;
    bool showLabels_ = false;

    const char* getAdjustedLabelText_( std::size_t labelIndex, bool onlyTopHalf, std::string& storage ) const;

    float getMaxLabelWidth_( bool onlyTopHalf = false ) const;
 
    struct StyleVariables
    {
        ImVec2 windowPaddingA;
        ImVec2 windowPaddingB;
        float labelToColoredRectSpacing {};
        float minColoredRectWidth {};
    };
    StyleVariables getStyleVariables_( float scaling ) const;

    MeshTexture texture_;

    float texStart_ = 0, texEnd_ = 1;
 
    Parameters parameters_;
 
    bool isWindowOpen_ = false;
 
    bool useCustomLabels_ = false;
 
    int maxLabelCount_ = 0;
 
    float prevMaxLabelWidth_ = 0.0f;
 
    MinMaxi legendLimitIndexes_ = { 0, 7 };
    MinMaxf relativeLimits_ = { 0.f, 1.f };

    Histogram histogram_;

    Histogram histogramDiscr_;

    bool enableHistogramDiscr_ = false;

    int drawDelayFrames_ = 0;
 
    static void resizeCallback_( ImGuiSizeCallbackData* data );
};

class PalettePresets
{
public:
    MRVIEWER_API static const std::vector<std::string>& getPresetNames();
    MRVIEWER_API static bool loadPreset( const std::string& name, Palette& palette );
    MRVIEWER_API static Expected<void> savePreset( const std::string& name, const Palette& palette );
    MRVIEWER_API static std::filesystem::path getPalettePresetsFolder();
private:
    PalettePresets();
    ~PalettePresets() = default;
 
    std::vector<std::string> names_;
 
    void update_();
 
    static PalettePresets& instance_();
};
 
}