cont/ColorTable.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_ColorTable_h
#define vtk_m_cont_ColorTable_h
 
#include <vtkm/Range.h>
#include <vtkm/Types.h>
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ColorTableSamples.h>
#include <vtkm/cont/ExecutionObjectBase.h>
 
#include <vtkm/exec/ColorTable.h>
 
#include <set>
 
namespace vtkm
{
namespace cont
{
 
namespace detail
{
struct ColorTableInternals;
}
 
class VTKM_CONT_EXPORT ColorTable : public vtkm::cont::ExecutionObjectBase
{
  std::shared_ptr<detail::ColorTableInternals> Internals;
 
public:
  enum struct Preset
  {
    Default,
    CoolToWarm,
    CoolToWarmExtended,
    Viridis,
    Inferno,
    Plasma,
    BlackBodyRadiation,
    XRay,
    Green,
    BlackBlueWhite,
    BlueToOrange,
    GrayToRed,
    ColdAndHot,
    BlueGreenOrange,
    YellowGrayBlue,
    RainbowUniform,
    Jet,
    RainbowDesaturated,
  };
 
  ColorTable(vtkm::cont::ColorTable::Preset preset = vtkm::cont::ColorTable::Preset::Default);
 
  explicit ColorTable(const std::string& name);
 
  explicit ColorTable(vtkm::ColorSpace space);
 
  ColorTable(const vtkm::Range& range, vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
 
  //
  ColorTable(const vtkm::Range& range,
             const vtkm::Vec3f_32& rgb1,
             const vtkm::Vec3f_32& rgb2,
             vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
 
  ColorTable(const vtkm::Range& range,
             const vtkm::Vec4f_32& rgba1,
             const vtkm::Vec4f_32& rgba2,
             vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
 
  ColorTable(
    const std::string& name,
    vtkm::ColorSpace colorSpace,
    const vtkm::Vec3f_64& nanColor,
    const std::vector<vtkm::Float64>& rgbPoints,
    const std::vector<vtkm::Float64>& alphaPoints = { 0.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 0.0 });
 
 
  ~ColorTable();
 
  ColorTable& operator=(const ColorTable&) = default;
  ColorTable(const ColorTable&) = default;
 
  const std::string& GetName() const;
  void SetName(const std::string& name);
 
  bool LoadPreset(vtkm::cont::ColorTable::Preset preset);
 
  static std::set<std::string> GetPresets();
 
  bool LoadPreset(const std::string& name);
 
  ColorTable MakeDeepCopy();
 
  vtkm::ColorSpace GetColorSpace() const;
  void SetColorSpace(vtkm::ColorSpace space);
 
  void SetClampingOn() { this->SetClamping(true); }
  void SetClampingOff() { this->SetClamping(false); }
  void SetClamping(bool state);
  bool GetClamping() const;
 
  void SetBelowRangeColor(const vtkm::Vec3f_32& c);
  const vtkm::Vec3f_32& GetBelowRangeColor() const;
 
  void SetAboveRangeColor(const vtkm::Vec3f_32& c);
  const vtkm::Vec3f_32& GetAboveRangeColor() const;
 
  void SetNaNColor(const vtkm::Vec3f_32& c);
  const vtkm::Vec3f_32& GetNaNColor() const;
 
  void Clear();
 
  void ClearColors();
 
  void ClearAlpha();
 
  void ReverseColors();
 
  void ReverseAlpha();
 
  const vtkm::Range& GetRange() const;
 
  void RescaleToRange(const vtkm::Range& range);
 
  // Functions for Colors
 
  vtkm::Int32 AddPoint(vtkm::Float64 x, const vtkm::Vec3f_32& rgb);
 
  vtkm::Int32 AddPointHSV(vtkm::Float64 x, const vtkm::Vec3f_32& hsv);
 
  vtkm::Int32 AddSegment(vtkm::Float64 x1,
                         const vtkm::Vec3f_32& rgb1,
                         vtkm::Float64 x2,
                         const vtkm::Vec3f_32& rgb2);
 
  vtkm::Int32 AddSegmentHSV(vtkm::Float64 x1,
                            const vtkm::Vec3f_32& hsv1,
                            vtkm::Float64 x2,
                            const vtkm::Vec3f_32& hsv2);
 
  bool GetPoint(vtkm::Int32 index, vtkm::Vec4f_64&) const;
 
  vtkm::Int32 UpdatePoint(vtkm::Int32 index, const vtkm::Vec4f_64&);
 
  bool RemovePoint(vtkm::Float64 x);
 
  bool RemovePoint(vtkm::Int32 index);
 
  vtkm::Int32 GetNumberOfPoints() const;
 
  // Functions for Opacity
 
  vtkm::Int32 AddPointAlpha(vtkm::Float64 x, vtkm::Float32 alpha)
  {
    return AddPointAlpha(x, alpha, 0.5f, 0.0f);
  }
 
  vtkm::Int32 AddPointAlpha(vtkm::Float64 x,
                            vtkm::Float32 alpha,
                            vtkm::Float32 midpoint,
                            vtkm::Float32 sharpness);
 
  vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
                              vtkm::Float32 alpha1,
                              vtkm::Float64 x2,
                              vtkm::Float32 alpha2)
  {
    vtkm::Vec2f_32 mid_sharp(0.5f, 0.0f);
    return AddSegmentAlpha(x1, alpha1, x2, alpha2, mid_sharp, mid_sharp);
  }
 
  vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
                              vtkm::Float32 alpha1,
                              vtkm::Float64 x2,
                              vtkm::Float32 alpha2,
                              const vtkm::Vec2f_32& mid_sharp1,
                              const vtkm::Vec2f_32& mid_sharp2);
 
  bool GetPointAlpha(vtkm::Int32 index, vtkm::Vec4f_64&) const;
 
  vtkm::Int32 UpdatePointAlpha(vtkm::Int32 index, const vtkm::Vec4f_64&);
 
  bool RemovePointAlpha(vtkm::Float64 x);
 
  bool RemovePointAlpha(vtkm::Int32 index);
 
  vtkm::Int32 GetNumberOfPointsAlpha() const;
 
  bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
 
  bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
 
  bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
 
  bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
 
 
  bool Sample(vtkm::Int32 numSamples,
              vtkm::cont::ColorTableSamplesRGBA& samples,
              vtkm::Float64 tolerance = 0.002) const;
 
  bool Sample(vtkm::Int32 numSamples,
              vtkm::cont::ColorTableSamplesRGB& samples,
              vtkm::Float64 tolerance = 0.002) const;
 
  bool Sample(vtkm::Int32 numSamples,
              vtkm::cont::ArrayHandle<vtkm::Vec4ui_8>& colors,
              vtkm::Float64 tolerance = 0.002) const;
 
  bool Sample(vtkm::Int32 numSamples,
              vtkm::cont::ArrayHandle<vtkm::Vec3ui_8>& colors,
              vtkm::Float64 tolerance = 0.002) const;
 
 
  vtkm::exec::ColorTable PrepareForExecution(vtkm::cont::DeviceAdapterId deviceId,
                                             vtkm::cont::Token& token) const;
 
  vtkm::Id GetModifiedCount() const;
 
private:
  void UpdateArrayHandles() const;
};
}
} //namespace vtkm::cont
#endif //vtk_m_cont_ColorTable_h