colormappable.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2026 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <memory>
#include <string>
#include <vector>
 
#include <scroom/assertions.hh>
#include <scroom/color.hh>
#include <scroom/observable.hh>
#include <scroom/presentationinterface.hh>
 
const std::string COLORMAPPABLE_PROPERTY_NAME = "Colormappable";
const std::string MONOCHROME_COLORMAPPABLE_PROPERTY_NAME = "Monochrome Colormappable";
const std::string TRANSPARENT_BACKGROUND_PROPERTY_NAME = "Transparent Background";
 
class Colormap
{
public:
  using Ptr = std::shared_ptr<Colormap>;
  using ConstPtr = std::shared_ptr<const Colormap>;
  using WeakPtr = std::weak_ptr<Colormap>;
 
public:
  std::string name; 
  std::vector<Color> colors; 
private:
  Colormap()
    : name("Empty")
  {
  }
 
public:
  static Colormap::Ptr create() { return Ptr(new Colormap()); }
 
  static Colormap::Ptr createDefault(int n)
  {
    Colormap::Ptr result = create();
    result->name = "Default";
    result->colors.reserve(n);
    result->colors.clear();
    const double max = n - 1;
    for(int i = 0; i < n; i++)
    {
      result->colors.emplace_back(i / max); // Min is black
    }
 
    return result;
  }
 
  static Colormap::Ptr createDefaultInverted(int n)
  {
    Colormap::Ptr result = create();
    result->name = "0 is white";
    result->colors.reserve(n);
    result->colors.clear();
    const double max = n - 1;
    for(int i = 0; i < n; i++)
    {
      result->colors.emplace_back((max - i) / max); // Min is white
    }
 
    return result;
  }
 
  [[nodiscard]] Ptr clone() const { return std::make_shared<Colormap>(*this); }
 
  void setAlpha(double alpha)
  {
    for(Color& c: colors)
    {
      c.setAlpha(alpha);
    }
  }
 
  [[nodiscard]] Ptr setAlpha(double alpha) const
  {
    Ptr result = clone();
    result->setAlpha(alpha);
    return result;
  }
};
 
class Colormappable : private Interface
{
public:
  using Ptr = std::shared_ptr<Colormappable>;
  using WeakPtr = std::weak_ptr<Colormappable>;
 
  virtual void setColormap(Colormap::Ptr colormap) = 0;
 
  virtual Colormap::Ptr getOriginalColormap() = 0;
 
  virtual int getNumberOfColors() = 0;
 
  virtual Color getMonochromeColor() = 0;
  virtual void setMonochromeColor(const Color& c) = 0;
  virtual void setTransparentBackground() = 0;
  virtual void disableTransparentBackground() = 0;
  virtual bool getTransparentBackground() = 0;
};
 
class ColormapProvider : private Interface
{
public:
  using Ptr = std::shared_ptr<ColormapProvider>;
 
public:
  virtual Colormap::Ptr getColormap() = 0;
};
 
class ColormapHelperBase
  : public ColormapProvider
  , public Colormappable
{
public:
  using Ptr = std::shared_ptr<ColormapHelperBase>;
 
public:
  Colormap::Ptr colormap;
  Colormap::Ptr originalColormap;
 
public:
  explicit ColormapHelperBase(Colormap::Ptr const& colormap);
  virtual std::map<std::string, std::string> getProperties() = 0;
 
  // Colormappable
  void setColormap(Colormap::Ptr colormap) override;
  Colormap::Ptr getOriginalColormap() override;
  int getNumberOfColors() override;
  Color getMonochromeColor() override;
  void setMonochromeColor(const Color& c) override;
  void setTransparentBackground() override;
  void disableTransparentBackground() override;
  bool getTransparentBackground() override;
 
  // ColormapProvider
  Colormap::Ptr getColormap() override;
 
  // Helpers
  virtual void setOriginalColormap(Colormap::Ptr colormap);
 
private:
  [[noreturn]] static void OperationNotSupported();
};
 
class ColormapHelper : public ColormapHelperBase
{
public:
  static Ptr create(int numberOfColors);
  static Ptr createInverted(int numberOfColors);
  static Ptr create(Colormap::Ptr const& colormap);
 
  std::map<std::string, std::string> getProperties() override;
 
private:
  explicit ColormapHelper(Colormap::Ptr const& colormap);
};
 
class MonochromeColormapHelper : public ColormapHelperBase
{
public:
  static Ptr create(int numberOfColors);
  static Ptr createInverted(int numberOfColors);
 
  std::map<std::string, std::string> getProperties() override;
 
  // Colormappable
 
  Color getMonochromeColor() override;
  void setMonochromeColor(const Color& c) override;
  void setTransparentBackground() override;
  void disableTransparentBackground() override;
  bool getTransparentBackground() override;
 
private:
  MonochromeColormapHelper(int numberOfColors, bool inverted);
  void regenerateColormap();
  static Colormap::Ptr generateInitialColormap(int numberOfColors, bool inverted);
 
private:
  int numberOfColors;
  bool inverted;
  Color blackish;
  Color whitish;
  bool transparentBackground{false};
};