cont/ColorTable.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  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 viskores_cont_ColorTable_h
#define viskores_cont_ColorTable_h
 
#include <viskores/Range.h>
#include <viskores/Types.h>
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/cont/ArrayHandle.h>
#include <viskores/cont/ColorTableSamples.h>
#include <viskores/cont/ExecutionObjectBase.h>
 
#include <viskores/exec/ColorTable.h>
 
#include <set>
 
namespace viskores
{
namespace cont
{
 
namespace detail
{
struct ColorTableInternals;
}
 
class VISKORES_CONT_EXPORT ColorTable : public viskores::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(
    viskores::cont::ColorTable::Preset preset = viskores::cont::ColorTable::Preset::Default);
 
  explicit ColorTable(const std::string& name);
 
  explicit ColorTable(viskores::ColorSpace space);
 
  ColorTable(const viskores::Range& range, viskores::ColorSpace space = viskores::ColorSpace::Lab);
 
  //
  ColorTable(const viskores::Range& range,
             const viskores::Vec3f_32& rgb1,
             const viskores::Vec3f_32& rgb2,
             viskores::ColorSpace space = viskores::ColorSpace::Lab);
 
  ColorTable(const viskores::Range& range,
             const viskores::Vec4f_32& rgba1,
             const viskores::Vec4f_32& rgba2,
             viskores::ColorSpace space = viskores::ColorSpace::Lab);
 
  ColorTable(
    const std::string& name,
    viskores::ColorSpace colorSpace,
    const viskores::Vec3f_64& nanColor,
    const std::vector<viskores::Float64>& rgbPoints,
    const std::vector<viskores::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(viskores::cont::ColorTable::Preset preset);
 
  static std::set<std::string> GetPresets();
 
  bool LoadPreset(const std::string& name);
 
  ColorTable MakeDeepCopy();
 
  viskores::ColorSpace GetColorSpace() const;
  void SetColorSpace(viskores::ColorSpace space);
 
  void SetClampingOn() { this->SetClamping(true); }
  void SetClampingOff() { this->SetClamping(false); }
  void SetClamping(bool state);
  bool GetClamping() const;
 
  void SetBelowRangeColor(const viskores::Vec3f_32& c);
  const viskores::Vec3f_32& GetBelowRangeColor() const;
 
  void SetAboveRangeColor(const viskores::Vec3f_32& c);
  const viskores::Vec3f_32& GetAboveRangeColor() const;
 
  void SetNaNColor(const viskores::Vec3f_32& c);
  const viskores::Vec3f_32& GetNaNColor() const;
 
  void Clear();
 
  void ClearColors();
 
  void ClearAlpha();
 
  void ReverseColors();
 
  void ReverseAlpha();
 
  const viskores::Range& GetRange() const;
 
  void RescaleToRange(const viskores::Range& range);
 
  // Functions for Colors
 
  viskores::Int32 AddPoint(viskores::Float64 x, const viskores::Vec3f_32& rgb);
 
  viskores::Int32 AddPointHSV(viskores::Float64 x, const viskores::Vec3f_32& hsv);
 
  viskores::Int32 AddSegment(viskores::Float64 x1,
                             const viskores::Vec3f_32& rgb1,
                             viskores::Float64 x2,
                             const viskores::Vec3f_32& rgb2);
 
  viskores::Int32 AddSegmentHSV(viskores::Float64 x1,
                                const viskores::Vec3f_32& hsv1,
                                viskores::Float64 x2,
                                const viskores::Vec3f_32& hsv2);
 
  bool GetPoint(viskores::Int32 index, viskores::Vec4f_64&) const;
 
  viskores::Int32 UpdatePoint(viskores::Int32 index, const viskores::Vec4f_64&);
 
  bool RemovePoint(viskores::Float64 x);
 
  bool RemovePoint(viskores::Int32 index);
 
  viskores::Int32 GetNumberOfPoints() const;
 
  // Functions for Opacity
 
  viskores::Int32 AddPointAlpha(viskores::Float64 x, viskores::Float32 alpha)
  {
    return AddPointAlpha(x, alpha, 0.5f, 0.0f);
  }
 
  viskores::Int32 AddPointAlpha(viskores::Float64 x,
                                viskores::Float32 alpha,
                                viskores::Float32 midpoint,
                                viskores::Float32 sharpness);
 
  viskores::Int32 AddSegmentAlpha(viskores::Float64 x1,
                                  viskores::Float32 alpha1,
                                  viskores::Float64 x2,
                                  viskores::Float32 alpha2)
  {
    viskores::Vec2f_32 mid_sharp(0.5f, 0.0f);
    return AddSegmentAlpha(x1, alpha1, x2, alpha2, mid_sharp, mid_sharp);
  }
 
  viskores::Int32 AddSegmentAlpha(viskores::Float64 x1,
                                  viskores::Float32 alpha1,
                                  viskores::Float64 x2,
                                  viskores::Float32 alpha2,
                                  const viskores::Vec2f_32& mid_sharp1,
                                  const viskores::Vec2f_32& mid_sharp2);
 
  bool GetPointAlpha(viskores::Int32 index, viskores::Vec4f_64&) const;
 
  viskores::Int32 UpdatePointAlpha(viskores::Int32 index, const viskores::Vec4f_64&);
 
  bool RemovePointAlpha(viskores::Float64 x);
 
  bool RemovePointAlpha(viskores::Int32 index);
 
  viskores::Int32 GetNumberOfPointsAlpha() const;
 
  bool FillColorTableFromDataPointer(viskores::Int32 n, const viskores::Float64* ptr);
 
  bool FillColorTableFromDataPointer(viskores::Int32 n, const viskores::Float32* ptr);
 
  bool FillOpacityTableFromDataPointer(viskores::Int32 n, const viskores::Float64* ptr);
 
  bool FillOpacityTableFromDataPointer(viskores::Int32 n, const viskores::Float32* ptr);
 
 
  bool Sample(viskores::Int32 numSamples,
              viskores::cont::ColorTableSamplesRGBA& samples,
              viskores::Float64 tolerance = 0.002) const;
 
  bool Sample(viskores::Int32 numSamples,
              viskores::cont::ColorTableSamplesRGB& samples,
              viskores::Float64 tolerance = 0.002) const;
 
  bool Sample(viskores::Int32 numSamples,
              viskores::cont::ArrayHandle<viskores::Vec4ui_8>& colors,
              viskores::Float64 tolerance = 0.002) const;
 
  bool Sample(viskores::Int32 numSamples,
              viskores::cont::ArrayHandle<viskores::Vec3ui_8>& colors,
              viskores::Float64 tolerance = 0.002) const;
 
 
  viskores::exec::ColorTable PrepareForExecution(viskores::cont::DeviceAdapterId deviceId,
                                                 viskores::cont::Token& token) const;
 
  viskores::Id GetModifiedCount() const;
 
private:
  void UpdateArrayHandles() const;
};
}
} //namespace viskores::cont
#endif //viskores_cont_ColorTable_h