Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Remove virtual methods from ColorTable

Browse Source 
Virtual methods are being deprecated, so remove their use from the
ColorTable classes. Instead of using a virtual method to look up a value
in the ColorTable, we essentially use a switch statement. This change
also simplified the code quite a bit.

The execution object used to use pointers to handle the virtual objects.
That is no longer necessary, so a simple `vtkm::exec::ColorTable` is
returned for execution objects. (Note that this `ColorTable` contains
pointers that are specific for the particular device.) This is a non-
backward compabible change. However, the only place (outside of the
`ColorTable` implementation itself) was a single worklet for converting
scalars to colors (`vtkm::worklet::colorconversion::TransferFunction`).
This is unlikely to affect anyone.

I also "fixed" some names in enum structs. There has been some
inconsistencies in VTK-m on whether items in an enum struct are
capitolized or camel case. We seem to moving toward camel case, so
deprecate some old names.
This commit is contained in:
Kenneth Moreland 2020-09-14 13:26:16 -06:00
parent fbb69b7655
commit 11996f133f
13 changed files with 1087 additions and 1141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMake/testing/VTKmCheckSourceInInstall.cmake
View File

@ -110,7 +110,6 @@ function(do_verify root_dir prefix)
) )
set(file_exceptions set(file_exceptions
cont/ColorTablePrivate.hxx
thirdparty/diy/vtkmdiy/cmake/mpi_types.h thirdparty/diy/vtkmdiy/cmake/mpi_types.h
# Ignore deprecated virtual classes (which are not installed if VTKm_NO_DEPRECATED_VIRTUAL # Ignore deprecated virtual classes (which are not installed if VTKm_NO_DEPRECATED_VIRTUAL

908
vtkm/cont/ColorTable.cxx
View File

File diff suppressed because it is too large Load Diff

308
vtkm/cont/ColorTable.h
View File

@ -17,43 +17,35 @@
#include <vtkm/cont/ArrayHandle.h> #include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ColorTableSamples.h> #include <vtkm/cont/ColorTableSamples.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/exec/ColorTable.h>
#include <set> #include <set>
namespace vtkm namespace vtkm
{ {
namespace exec
{
//forward declare exec objects
class ColorTableBase;
}
namespace cont namespace cont
{ {
template <typename T>
class VirtualObjectHandle;
namespace detail namespace detail
{ {
struct ColorTableInternals; struct ColorTableInternals;
} }
enum struct ColorSpace struct VTKM_DEPRECATED(1.6, "Use vtkm::ColorSpace.") ColorSpace
{ {
RGB, static constexpr vtkm::ColorSpace RGB = vtkm::ColorSpace::RGB;
HSV, static constexpr vtkm::ColorSpace HSV = vtkm::ColorSpace::HSV;
HSV_WRAP, static constexpr vtkm::ColorSpace HSV_WRAP = vtkm::ColorSpace::HSVWrap;
LAB, static constexpr vtkm::ColorSpace LAB = vtkm::ColorSpace::Lab;
DIVERGING static constexpr vtkm::ColorSpace DIVERGING = vtkm::ColorSpace::Diverging;
}; };
/// \brief Color Table for coloring arbitrary fields /// \brief Color Table for coloring arbitrary fields
/// ///
/// ///
/// The vtkm::cont::ColorTable allows for color mapping in RGB or HSV space and /// The `vtkm::cont::ColorTable` allows for color mapping in RGB or HSV space and
/// uses a piecewise hermite functions to allow opacity interpolation that can be /// uses a piecewise hermite functions to allow opacity interpolation that can be
/// piecewise constant, piecewise linear, or somewhere in-between /// piecewise constant, piecewise linear, or somewhere in-between
/// (a modified piecewise hermite function that squishes the function /// (a modified piecewise hermite function that squishes the function
@ -76,51 +68,77 @@ enum struct ColorSpace
/// will default to to Midpoint = 0.5 (halfway between the control points) and /// will default to to Midpoint = 0.5 (halfway between the control points) and
/// Sharpness = 0.0 (linear). /// Sharpness = 0.0 (linear).
/// ///
/// ColorTable also contains which ColorSpace should be used for interpolation /// ColorTable also contains which ColorSpace should be used for interpolation.
/// The color space is selected with the `vtkm::ColorSpace` enumeration.
/// Currently the valid ColorSpaces are: /// Currently the valid ColorSpaces are:
/// - RGB /// - `RGB`
/// - HSV /// - `HSV`
/// - HSV_WRAP /// - `HSVWrap`
/// - LAB /// - `Lab`
/// - Diverging /// - `Diverging`
/// ///
/// In HSV_WRAP mode, it will take the shortest path /// In `HSVWrap` mode, it will take the shortest path
/// in Hue (going back through 0 if that is the shortest way around the hue /// in Hue (going back through 0 if that is the shortest way around the hue
/// circle) whereas HSV will not go through 0 (in order the /// circle) whereas HSV will not go through 0 (in order to
/// match the current functionality of vtkLookupTable). In Lab mode, /// match the current functionality of `vtkLookupTable`). In `Lab` mode,
/// it will take the shortest path in the Lab color space with respect to the /// it will take the shortest path in the Lab color space with respect to the
/// CIE Delta E 2000 color distance measure. Diverging is a special /// CIE Delta E 2000 color distance measure. `Diverging` is a special
/// mode where colors will pass through white when interpolating between two /// mode where colors will pass through white when interpolating between two
/// saturated colors. /// saturated colors.
/// ///
/// To map a field from a vtkm::cont::DataSet through the color and opacity transfer /// To map a field from a `vtkm::cont::DataSet` through the color and opacity transfer
/// functions and into a RGB or RGBA array you should use vtkm::filter::FieldToColor. /// functions and into a RGB or RGBA array you should use `vtkm::filter::FieldToColor`.
/// ///
class VTKM_CONT_EXPORT ColorTable /// Note that modifications of `vtkm::cont::ColorTable` are not thread safe. You should
/// not modify a `ColorTable` simultaneously in 2 or more threads. Also, you should not
/// modify a `ColorTable` that might be used in the execution environment. However,
/// the `ColorTable` can be used in multiple threads and on multiple devices as long
/// as no modifications are made.
///
class VTKM_CONT_EXPORT ColorTable : public vtkm::cont::ExecutionObjectBase
{ {
std::shared_ptr<detail::ColorTableInternals> Impl; std::shared_ptr<detail::ColorTableInternals> Internals;
public: public:
enum struct Preset enum struct Preset
{ {
DEFAULT, Default,
COOL_TO_WARM, CoolToWarm,
COOL_TO_WARM_EXTENDED, CoolToWarmExtended,
VIRIDIS, Viridis,
INFERNO, Inferno,
PLASMA, Plasma,
BLACK_BODY_RADIATION, BlackBodyRadiation,
X_RAY, XRay,
GREEN, Green,
BLACK_BLUE_WHITE, BlackBlueWhite,
BLUE_TO_ORANGE, BlueToOrange,
GRAY_TO_RED, GrayToRed,
COLD_AND_HOT, ColdAndHot,
BLUE_GREEN_ORANGE, BlueGreenOrange,
YELLOW_GRAY_BLUE, YellowGrayBlue,
RAINBOW_UNIFORM, RainbowUniform,
JET, Jet,
RAINBOW_DESATURATED RainbowDesaturated,
DEFAULT VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Default."),
COOL_TO_WARM VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::CoolToWarm."),
COOL_TO_WARM_EXTENDED VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::CoolToWarmExtended."),
VIRIDIS VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Viridis."),
INFERNO VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Inferno."),
PLASMA VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Plasma."),
BLACK_BODY_RADIATION VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::BlackBodyRadiation."),
X_RAY VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::XRay."),
GREEN VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Green."),
BLACK_BLUE_WHITE VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::BlackBlueWhite."),
BLUE_TO_ORANGE VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::BlueToOrange."),
GRAY_TO_RED VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::GrayToRed."),
COLD_AND_HOT VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::ColdAndHot."),
BLUE_GREEN_ORANGE VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::BlueGreenOrange."),
YELLOW_GRAY_BLUE VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::YellowGrayBlue."),
RAINBOW_UNIFORM VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::RainbowUniform."),
JET VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::Jet."),
RAINBOW_DESATURATED VTKM_DEPRECATED(1.6, "Use vtkm::ColorTable::Preset::RainbowDesaturated.")
}; };
/// \brief Construct a color table from a preset /// \brief Construct a color table from a preset
@ -130,7 +148,7 @@ public:
/// ///
/// Note: these are a select set of the presets you can get by providing a string identifier. /// Note: these are a select set of the presets you can get by providing a string identifier.
/// ///
ColorTable(vtkm::cont::ColorTable::Preset preset = vtkm::cont::ColorTable::Preset::DEFAULT); ColorTable(vtkm::cont::ColorTable::Preset preset = vtkm::cont::ColorTable::Preset::Default);
/// \brief Construct a color table from a preset color table /// \brief Construct a color table from a preset color table
/// ///
@ -165,41 +183,42 @@ public:
/// ///
/// Note: The color table will have 0 entries /// Note: The color table will have 0 entries
/// Note: The alpha table will have 0 entries /// Note: The alpha table will have 0 entries
explicit ColorTable(ColorSpace space); explicit ColorTable(vtkm::ColorSpace space);
/// Construct a color table with a 2 positions /// Construct a color table with a 2 positions
/// ///
/// Note: The color table will have 2 entries of rgb = {1.0,1.0,1.0} /// Note: The color table will have 2 entries of rgb = {1.0,1.0,1.0}
/// Note: The alpha table will have 2 entries of alpha = 1.0 with linear /// Note: The alpha table will have 2 entries of alpha = 1.0 with linear
/// interpolation /// interpolation
ColorTable(const vtkm::Range& range, ColorSpace space = ColorSpace::LAB); ColorTable(const vtkm::Range& range, vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
/// Construct a color table with 2 positions /// Construct a color table with 2 positions
// //
/// Note: The alpha table will have 2 entries of alpha = 1.0 with linear /// Note: The alpha table will have 2 entries of alpha = 1.0 with linear
/// interpolation /// interpolation
ColorTable(const vtkm::Range& range, ColorTable(const vtkm::Range& range,
const vtkm::Vec<float, 3>& rgb1, const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
ColorSpace space = ColorSpace::LAB); vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
/// Construct color and alpha and table with 2 positions /// Construct color and alpha and table with 2 positions
/// ///
/// Note: The alpha table will use linear interpolation /// Note: The alpha table will use linear interpolation
ColorTable(const vtkm::Range& range, ColorTable(const vtkm::Range& range,
const vtkm::Vec<float, 4>& rgba1, const vtkm::Vec4f_32& rgba1,
const vtkm::Vec<float, 4>& rgba2, const vtkm::Vec4f_32& rgba2,
ColorSpace space = ColorSpace::LAB); vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
/// Construct a color table with a list of colors and alphas. For this version you must also /// Construct a color table with a list of colors and alphas. For this version you must also
/// specify a name. /// specify a name.
/// ///
/// This constructor is mostly used for presets. /// This constructor is mostly used for presets.
ColorTable(const std::string& name, ColorTable(
vtkm::cont::ColorSpace colorSpace, const std::string& name,
const vtkm::Vec<double, 3>& nanColor, vtkm::ColorSpace colorSpace,
const std::vector<double>& rgbPoints, const vtkm::Vec3f_64& nanColor,
const std::vector<double>& alphaPoints = { 0.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 0.0 }); 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();
@ -257,8 +276,8 @@ public:
ColorTable MakeDeepCopy(); ColorTable MakeDeepCopy();
/// ///
ColorSpace GetColorSpace() const; vtkm::ColorSpace GetColorSpace() const;
void SetColorSpace(ColorSpace space); void SetColorSpace(vtkm::ColorSpace space);
/// If clamping is disabled values that lay out side /// If clamping is disabled values that lay out side
/// the color table range are colored based on Below /// the color table range are colored based on Below
@ -274,19 +293,19 @@ public:
/// that is below the given range /// that is below the given range
/// ///
/// Default value is {0,0,0} /// Default value is {0,0,0}
void SetBelowRangeColor(const vtkm::Vec<float, 3>& c); void SetBelowRangeColor(const vtkm::Vec3f_32& c);
const vtkm::Vec<float, 3>& GetBelowRangeColor() const; const vtkm::Vec3f_32& GetBelowRangeColor() const;
/// Color to use when clamping is disabled for any value /// Color to use when clamping is disabled for any value
/// that is above the given range /// that is above the given range
/// ///
/// Default value is {0,0,0} /// Default value is {0,0,0}
void SetAboveRangeColor(const vtkm::Vec<float, 3>& c); void SetAboveRangeColor(const vtkm::Vec3f_32& c);
const vtkm::Vec<float, 3>& GetAboveRangeColor() const; const vtkm::Vec3f_32& GetAboveRangeColor() const;
/// ///
void SetNaNColor(const vtkm::Vec<float, 3>& c); void SetNaNColor(const vtkm::Vec3f_32& c);
const vtkm::Vec<float, 3>& GetNaNColor() const; const vtkm::Vec3f_32& GetNaNColor() const;
/// Remove all existing values in both color and alpha tables. /// Remove all existing values in both color and alpha tables.
/// Does not remove the clamping, below, and above range state or colors. /// Does not remove the clamping, below, and above range state or colors.
@ -321,40 +340,40 @@ public:
/// ///
/// Note: rgb values need to be between 0 and 1.0 (inclusive). /// Note: rgb values need to be between 0 and 1.0 (inclusive).
/// Return the index of the point (0 based), or -1 osn error. /// Return the index of the point (0 based), or -1 osn error.
vtkm::Int32 AddPoint(double x, const vtkm::Vec<float, 3>& rgb); vtkm::Int32 AddPoint(vtkm::Float64 x, const vtkm::Vec3f_32& rgb);
/// Adds a point to the color function. If the point already exists, it /// Adds a point to the color function. If the point already exists, it
/// will be updated to the new value. /// will be updated to the new value.
/// ///
/// Note: hsv values need to be between 0 and 1.0 (inclusive). /// Note: hsv values need to be between 0 and 1.0 (inclusive).
/// Return the index of the point (0 based), or -1 on error. /// Return the index of the point (0 based), or -1 on error.
vtkm::Int32 AddPointHSV(double x, const vtkm::Vec<float, 3>& hsv); vtkm::Int32 AddPointHSV(vtkm::Float64 x, const vtkm::Vec3f_32& hsv);
/// Add a line segment to the color function. All points which lay between x1 and x2 /// Add a line segment to the color function. All points which lay between x1 and x2
/// (inclusive) are removed from the function. /// (inclusive) are removed from the function.
/// ///
/// Note: rgb1, and rgb2 values need to be between 0 and 1.0 (inclusive). /// Note: rgb1, and rgb2 values need to be between 0 and 1.0 (inclusive).
/// Return the index of the point x1 (0 based), or -1 on error. /// Return the index of the point x1 (0 based), or -1 on error.
vtkm::Int32 AddSegment(double x1, vtkm::Int32 AddSegment(vtkm::Float64 x1,
const vtkm::Vec<float, 3>& rgb1, const vtkm::Vec3f_32& rgb1,
double x2, vtkm::Float64 x2,
const vtkm::Vec<float, 3>& rgb2); const vtkm::Vec3f_32& rgb2);
/// Add a line segment to the color function. All points which lay between x1 and x2 /// Add a line segment to the color function. All points which lay between x1 and x2
/// (inclusive) are removed from the function. /// (inclusive) are removed from the function.
/// ///
/// Note: hsv1, and hsv2 values need to be between 0 and 1.0 (inclusive) /// Note: hsv1, and hsv2 values need to be between 0 and 1.0 (inclusive)
/// Return the index of the point x1 (0 based), or -1 on error /// Return the index of the point x1 (0 based), or -1 on error
vtkm::Int32 AddSegmentHSV(double x1, vtkm::Int32 AddSegmentHSV(vtkm::Float64 x1,
const vtkm::Vec<float, 3>& hsv1, const vtkm::Vec3f_32& hsv1,
double x2, vtkm::Float64 x2,
const vtkm::Vec<float, 3>& hsv2); const vtkm::Vec3f_32& hsv2);
/// Get the location, and rgb information for an existing point in the opacity function. /// Get the location, and rgb information for an existing point in the opacity function.
/// ///
/// Note: components 1-3 are rgb and will have values between 0 and 1.0 (inclusive) /// Note: components 1-3 are rgb and will have values between 0 and 1.0 (inclusive)
/// Return the index of the point (0 based), or -1 on error. /// Return the index of the point (0 based), or -1 on error.
bool GetPoint(vtkm::Int32 index, vtkm::Vec<double, 4>&) const; bool GetPoint(vtkm::Int32 index, vtkm::Vec4f_64&) const;
/// Update the location, and rgb information for an existing point in the color function. /// Update the location, and rgb information for an existing point in the color function.
/// If the location value for the index is modified the point is removed from /// If the location value for the index is modified the point is removed from
@ -362,12 +381,12 @@ public:
/// ///
/// Note: components 1-3 are rgb and must have values between 0 and 1.0 (inclusive). /// Note: components 1-3 are rgb and must have values between 0 and 1.0 (inclusive).
/// Return the new index of the updated point (0 based), or -1 on error. /// Return the new index of the updated point (0 based), or -1 on error.
vtkm::Int32 UpdatePoint(vtkm::Int32 index, const vtkm::Vec<double, 4>&); vtkm::Int32 UpdatePoint(vtkm::Int32 index, const vtkm::Vec4f_64&);
/// Remove the Color function point that exists at exactly x /// Remove the Color function point that exists at exactly x
/// ///
/// Return true if the point x exists and has been removed /// Return true if the point x exists and has been removed
bool RemovePoint(double x); bool RemovePoint(vtkm::Float64 x);
/// Remove the Color function point n /// Remove the Color function point n
/// ///
@ -385,14 +404,20 @@ public:
/// ///
/// Note: alpha needs to be a value between 0 and 1.0 (inclusive). /// Note: alpha needs to be a value between 0 and 1.0 (inclusive).
/// Return the index of the point (0 based), or -1 on error. /// Return the index of the point (0 based), or -1 on error.
vtkm::Int32 AddPointAlpha(double x, float alpha) { return AddPointAlpha(x, alpha, 0.5f, 0.0f); } vtkm::Int32 AddPointAlpha(vtkm::Float64 x, vtkm::Float32 alpha)
{
return AddPointAlpha(x, alpha, 0.5f, 0.0f);
}
/// Adds a point to the opacity function. If the point already exists, it /// Adds a point to the opacity function. If the point already exists, it
/// will be updated to the new value. /// will be updated to the new value.
/// ///
/// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive) /// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive)
/// Return the index of the point (0 based), or -1 on error. /// Return the index of the point (0 based), or -1 on error.
vtkm::Int32 AddPointAlpha(double x, float alpha, float midpoint, float sharpness); vtkm::Int32 AddPointAlpha(vtkm::Float64 x,
vtkm::Float32 alpha,
vtkm::Float32 midpoint,
vtkm::Float32 sharpness);
/// Add a line segment to the opacity function. All points which lay between x1 and x2 /// Add a line segment to the opacity function. All points which lay between x1 and x2
/// (inclusive) are removed from the function. Uses a midpoint of /// (inclusive) are removed from the function. Uses a midpoint of
@ -400,9 +425,12 @@ public:
/// ///
/// Note: alpha values need to be between 0 and 1.0 (inclusive) /// Note: alpha values need to be between 0 and 1.0 (inclusive)
/// Return the index of the point x1 (0 based), or -1 on error /// Return the index of the point x1 (0 based), or -1 on error
vtkm::Int32 AddSegmentAlpha(double x1, float alpha1, double x2, float alpha2) vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
vtkm::Float32 alpha1,
vtkm::Float64 x2,
vtkm::Float32 alpha2)
{ {
vtkm::Vec<float, 2> mid_sharp(0.5f, 0.0f); vtkm::Vec2f_32 mid_sharp(0.5f, 0.0f);
return AddSegmentAlpha(x1, alpha1, x2, alpha2, mid_sharp, mid_sharp); return AddSegmentAlpha(x1, alpha1, x2, alpha2, mid_sharp, mid_sharp);
} }
@ -411,19 +439,19 @@ public:
/// ///
/// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive) /// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive)
/// Return the index of the point x1 (0 based), or -1 on error /// Return the index of the point x1 (0 based), or -1 on error
vtkm::Int32 AddSegmentAlpha(double x1, vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
float alpha1, vtkm::Float32 alpha1,
double x2, vtkm::Float64 x2,
float alpha2, vtkm::Float32 alpha2,
const vtkm::Vec<float, 2>& mid_sharp1, const vtkm::Vec2f_32& mid_sharp1,
const vtkm::Vec<float, 2>& mid_sharp2); const vtkm::Vec2f_32& mid_sharp2);
/// Get the location, alpha, midpoint and sharpness information for an existing /// Get the location, alpha, midpoint and sharpness information for an existing
/// point in the opacity function. /// point in the opacity function.
/// ///
/// Note: alpha, midpoint, and sharpness values all will be between 0 and 1.0 (inclusive) /// Note: alpha, midpoint, and sharpness values all will be between 0 and 1.0 (inclusive)
/// Return the index of the point (0 based), or -1 on error. /// Return the index of the point (0 based), or -1 on error.
bool GetPointAlpha(vtkm::Int32 index, vtkm::Vec<double, 4>&) const; bool GetPointAlpha(vtkm::Int32 index, vtkm::Vec4f_64&) const;
/// Update the location, alpha, midpoint and sharpness information for an existing /// Update the location, alpha, midpoint and sharpness information for an existing
/// point in the opacity function. /// point in the opacity function.
@ -432,12 +460,12 @@ public:
/// ///
/// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive) /// Note: alpha, midpoint, and sharpness values need to be between 0 and 1.0 (inclusive)
/// Return the new index of the updated point (0 based), or -1 on error. /// Return the new index of the updated point (0 based), or -1 on error.
vtkm::Int32 UpdatePointAlpha(vtkm::Int32 index, const vtkm::Vec<double, 4>&); vtkm::Int32 UpdatePointAlpha(vtkm::Int32 index, const vtkm::Vec4f_64&);
/// Remove the Opacity function point that exists at exactly x /// Remove the Opacity function point that exists at exactly x
/// ///
/// Return true if the point x exists and has been removed /// Return true if the point x exists and has been removed
bool RemovePointAlpha(double x); bool RemovePointAlpha(vtkm::Float64 x);
/// Remove the Opacity function point n /// Remove the Opacity function point n
/// ///
@ -447,9 +475,9 @@ public:
/// Returns the number of points in the alpha function /// Returns the number of points in the alpha function
vtkm::Int32 GetNumberOfPointsAlpha() const; vtkm::Int32 GetNumberOfPointsAlpha() const;
/// Fill the Color table from a double pointer /// Fill the Color table from a vtkm::Float64 pointer
/// ///
/// The double pointer is required to have the layout out of [X1, R1, /// The vtkm::Float64 pointer is required to have the layout out of [X1, R1,
/// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the /// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the
/// number of nodes. /// number of nodes.
/// This will remove any existing color control points. /// This will remove any existing color control points.
@ -458,11 +486,11 @@ public:
/// ///
/// Note: This is provided as a interoperability method with VTK /// Note: This is provided as a interoperability method with VTK
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr /// Will return false and not modify anything if n is <= 0 or ptr == nullptr
bool FillColorTableFromDataPointer(vtkm::Int32 n, const double* ptr); bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
/// Fill the Color table from a float pointer /// Fill the Color table from a vtkm::Float32 pointer
/// ///
/// The double pointer is required to have the layout out of [X1, R1, /// The vtkm::Float64 pointer is required to have the layout out of [X1, R1,
/// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the /// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the
/// number of nodes. /// number of nodes.
/// This will remove any existing color control points. /// This will remove any existing color control points.
@ -471,11 +499,11 @@ public:
/// ///
/// Note: This is provided as a interoperability method with VTK /// Note: This is provided as a interoperability method with VTK
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr /// Will return false and not modify anything if n is <= 0 or ptr == nullptr
bool FillColorTableFromDataPointer(vtkm::Int32 n, const float* ptr); bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
/// Fill the Opacity table from a double pointer /// Fill the Opacity table from a vtkm::Float64 pointer
/// ///
/// The double pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2, /// The vtkm::Float64 pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2,
/// ..., Xn, An, Mn, Sn] where n is the number of nodes. The Xi values represent the value to /// ..., Xn, An, Mn, Sn] where n is the number of nodes. The Xi values represent the value to
/// map, the Ai values represent alpha (opacity) value, the Mi values represent midpoints, and /// map, the Ai values represent alpha (opacity) value, the Mi values represent midpoints, and
/// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear /// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear
@ -486,11 +514,11 @@ public:
/// Note: n represents the length of the array, so ( n/4 == number of control points ) /// Note: n represents the length of the array, so ( n/4 == number of control points )
/// ///
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr /// Will return false and not modify anything if n is <= 0 or ptr == nullptr
bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const double* ptr); bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
/// Fill the Opacity table from a float pointer /// Fill the Opacity table from a vtkm::Float32 pointer
/// ///
/// The float pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2, /// The vtkm::Float32 pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2,
/// ..., Xn, An, Mn, Sn] where n is the number of nodes. The Xi values represent the value to /// ..., Xn, An, Mn, Sn] where n is the number of nodes. The Xi values represent the value to
/// map, the Ai values represent alpha (opacity) value, the Mi values represent midpoints, and /// map, the Ai values represent alpha (opacity) value, the Mi values represent midpoints, and
/// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear /// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear
@ -501,7 +529,7 @@ public:
/// Note: n represents the length of the array, so ( n/4 == number of control points ) /// Note: n represents the length of the array, so ( n/4 == number of control points )
/// ///
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr /// Will return false and not modify anything if n is <= 0 or ptr == nullptr
bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const float* ptr); bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
/// \brief Sample each value through an intermediate lookup/sample table to generate RGBA colors /// \brief Sample each value through an intermediate lookup/sample table to generate RGBA colors
@ -628,8 +656,8 @@ public:
/// ///
/// Will use the current range of the color table to generate evenly spaced /// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space. /// values using either vtkm::Float32 or vtkm::Float64 space.
/// Will use vtkm::Float32 space when the difference between the float and double /// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within float space and the following are within a tolerance: /// values when the range is within vtkm::Float32 space and the following are within a tolerance:
/// ///
/// - (max-min) / numSamples /// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples /// - ((max-min) / numSamples) * numSamples
@ -637,14 +665,14 @@ public:
/// Note: This will return false if the number of samples is less than 2 /// Note: This will return false if the number of samples is less than 2
inline bool Sample(vtkm::Int32 numSamples, inline bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ColorTableSamplesRGBA& samples, vtkm::cont::ColorTableSamplesRGBA& samples,
double tolerance = 0.002) const; vtkm::Float64 tolerance = 0.002) const;
/// \brief generate a sample lookup table using regular spaced samples along the range. /// \brief generate a sample lookup table using regular spaced samples along the range.
/// ///
/// Will use the current range of the color table to generate evenly spaced /// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space. /// values using either vtkm::Float32 or vtkm::Float64 space.
/// Will use vtkm::Float32 space when the difference between the float and double /// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within float space and the following are within a tolerance: /// values when the range is within vtkm::Float32 space and the following are within a tolerance:
/// ///
/// - (max-min) / numSamples /// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples /// - ((max-min) / numSamples) * numSamples
@ -652,14 +680,14 @@ public:
/// Note: This will return false if the number of samples is less than 2 /// Note: This will return false if the number of samples is less than 2
inline bool Sample(vtkm::Int32 numSamples, inline bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ColorTableSamplesRGB& samples, vtkm::cont::ColorTableSamplesRGB& samples,
double tolerance = 0.002) const; vtkm::Float64 tolerance = 0.002) const;
/// \brief generate RGBA colors using regular spaced samples along the range. /// \brief generate RGBA colors using regular spaced samples along the range.
/// ///
/// Will use the current range of the color table to generate evenly spaced /// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space. /// values using either vtkm::Float32 or vtkm::Float64 space.
/// Will use vtkm::Float32 space when the difference between the float and double /// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within float space and the following are within a tolerance: /// values when the range is within vtkm::Float32 space and the following are within a tolerance:
/// ///
/// - (max-min) / numSamples /// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples /// - ((max-min) / numSamples) * numSamples
@ -667,14 +695,14 @@ public:
/// Note: This will return false if the number of samples is less than 2 /// Note: This will return false if the number of samples is less than 2
inline bool Sample(vtkm::Int32 numSamples, inline bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8>& colors, vtkm::cont::ArrayHandle<vtkm::Vec4ui_8>& colors,
double tolerance = 0.002) const; vtkm::Float64 tolerance = 0.002) const;
/// \brief generate RGB colors using regular spaced samples along the range. /// \brief generate RGB colors using regular spaced samples along the range.
/// ///
/// Will use the current range of the color table to generate evenly spaced /// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space. /// values using either vtkm::Float32 or vtkm::Float64 space.
/// Will use vtkm::Float32 space when the difference between the float and double /// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within float space and the following are within a tolerance: /// values when the range is within vtkm::Float32 space and the following are within a tolerance:
/// ///
/// - (max-min) / numSamples /// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples /// - ((max-min) / numSamples) * numSamples
@ -682,48 +710,30 @@ public:
/// Note: This will return false if the number of samples is less than 2 /// Note: This will return false if the number of samples is less than 2
inline bool Sample(vtkm::Int32 numSamples, inline bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8>& colors, vtkm::cont::ArrayHandle<vtkm::Vec3ui_8>& colors,
double tolerance = 0.002) const; vtkm::Float64 tolerance = 0.002) const;
/// \brief returns a virtual object pointer of the exec color table /// \brief returns a virtual object pointer of the exec color table
/// ///
/// This pointer is only valid as long as the ColorTable is unmodified /// This pointer is only valid as long as the ColorTable is unmodified
inline const vtkm::exec::ColorTableBase* PrepareForExecution(vtkm::cont::DeviceAdapterId deviceId, vtkm::exec::ColorTable PrepareForExecution(vtkm::cont::DeviceAdapterId deviceId,
vtkm::cont::Token& token) const; vtkm::cont::Token& token) const;
VTKM_DEPRECATED(1.6, "PrepareForExecution now requires a vtkm::cont::Token object") VTKM_DEPRECATED(1.6, "PrepareForExecution now requires a vtkm::cont::Token object")
inline const vtkm::exec::ColorTableBase* PrepareForExecution( inline vtkm::exec::ColorTable PrepareForExecution(vtkm::cont::DeviceAdapterId deviceId) const;
vtkm::cont::DeviceAdapterId deviceId) const;
/// \brief returns the modified count for the virtual object handle of the exec color table /// \brief Returns the modified count for changes of the color table
/// ///
/// The `ModifiedCount` of the color table starts at 1 and gets incremented
/// every time a change is made to the color table.
/// The modified count allows consumers of a shared color table to keep track /// The modified count allows consumers of a shared color table to keep track
/// if the color table has been modified since the last time they used it. /// if the color table has been modified since the last time they used it.
/// This is important for consumers that need to sample the color table.
/// You only want to resample the color table if changes have been made.
vtkm::Id GetModifiedCount() const; vtkm::Id GetModifiedCount() const;
struct TransferState
{
bool NeedsTransfer;
vtkm::exec::ColorTableBase* Portal;
const vtkm::cont::ArrayHandle<double>& ColorPosHandle;
const vtkm::cont::ArrayHandle<vtkm::Vec<float, 3>>& ColorRGBHandle;
const vtkm::cont::ArrayHandle<double>& OpacityPosHandle;
const vtkm::cont::ArrayHandle<float>& OpacityAlphaHandle;
const vtkm::cont::ArrayHandle<vtkm::Vec<float, 2>>& OpacityMidSharpHandle;
};
private: private:
bool NeedToCreateExecutionColorTable() const; void UpdateArrayHandles() const;
//takes ownership of the pointer passed in
void UpdateExecutionColorTable(
vtkm::cont::VirtualObjectHandle<vtkm::exec::ColorTableBase>*) const;
ColorTable::TransferState GetExecutionDataForTransfer() const;
vtkm::exec::ColorTableBase* GetControlRepresentation() const;
vtkm::cont::VirtualObjectHandle<vtkm::exec::ColorTableBase> const* GetExecutionHandle() const;
}; };
} }
} //namespace vtkm::cont } //namespace vtkm::cont

117
vtkm/cont/ColorTable.hxx
View File

@ -29,52 +29,6 @@ namespace cont
namespace detail namespace detail
{ {
template <typename T>
inline T* get_ptr(T* t)
{
return t;
}
#if defined(VTKM_MSVC)
//ArrayPortalToIteratorBegin could be returning a checked_array_iterator so
//we need to grab the underlying pointer
template <typename T>
inline T* get_ptr(stdext::checked_array_iterator<T*> t)
{
return t.base();
}
#endif
struct transfer_color_table_to_device
{
template <typename DeviceAdapter>
inline bool operator()(DeviceAdapter device,
vtkm::cont::ColorTable::TransferState&& state,
vtkm::cont::Token& token) const
{
auto p1 = state.ColorPosHandle.PrepareForInput(device, token);
auto p2 = state.ColorRGBHandle.PrepareForInput(device, token);
auto p3 = state.OpacityPosHandle.PrepareForInput(device, token);
auto p4 = state.OpacityAlphaHandle.PrepareForInput(device, token);
auto p5 = state.OpacityMidSharpHandle.PrepareForInput(device, token);
//The rest of the data member on portal are set when-ever the user
//modifies the ColorTable instance and don't need to specified here
state.Portal->ColorSize = static_cast<vtkm::Int32>(state.ColorPosHandle.GetNumberOfValues());
state.Portal->OpacitySize =
static_cast<vtkm::Int32>(state.OpacityPosHandle.GetNumberOfValues());
state.Portal->ColorNodes = detail::get_ptr(vtkm::cont::ArrayPortalToIteratorBegin(p1));
state.Portal->RGB = detail::get_ptr(vtkm::cont::ArrayPortalToIteratorBegin(p2));
state.Portal->ONodes = detail::get_ptr(vtkm::cont::ArrayPortalToIteratorBegin(p3));
state.Portal->Alpha = detail::get_ptr(vtkm::cont::ArrayPortalToIteratorBegin(p4));
state.Portal->MidSharp = detail::get_ptr(vtkm::cont::ArrayPortalToIteratorBegin(p5));
state.Portal->Modified();
return true;
}
};
struct map_color_table struct map_color_table
{ {
template <typename DeviceAdapter, typename ColorTable, typename... Args> template <typename DeviceAdapter, typename ColorTable, typename... Args>
@ -349,77 +303,6 @@ bool ColorTable::Sample(vtkm::Int32 numSamples,
} }
return sampleColorTable(this, numSamples, colors, tolerance, false); return sampleColorTable(this, numSamples, colors, tolerance, false);
} }
//---------------------------------------------------------------------------
const vtkm::exec::ColorTableBase* ColorTable::PrepareForExecution(
vtkm::cont::DeviceAdapterId device,
vtkm::cont::Token& token) const
{
//Build the ColorTable instance that is needed for execution
if (this->NeedToCreateExecutionColorTable())
{
auto space = this->GetColorSpace();
auto hostPortal = this->GetControlRepresentation();
//Remove any existing host and execution data. The allocation of the
//virtual object handle needs to occur in the .hxx so that it happens
//in the same library as the user and will be a valid virtual object
using HandleType = vtkm::cont::VirtualObjectHandle<vtkm::exec::ColorTableBase>;
switch (space)
{
case vtkm::cont::ColorSpace::RGB:
{
this->UpdateExecutionColorTable(
new HandleType(static_cast<vtkm::exec::ColorTableRGB*>(hostPortal), false));
break;
}
case vtkm::cont::ColorSpace::HSV:
{
this->UpdateExecutionColorTable(
new HandleType(static_cast<vtkm::exec::ColorTableHSV*>(hostPortal), false));
break;
}
case vtkm::cont::ColorSpace::HSV_WRAP:
{
this->UpdateExecutionColorTable(
new HandleType(static_cast<vtkm::exec::ColorTableHSVWrap*>(hostPortal), false));
break;
}
case vtkm::cont::ColorSpace::LAB:
{
this->UpdateExecutionColorTable(
new HandleType(static_cast<vtkm::exec::ColorTableLab*>(hostPortal), false));
break;
}
case vtkm::cont::ColorSpace::DIVERGING:
{
this->UpdateExecutionColorTable(
new HandleType(static_cast<vtkm::exec::ColorTableDiverging*>(hostPortal), false));
break;
}
}
}
//transfer ColorTable and all related data
auto&& info = this->GetExecutionDataForTransfer();
if (info.NeedsTransfer)
{
bool transfered = vtkm::cont::TryExecuteOnDevice(
device, detail::transfer_color_table_to_device{}, std::move(info), token);
if (!transfered)
{
throwFailedRuntimeDeviceTransfer("ColorTable", device);
}
}
return this->GetExecutionHandle()->PrepareForExecution(device, token);
}
const vtkm::exec::ColorTableBase* ColorTable::PrepareForExecution(
vtkm::cont::DeviceAdapterId device) const
{
vtkm::cont::Token token;
return this->PrepareForExecution(device, token);
}
} }
} }
#endif #endif

151
vtkm/cont/ColorTablePresets.cxx
View File

@ -24,28 +24,28 @@ namespace cont
namespace internal namespace internal
{ {
static vtkm::cont::ColorTable::Preset DEFAULT_PRESET = vtkm::cont::ColorTable::Preset::VIRIDIS; static vtkm::cont::ColorTable::Preset DEFAULT_PRESET = vtkm::cont::ColorTable::Preset::Viridis;
std::string GetColorSpaceString(vtkm::cont::ColorSpace space) std::string GetColorSpaceString(vtkm::ColorSpace space)
{ {
switch (space) switch (space)
{ {
case vtkm::cont::ColorSpace::RGB: case vtkm::ColorSpace::RGB:
return std::string("RGB"); return std::string("RGB");
case vtkm::cont::ColorSpace::HSV: case vtkm::ColorSpace::HSV:
return std::string("HSV"); return std::string("HSV");
case vtkm::cont::ColorSpace::HSV_WRAP: case vtkm::ColorSpace::HSVWrap:
return std::string("HSV_WRAP"); return std::string("HSVWrap");
case vtkm::cont::ColorSpace::LAB: case vtkm::ColorSpace::Lab:
return std::string("Lab"); return std::string("Lab");
case vtkm::cont::ColorSpace::DIVERGING: case vtkm::ColorSpace::Diverging:
return std::string("Diverging"); return std::string("Diverging");
} }
throw vtkm::cont::ErrorBadValue("Encountered invalid color space."); throw vtkm::cont::ErrorBadValue("Encountered invalid color space.");
} }
vtkm::cont::ColorSpace GetColorSpaceEnum(const std::string& colorSpaceString) vtkm::ColorSpace GetColorSpaceEnum(const std::string& colorSpaceString)
{ {
std::string spaceString = colorSpaceString; std::string spaceString = colorSpaceString;
@ -56,27 +56,27 @@ vtkm::cont::ColorSpace GetColorSpaceEnum(const std::string& colorSpaceString)
if (spaceString == "rgb") if (spaceString == "rgb")
{ {
return vtkm::cont::ColorSpace::RGB; return vtkm::ColorSpace::RGB;
} }
if (spaceString == "hsv") if (spaceString == "hsv")
{ {
return vtkm::cont::ColorSpace::HSV; return vtkm::ColorSpace::HSV;
} }
if ((spaceString == "hsv_wrap") || (spaceString == "hsv-wrap") || (spaceString == "hsvwrap")) if ((spaceString == "hsv_wrap") || (spaceString == "hsv-wrap") || (spaceString == "hsvwrap"))
{ {
return vtkm::cont::ColorSpace::HSV_WRAP; return vtkm::ColorSpace::HSVWrap;
} }
if (spaceString == "lab") if (spaceString == "lab")
{ {
return vtkm::cont::ColorSpace::LAB; return vtkm::ColorSpace::Lab;
} }
if (spaceString == "diverging") if (spaceString == "diverging")
{ {
return vtkm::cont::ColorSpace::DIVERGING; return vtkm::ColorSpace::Diverging;
} }
std::stringstream message; std::stringstream message;
@ -116,7 +116,7 @@ struct ColorTablePreset
{ {
vtkm::cont::ColorTable::Preset Preset; vtkm::cont::ColorTable::Preset Preset;
std::string Name; std::string Name;
vtkm::cont::ColorSpace ColorSpace; vtkm::ColorSpace ColorSpace;
vtkm::Vec<double, 3> NanColor; vtkm::Vec<double, 3> NanColor;
std::vector<double> RGBPoints; std::vector<double> RGBPoints;
std::vector<double> AlphaPoints; std::vector<double> AlphaPoints;
@ -124,13 +124,13 @@ struct ColorTablePreset
VTKM_CONT VTKM_CONT
ColorTablePreset(vtkm::cont::ColorTable::Preset preset, ColorTablePreset(vtkm::cont::ColorTable::Preset preset,
std::string&& name, std::string&& name,
vtkm::cont::ColorSpace colorSpace, vtkm::ColorSpace colorSpace,
vtkm::Vec<double, 3>&& nanColor, vtkm::Vec<double, 3>&& nanColor,
std::vector<double>&& rgbPoints, std::vector<double>&& rgbPoints,
std::vector<double>&& alphaPoints = { 0.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 0.0 }) std::vector<double>&& alphaPoints = { 0.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 0.0 })
: Preset(preset) : Preset(preset)
, Name(std::move(name)) , Name(std::move(name))
, ColorSpace(std::move(colorSpace)) , ColorSpace(colorSpace)
, NanColor(std::move(nanColor)) , NanColor(std::move(nanColor))
, RGBPoints(std::move(rgbPoints)) , RGBPoints(std::move(rgbPoints))
, AlphaPoints(std::move(alphaPoints)) , AlphaPoints(std::move(alphaPoints))
@ -148,9 +148,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
{ {
// clang-format off // clang-format off
presets = std::vector<ColorTablePreset>{ presets = std::vector<ColorTablePreset>{
{ vtkm::cont::ColorTable::Preset::COOL_TO_WARM, { vtkm::cont::ColorTable::Preset::CoolToWarm,
"Cool to Warm", "Cool to Warm",
vtkm::cont::ColorSpace::DIVERGING, vtkm::ColorSpace::Diverging,
{ 1, 1, 0 }, { 1, 1, 0 },
{ {
0, 0.23137254902, 0.298039215686, 0.752941176471, 0, 0.23137254902, 0.298039215686, 0.752941176471,
@ -158,9 +158,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 0.705882352941, 0.0156862745098, 0.149019607843 1, 0.705882352941, 0.0156862745098, 0.149019607843
} }
}, },
{ vtkm::cont::ColorTable::Preset::COOL_TO_WARM_EXTENDED, { vtkm::cont::ColorTable::Preset::CoolToWarmExtended,
"Cool to Warm Extended", "Cool to Warm Extended",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0.25, 0, 0 }, { 0.25, 0, 0 },
{ {
0, 0, 0, 0.34902, 0, 0, 0, 0.34902,
@ -200,9 +200,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 0.34902, 0.070588, 0.211765 1, 0.34902, 0.070588, 0.211765
} }
}, },
{ vtkm::cont::ColorTable::Preset::VIRIDIS, { vtkm::cont::ColorTable::Preset::Viridis,
"Viridis", "Viridis",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 1, 0, 0 }, { 1, 0, 0 },
{ {
0.000000, 0.282365, 0.000000, 0.331010, 0.000000, 0.282365, 0.000000, 0.331010,
@ -463,9 +463,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.952999, 0.912545, 0.110859 1.000000, 0.952999, 0.912545, 0.110859
} }
}, },
{ vtkm::cont::ColorTable::Preset::INFERNO, { vtkm::cont::ColorTable::Preset::Inferno,
"Inferno", "Inferno",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0, 1, 0 }, { 0, 1, 0 },
{ {
0.000000, 0.002811, 0.000240, 0.013985, 0.000000, 0.002811, 0.000240, 0.013985,
@ -726,9 +726,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.959400, 1.002963, 0.640626 1.000000, 0.959400, 1.002963, 0.640626
} }
}, },
{ vtkm::cont::ColorTable::Preset::PLASMA, { vtkm::cont::ColorTable::Preset::Plasma,
"Plasma", "Plasma",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0, 1, 0 }, { 0, 1, 0 },
{ {
0.000000, 0.185001, 0.000000, 0.530073, 0.000000, 0.185001, 0.000000, 0.530073,
@ -989,9 +989,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.894058, 0.982254, 0.081069 1.000000, 0.894058, 0.982254, 0.081069
} }
}, },
{ vtkm::cont::ColorTable::Preset::BLACK_BODY_RADIATION, { vtkm::cont::ColorTable::Preset::BlackBodyRadiation,
"Black-Body Radiation", "Black-Body Radiation",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 0, 0.498039215686, 1 }, { 0, 0.498039215686, 1 },
{ {
0, 0, 0, 0, 0, 0, 0, 0,
@ -1000,15 +1000,15 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 1, 1, 1 1, 1, 1, 1
} }
}, },
{ vtkm::cont::ColorTable::Preset::X_RAY, { vtkm::cont::ColorTable::Preset::XRay,
"X Ray", "X Ray",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 1, 0, 0 }, { 1, 0, 0 },
{ 0, 1, 1, 1, 1, 0, 0, 0 } { 0, 1, 1, 1, 1, 0, 0, 0 }
}, },
{ vtkm::cont::ColorTable::Preset::GREEN, { vtkm::cont::ColorTable::Preset::Green,
"Green", "Green",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0.25, 0, 0 }, { 0.25, 0, 0 },
{ {
0.00, 0.054902, 0.109804, 0.121569, 0.00, 0.054902, 0.109804, 0.121569,
@ -1034,9 +1034,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.00, 1.000000, 0.984314, 0.901961 1.00, 1.000000, 0.984314, 0.901961
} }
}, },
{ vtkm::cont::ColorTable::Preset::BLACK_BLUE_WHITE, { vtkm::cont::ColorTable::Preset::BlackBlueWhite,
"Black - Blue - White", "Black - Blue - White",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 1, 1, 0 }, { 1, 1, 0 },
{ {
0, 0, 0, 0, 0, 0, 0, 0,
@ -1045,9 +1045,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 1, 1, 1 1, 1, 1, 1
} }
}, },
{ vtkm::cont::ColorTable::Preset::BLUE_TO_ORANGE, { vtkm::cont::ColorTable::Preset::BlueToOrange,
"Blue to Orange", "Blue to Orange",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0.25, 0, 0 }, { 0.25, 0, 0 },
{ {
0.000000, 0.086275, 0.003922, 0.298039, 0.000000, 0.086275, 0.003922, 0.298039,
@ -1098,9 +1098,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.188235, 0.000000, 0.070588 1.000000, 0.188235, 0.000000, 0.070588
} }
}, },
{vtkm::cont::ColorTable::Preset::GRAY_TO_RED, {vtkm::cont::ColorTable::Preset::GrayToRed,
"Gray to Red", "Gray to Red",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0, 0.498039215686, 1 }, { 0, 0.498039215686, 1 },
{ {
0.000000, 0.101961, 0.101961, 0.101961, 0.000000, 0.101961, 0.101961, 0.101961,
@ -1122,9 +1122,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.403922, 0.000000, 0.121569 1.000000, 0.403922, 0.000000, 0.121569
} }
}, },
{ vtkm::cont::ColorTable::Preset::COLD_AND_HOT, { vtkm::cont::ColorTable::Preset::ColdAndHot,
"Cold and Hot", "Cold and Hot",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 1, 1, 0 }, { 1, 1, 0 },
{ {
0, 0, 1, 1, 0, 0, 1, 1,
@ -1134,9 +1134,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 1, 1, 0 1, 1, 1, 0
} }
}, },
{ vtkm::cont::ColorTable::Preset::BLUE_GREEN_ORANGE, { vtkm::cont::ColorTable::Preset::BlueGreenOrange,
"Blue - Green - Orange", "Blue - Green - Orange",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0.25, 0.0, 0.0 }, { 0.25, 0.0, 0.0 },
{ {
0.0,0.831373,0.909804,0.980392, 0.0,0.831373,0.909804,0.980392,
@ -1191,9 +1191,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.0,0.45098,0.007843,0.0 1.0,0.45098,0.007843,0.0
} }
}, },
{ vtkm::cont::ColorTable::Preset::YELLOW_GRAY_BLUE, { vtkm::cont::ColorTable::Preset::YellowGrayBlue,
"Yellow - Gray - Blue", "Yellow - Gray - Blue",
vtkm::cont::ColorSpace::LAB, vtkm::ColorSpace::Lab,
{ 0.25, 0, 0 }, { 0.25, 0, 0 },
{ {
0.000000, 0.301961, 0.047059, 0.090196, 0.000000, 0.301961, 0.047059, 0.090196,
@ -1253,9 +1253,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000, 0.890196, 0.956863, 0.984314 1.000000, 0.890196, 0.956863, 0.984314
} }
}, },
{ vtkm::cont::ColorTable::Preset::RAINBOW_UNIFORM, { vtkm::cont::ColorTable::Preset::RainbowUniform,
"Rainbow Uniform", "Rainbow Uniform",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 1, 0, 0 }, { 1, 0, 0 },
{ {
0.000000,0.020000,0.381300,0.998100, 0.000000,0.020000,0.381300,0.998100,
@ -1303,9 +1303,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1.000000,0.683700,0.050000,0.413900 1.000000,0.683700,0.050000,0.413900
} }
}, },
{ vtkm::cont::ColorTable::Preset::JET, { vtkm::cont::ColorTable::Preset::Jet,
"Jet", "Jet",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 0.25, 0, 0 }, { 0.25, 0, 0 },
{ {
0, 0, 0, 0.5625, 0, 0, 0, 0.5625,
@ -1317,9 +1317,9 @@ VTKM_CONT void BuildColorTablePresetsVector(std::vector<ColorTablePreset>& prese
1, 0.5, 0, 0 1, 0.5, 0, 0
} }
}, },
{ vtkm::cont::ColorTable::Preset::RAINBOW_DESATURATED, { vtkm::cont::ColorTable::Preset::RainbowDesaturated,
"Rainbow Desaturated", "Rainbow Desaturated",
vtkm::cont::ColorSpace::RGB, vtkm::ColorSpace::RGB,
{ 1, 1, 0 }, { 1, 1, 0 },
{ {
0, 0.278431372549, 0.278431372549, 0.858823529412, 0, 0.278431372549, 0.278431372549, 0.858823529412,
@ -1357,7 +1357,7 @@ namespace internal
VTKM_CONT_EXPORT VTKM_CONT_EXPORT
bool LoadColorTablePreset(vtkm::cont::ColorTable::Preset preset, vtkm::cont::ColorTable& table) bool LoadColorTablePreset(vtkm::cont::ColorTable::Preset preset, vtkm::cont::ColorTable& table)
{ {
if (preset == vtkm::cont::ColorTable::Preset::DEFAULT) if (preset == vtkm::cont::ColorTable::Preset::Default)
{ {
preset = DEFAULT_PRESET; preset = DEFAULT_PRESET;
} }
@ -1369,7 +1369,52 @@ bool LoadColorTablePreset(vtkm::cont::ColorTable::Preset preset, vtkm::cont::Col
return true; return true;
} }
} }
return false;
VTKM_DEPRECATED_SUPPRESS_BEGIN
// Handle deprecated names
switch (preset)
{
case vtkm::cont::ColorTable::Preset::DEFAULT:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Default, table);
case vtkm::cont::ColorTable::Preset::COOL_TO_WARM:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::CoolToWarm, table);
case vtkm::cont::ColorTable::Preset::COOL_TO_WARM_EXTENDED:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::CoolToWarmExtended, table);
case vtkm::cont::ColorTable::Preset::VIRIDIS:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Viridis, table);
case vtkm::cont::ColorTable::Preset::INFERNO:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Inferno, table);
case vtkm::cont::ColorTable::Preset::PLASMA:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Plasma, table);
case vtkm::cont::ColorTable::Preset::BLACK_BODY_RADIATION:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::BlackBodyRadiation, table);
case vtkm::cont::ColorTable::Preset::X_RAY:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::XRay, table);
case vtkm::cont::ColorTable::Preset::GREEN:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Green, table);
case vtkm::cont::ColorTable::Preset::BLACK_BLUE_WHITE:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::BlackBlueWhite, table);
case vtkm::cont::ColorTable::Preset::BLUE_TO_ORANGE:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::BlueToOrange, table);
case vtkm::cont::ColorTable::Preset::GRAY_TO_RED:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::GrayToRed, table);
case vtkm::cont::ColorTable::Preset::COLD_AND_HOT:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::ColdAndHot, table);
case vtkm::cont::ColorTable::Preset::BLUE_GREEN_ORANGE:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::BlueGreenOrange, table);
case vtkm::cont::ColorTable::Preset::YELLOW_GRAY_BLUE:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::YellowGrayBlue, table);
case vtkm::cont::ColorTable::Preset::RAINBOW_UNIFORM:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::RainbowUniform, table);
case vtkm::cont::ColorTable::Preset::JET:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::Jet, table);
case vtkm::cont::ColorTable::Preset::RAINBOW_DESATURATED:
return LoadColorTablePreset(vtkm::cont::ColorTable::Preset::RainbowDesaturated, table);
default:
// Should not get here.
return false;
}
VTKM_DEPRECATED_SUPPRESS_END
} }
VTKM_CONT_EXPORT std::set<std::string> GetPresetNames() VTKM_CONT_EXPORT std::set<std::string> GetPresetNames()

295
vtkm/cont/ColorTablePrivate.hxx
View File

@ -1,295 +0,0 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/Range.h>
#include <vtkm/Types.h>
#include <vtkm/cont/VirtualObjectHandle.h>
#include <vtkm/exec/ColorTable.h>
#include <limits>
#include <vector>
namespace vtkm
{
namespace cont
{
namespace detail
{
struct ColorTableInternals
{
std::string Name;
ColorSpace CSpace = ColorSpace::LAB;
vtkm::Range TableRange = { 1.0, 0.0 };
//Host side version of the ColorTableBase. This holds data such as:
// NanColor
// BelowRangeColor
// AboveRangeColor
// UseClamping
// BelowRangeColor
// AboveRangeColor
//Note the pointers inside the host side portal are not valid, as they
//are execution pointers
std::unique_ptr<vtkm::exec::ColorTableBase> HostSideCache;
//Execution side version of the ColorTableBase.
std::unique_ptr<vtkm::cont::VirtualObjectHandle<vtkm::exec::ColorTableBase>> ExecHandle;
std::vector<double> ColorNodePos;
std::vector<vtkm::Vec<float, 3>> ColorRGB;
std::vector<double> OpacityNodePos;
std::vector<float> OpacityAlpha;
std::vector<vtkm::Vec<float, 2>> OpacityMidSharp;
vtkm::cont::ArrayHandle<double> ColorPosHandle;
vtkm::cont::ArrayHandle<vtkm::Vec<float, 3>> ColorRGBHandle;
vtkm::cont::ArrayHandle<double> OpacityPosHandle;
vtkm::cont::ArrayHandle<float> OpacityAlphaHandle;
vtkm::cont::ArrayHandle<vtkm::Vec<float, 2>> OpacityMidSharpHandle;
bool ColorArraysChanged = true;
bool OpacityArraysChanged = true;
bool HostSideCacheChanged = true;
void RecalculateRange()
{
vtkm::Range r;
if (this->ColorNodePos.size() > 0)
{
r.Include(this->ColorNodePos.front());
r.Include(this->ColorNodePos.back());
}
if (this->OpacityNodePos.size() > 0)
{
r.Include(this->OpacityNodePos.front());
r.Include(this->OpacityNodePos.back());
}
this->TableRange = r;
}
};
} //namespace detail
namespace
{
template <typename T>
struct MinDelta
{
};
// This value seems to work well for float ranges we have tested
template <>
struct MinDelta<float>
{
static constexpr int value = 2048;
};
template <>
struct MinDelta<double>
{
static constexpr vtkm::Int64 value = 2048L;
};
// Reperesents the following:
// T m = std::numeric_limits<T>::min();
// EquivSizeIntT im;
// std::memcpy(&im, &m, sizeof(T));
//
template <typename EquivSizeIntT>
struct MinRepresentable
{
};
template <>
struct MinRepresentable<float>
{
static constexpr int value = 8388608;
};
template <>
struct MinRepresentable<double>
{
static constexpr vtkm::Int64 value = 4503599627370496L;
};
inline bool rangeAlmostEqual(const vtkm::Range& r)
{
vtkm::Int64 irange[2];
// needs to be a memcpy to avoid strict aliasing issues, doing a count
// of 2*sizeof(T) to couple both values at the same time
std::memcpy(irange, &r.Min, sizeof(vtkm::Int64));
std::memcpy(irange + 1, &r.Max, sizeof(vtkm::Int64));
// determine the absolute delta between these two numbers.
const vtkm::Int64 delta = std::abs(irange[1] - irange[0]);
// If the numbers are not nearly equal, we don't touch them. This avoids running into
// pitfalls like BUG PV #17152.
return (delta < 1024) ? true : false;
}
template <typename T>
inline double expandRange(T r[2])
{
constexpr bool is_float32_type = std::is_same<T, vtkm::Float32>::value;
using IRange = typename std::conditional<is_float32_type, vtkm::Int32, vtkm::Int64>::type;
IRange irange[2];
// needs to be a memcpy to avoid strict aliasing issues, doing a count
// of 2*sizeof(T) to couple both values at the same time
std::memcpy(irange, r, sizeof(T) * 2);
const bool denormal = !std::isnormal(r[0]);
const IRange minInt = MinRepresentable<T>::value;
const IRange minDelta = denormal ? minInt + MinDelta<T>::value : MinDelta<T>::value;
// determine the absolute delta between these two numbers.
const vtkm::Int64 delta = std::abs(irange[1] - irange[0]);
// if our delta is smaller than the min delta push out the max value
// so that it is equal to minRange + minDelta. When our range is entirely
// negative we should instead subtract from our max, to max a larger negative
// value
if (delta < minDelta)
{
if (irange[0] < 0)
{
irange[1] = irange[0] - minDelta;
}
else
{
irange[1] = irange[0] + minDelta;
}
T result;
std::memcpy(&result, irange + 1, sizeof(T));
return static_cast<double>(result);
}
return static_cast<double>(r[1]);
}
inline vtkm::Range adjustRange(const vtkm::Range& r)
{
const bool spans_zero_boundary = r.Min < 0 && r.Max > 0;
if (spans_zero_boundary)
{ // nothing needs to be done, but this check is required.
// if we convert into integer space the delta difference will overflow
// an integer
return r;
}
if (rangeAlmostEqual(r))
{
return r;
}
// range should be left untouched as much as possible to
// to avoid loss of precision whenever possible. That is why
// we only modify the Max value
vtkm::Range result = r;
if (r.Min > static_cast<double>(std::numeric_limits<float>::lowest()) &&
r.Max < static_cast<double>(std::numeric_limits<float>::max()))
{ //We've found it best to offset it in float space if the numbers
//lay inside that representable range
float frange[2] = { static_cast<float>(r.Min), static_cast<float>(r.Max) };
result.Max = expandRange(frange);
}
else
{
double drange[2] = { r.Min, r.Max };
result.Max = expandRange(drange);
}
return result;
}
inline vtkm::Vec<float, 3> hsvTorgb(const vtkm::Vec<float, 3>& hsv)
{
vtkm::Vec<float, 3> rgb;
constexpr float onethird = 1.0f / 3.0f;
constexpr float onesixth = 1.0f / 6.0f;
constexpr float twothird = 2.0f / 3.0f;
constexpr float fivesixth = 5.0f / 6.0f;
// compute RGB from HSV
if (hsv[0] > onesixth && hsv[0] <= onethird) // green/red
{
rgb[1] = 1.0f;
rgb[0] = (onethird - hsv[0]) * 6.0f;
rgb[2] = 0.0f;
}
else if (hsv[0] > onethird && hsv[0] <= 0.5f) // green/blue
{
rgb[1] = 1.0f;
rgb[2] = (hsv[0] - onethird) * 6.0f;
rgb[0] = 0.0f;
}
else if (hsv[0] > 0.5 && hsv[0] <= twothird) // blue/green
{
rgb[2] = 1.0f;
rgb[1] = (twothird - hsv[0]) * 6.0f;
rgb[0] = 0.0f;
}
else if (hsv[0] > twothird && hsv[0] <= fivesixth) // blue/red
{
rgb[2] = 1.0f;
rgb[0] = (hsv[0] - twothird) * 6.0f;
rgb[1] = 0.0f;
}
else if (hsv[0] > fivesixth && hsv[0] <= 1.0) // red/blue
{
rgb[0] = 1.0f;
rgb[2] = (1.0f - hsv[0]) * 6.0f;
rgb[1] = 0.0f;
}
else // red/green
{
rgb[0] = 1.0f;
rgb[1] = hsv[0] * 6;
rgb[2] = 0.0f;
}
// add Saturation to the equation.
rgb[0] = (hsv[1] * rgb[0] + (1.0f - hsv[1]));
rgb[1] = (hsv[1] * rgb[1] + (1.0f - hsv[1]));
rgb[2] = (hsv[1] * rgb[2] + (1.0f - hsv[1]));
rgb[0] *= hsv[2];
rgb[1] *= hsv[2];
rgb[2] *= hsv[2];
return rgb;
}
// clang-format off
inline bool outside_vrange(double x) { return x < 0.0 || x > 1.0; }
inline bool outside_vrange(const vtkm::Vec<double, 2>& x)
{ return x[0] < 0.0 || x[0] > 1.0 || x[1] < 0.0 || x[1] > 1.0; }
inline bool outside_vrange(const vtkm::Vec<double, 3>& x)
{ return x[0] < 0.0 || x[0] > 1.0 || x[1] < 0.0 || x[1] > 1.0 || x[2] < 0.0 || x[2] > 1.0; }
inline bool outside_vrange(float x) { return x < 0.0f || x > 1.0f; }
inline bool outside_vrange(const vtkm::Vec<float, 2>& x)
{ return x[0] < 0.0f || x[0] > 1.0f || x[1] < 0.0f || x[1] > 1.0f; }
inline bool outside_vrange(const vtkm::Vec<float, 3>& x)
{ return x[0] < 0.0f || x[0] > 1.0f || x[1] < 0.0f || x[1] > 1.0f || x[2] < 0.0f || x[2] > 1.0f; }
inline bool outside_range() { return false; }
template <typename T>
inline bool outside_range(T&& t) { return outside_vrange(t); }
template <typename T, typename U>
inline bool outside_range(T&& t, U&& u) { return outside_vrange(t) || outside_vrange(u); }
template <typename T, typename U, typename V, typename... Args>
inline bool outside_range(T&& t, U&& u, V&& v, Args&&... args)
{
return outside_vrange(t) || outside_vrange(u) || outside_vrange(v) ||
outside_range(std::forward<Args>(args)...);
}
// clang-format on
}
} //namespace cont
} //namespace vtkm

76
vtkm/cont/testing/TestingColorTable.h
View File

@ -59,9 +59,9 @@ public:
vtkm::Range range{ 0.0, 1.0 }; vtkm::Range range{ 0.0, 1.0 };
vtkm::Vec<float, 3> rgb1{ 0.0f, 0.0f, 0.0f }; vtkm::Vec<float, 3> rgb1{ 0.0f, 0.0f, 0.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 1.0f, 1.0f }; vtkm::Vec<float, 3> rgb2{ 1.0f, 1.0f, 1.0f };
auto rgbspace = vtkm::cont::ColorSpace::RGB; auto rgbspace = vtkm::ColorSpace::RGB;
auto hsvspace = vtkm::cont::ColorSpace::HSV; auto hsvspace = vtkm::ColorSpace::HSV;
auto diverging = vtkm::cont::ColorSpace::DIVERGING; auto diverging = vtkm::ColorSpace::Diverging;
vtkm::cont::ColorTable table(rgbspace); vtkm::cont::ColorTable table(rgbspace);
VTKM_TEST_ASSERT(table.GetColorSpace() == rgbspace, "color space not saved"); VTKM_TEST_ASSERT(table.GetColorSpace() == rgbspace, "color space not saved");
@ -90,10 +90,10 @@ public:
static void TestLoadPresets() static void TestLoadPresets()
{ {
vtkm::Range range{ 0.0, 1.0 }; vtkm::Range range{ 0.0, 1.0 };
auto rgbspace = vtkm::cont::ColorSpace::RGB; auto rgbspace = vtkm::ColorSpace::RGB;
auto hsvspace = vtkm::cont::ColorSpace::HSV; auto hsvspace = vtkm::ColorSpace::HSV;
auto labspace = vtkm::cont::ColorSpace::LAB; auto labspace = vtkm::ColorSpace::Lab;
auto diverging = vtkm::cont::ColorSpace::DIVERGING; auto diverging = vtkm::ColorSpace::Diverging;
{ {
vtkm::cont::ColorTable table(rgbspace); vtkm::cont::ColorTable table(rgbspace);
@ -103,7 +103,7 @@ public:
VTKM_TEST_ASSERT(table.GetRange() == range, "color range not correct after loading preset"); VTKM_TEST_ASSERT(table.GetRange() == range, "color range not correct after loading preset");
VTKM_TEST_ASSERT(table.GetNumberOfPoints() == 3); VTKM_TEST_ASSERT(table.GetNumberOfPoints() == 3);
VTKM_TEST_ASSERT(table.LoadPreset(vtkm::cont::ColorTable::Preset::COOL_TO_WARM_EXTENDED)); VTKM_TEST_ASSERT(table.LoadPreset(vtkm::cont::ColorTable::Preset::CoolToWarmExtended));
VTKM_TEST_ASSERT(table.GetColorSpace() == labspace, VTKM_TEST_ASSERT(table.GetColorSpace() == labspace,
"color space not switched when loading preset"); "color space not switched when loading preset");
VTKM_TEST_ASSERT(table.GetRange() == range, "color range not correct after loading preset"); VTKM_TEST_ASSERT(table.GetRange() == range, "color range not correct after loading preset");
@ -140,24 +140,24 @@ public:
VTKM_TEST_ASSERT(table.GetNumberOfPoints() > 0, "Issue loading preset ", name); VTKM_TEST_ASSERT(table.GetNumberOfPoints() > 0, "Issue loading preset ", name);
} }
auto presetEnum = { vtkm::cont::ColorTable::Preset::DEFAULT, auto presetEnum = { vtkm::cont::ColorTable::Preset::Default,
vtkm::cont::ColorTable::Preset::COOL_TO_WARM, vtkm::cont::ColorTable::Preset::CoolToWarm,
vtkm::cont::ColorTable::Preset::COOL_TO_WARM_EXTENDED, vtkm::cont::ColorTable::Preset::CoolToWarmExtended,
vtkm::cont::ColorTable::Preset::VIRIDIS, vtkm::cont::ColorTable::Preset::Viridis,
vtkm::cont::ColorTable::Preset::INFERNO, vtkm::cont::ColorTable::Preset::Inferno,
vtkm::cont::ColorTable::Preset::PLASMA, vtkm::cont::ColorTable::Preset::Plasma,
vtkm::cont::ColorTable::Preset::BLACK_BODY_RADIATION, vtkm::cont::ColorTable::Preset::BlackBodyRadiation,
vtkm::cont::ColorTable::Preset::X_RAY, vtkm::cont::ColorTable::Preset::XRay,
vtkm::cont::ColorTable::Preset::GREEN, vtkm::cont::ColorTable::Preset::Green,
vtkm::cont::ColorTable::Preset::BLACK_BLUE_WHITE, vtkm::cont::ColorTable::Preset::BlackBlueWhite,
vtkm::cont::ColorTable::Preset::BLUE_TO_ORANGE, vtkm::cont::ColorTable::Preset::BlueToOrange,
vtkm::cont::ColorTable::Preset::GRAY_TO_RED, vtkm::cont::ColorTable::Preset::GrayToRed,
vtkm::cont::ColorTable::Preset::COLD_AND_HOT, vtkm::cont::ColorTable::Preset::ColdAndHot,
vtkm::cont::ColorTable::Preset::BLUE_GREEN_ORANGE, vtkm::cont::ColorTable::Preset::BlueGreenOrange,
vtkm::cont::ColorTable::Preset::YELLOW_GRAY_BLUE, vtkm::cont::ColorTable::Preset::YellowGrayBlue,
vtkm::cont::ColorTable::Preset::RAINBOW_UNIFORM, vtkm::cont::ColorTable::Preset::RainbowUniform,
vtkm::cont::ColorTable::Preset::JET, vtkm::cont::ColorTable::Preset::Jet,
vtkm::cont::ColorTable::Preset::RAINBOW_DESATURATED }; vtkm::cont::ColorTable::Preset::RainbowDesaturated };
for (vtkm::cont::ColorTable::Preset preset : presetEnum) for (vtkm::cont::ColorTable::Preset preset : presetEnum)
{ {
vtkm::cont::ColorTable table(preset); vtkm::cont::ColorTable table(preset);
@ -172,7 +172,7 @@ public:
vtkm::Range range{ 0.0, 1.0 }; vtkm::Range range{ 0.0, 1.0 };
vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f }; vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f }; vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f };
auto rgbspace = vtkm::cont::ColorSpace::RGB; auto rgbspace = vtkm::ColorSpace::RGB;
vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace); vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace);
VTKM_TEST_ASSERT(table.GetClamping() == true, "clamping not setup properly"); VTKM_TEST_ASSERT(table.GetClamping() == true, "clamping not setup properly");
@ -194,7 +194,7 @@ public:
vtkm::Range range{ -1.0, 2.0 }; vtkm::Range range{ -1.0, 2.0 };
vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f }; vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f }; vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f };
auto rgbspace = vtkm::cont::ColorSpace::RGB; auto rgbspace = vtkm::ColorSpace::RGB;
vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace); vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace);
table.SetClampingOff(); table.SetClampingOff();
@ -228,7 +228,7 @@ public:
//implement a blue2yellow color table //implement a blue2yellow color table
vtkm::Vec<float, 3> rgb1{ 0.0f, 0.0f, 1.0f }; vtkm::Vec<float, 3> rgb1{ 0.0f, 0.0f, 1.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 1.0f, 0.0f }; vtkm::Vec<float, 3> rgb2{ 1.0f, 1.0f, 0.0f };
auto lab = vtkm::cont::ColorSpace::LAB; auto lab = vtkm::ColorSpace::Lab;
vtkm::cont::ColorTable table(range, rgb1, rgb2, lab); vtkm::cont::ColorTable table(range, rgb1, rgb2, lab);
table.AddPoint(0.0, vtkm::Vec<float, 3>{ 0.5f, 0.5f, 0.5f }); table.AddPoint(0.0, vtkm::Vec<float, 3>{ 0.5f, 0.5f, 0.5f });
@ -266,7 +266,7 @@ public:
std::cout << "Test Add Points" << std::endl; std::cout << "Test Add Points" << std::endl;
vtkm::Range range{ -20, 20.0 }; vtkm::Range range{ -20, 20.0 };
auto rgbspace = vtkm::cont::ColorSpace::RGB; auto rgbspace = vtkm::ColorSpace::RGB;
vtkm::cont::ColorTable table(rgbspace); vtkm::cont::ColorTable table(rgbspace);
table.AddPoint(-10.0, vtkm::Vec<float, 3>{ 0.0f, 1.0f, 1.0f }); table.AddPoint(-10.0, vtkm::Vec<float, 3>{ 0.0f, 1.0f, 1.0f });
@ -291,9 +291,9 @@ public:
std::cout << "Test Add Segments" << std::endl; std::cout << "Test Add Segments" << std::endl;
vtkm::Range range{ 0.0, 50.0 }; vtkm::Range range{ 0.0, 50.0 };
auto diverging = vtkm::cont::ColorSpace::DIVERGING; auto diverging = vtkm::ColorSpace::Diverging;
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::COOL_TO_WARM); vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::CoolToWarm);
VTKM_TEST_ASSERT(table.GetColorSpace() == diverging, VTKM_TEST_ASSERT(table.GetColorSpace() == diverging,
"color space not switched when loading preset"); "color space not switched when loading preset");
@ -332,7 +332,7 @@ public:
{ {
std::cout << "Test Remove Points" << std::endl; std::cout << "Test Remove Points" << std::endl;
auto hsv = vtkm::cont::ColorSpace::HSV; auto hsv = vtkm::ColorSpace::HSV;
vtkm::cont::ColorTable table(hsv); vtkm::cont::ColorTable table(hsv);
//implement Blue to Red Rainbow color table //implement Blue to Red Rainbow color table
@ -370,7 +370,7 @@ public:
std::cout << " Change Color Space" << std::endl; std::cout << " Change Color Space" << std::endl;
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors_rgb; vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors_rgb;
table.SetColorSpace(vtkm::cont::ColorSpace::RGB); table.SetColorSpace(vtkm::ColorSpace::RGB);
table.Map(field, colors_rgb); table.Map(field, colors_rgb);
CheckColors(colors_rgb, CheckColors(colors_rgb,
@ -386,7 +386,7 @@ public:
{ {
std::cout << "Test Opacity Only Points" << std::endl; std::cout << "Test Opacity Only Points" << std::endl;
auto hsv = vtkm::cont::ColorSpace::HSV; auto hsv = vtkm::ColorSpace::HSV;
vtkm::cont::ColorTable table(hsv); vtkm::cont::ColorTable table(hsv);
//implement only a color table //implement only a color table
@ -430,7 +430,7 @@ public:
using namespace vtkm::worklet::colorconversion; using namespace vtkm::worklet::colorconversion;
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::GREEN); vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::Green);
VTKM_TEST_ASSERT((table.GetRange() == vtkm::Range{ 0.0, 1.0 }), VTKM_TEST_ASSERT((table.GetRange() == vtkm::Range{ 0.0, 1.0 }),
"loading linear green table failed with wrong range"); "loading linear green table failed with wrong range");
VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21), VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21),
@ -454,7 +454,7 @@ public:
{ {
std::cout << "Test Sampling" << std::endl; std::cout << "Test Sampling" << std::endl;
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::GREEN); vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::Green);
VTKM_TEST_ASSERT((table.GetRange() == vtkm::Range{ 0.0, 1.0 }), VTKM_TEST_ASSERT((table.GetRange() == vtkm::Range{ 0.0, 1.0 }),
"loading linear green table failed with wrong range"); "loading linear green table failed with wrong range");
VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21), VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21),
@ -473,7 +473,7 @@ public:
//build a color table with clamping off and verify that sampling works //build a color table with clamping off and verify that sampling works
vtkm::Range range{ 0.0, 50.0 }; vtkm::Range range{ 0.0, 50.0 };
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::COOL_TO_WARM); vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::CoolToWarm);
table.RescaleToRange(range); table.RescaleToRange(range);
table.SetClampingOff(); table.SetClampingOff();
table.SetAboveRangeColor(vtkm::Vec<float, 3>{ 1.0f, 0.0f, 0.0f }); //red table.SetAboveRangeColor(vtkm::Vec<float, 3>{ 1.0f, 0.0f, 0.0f }); //red

116
vtkm/exec/ColorTable.h
View File

@ -10,85 +10,121 @@
#ifndef vtk_m_exec_ColorTable_h #ifndef vtk_m_exec_ColorTable_h
#define vtk_m_exec_ColorTable_h #define vtk_m_exec_ColorTable_h
#include <vtkm/VirtualObjectBase.h> #include <vtkm/Deprecated.h>
#include <vtkm/Types.h>
namespace vtkm
{
enum struct ColorSpace
{
RGB,
HSV,
HSVWrap,
Lab,
Diverging
};
} // namespace vtkm
namespace vtkm namespace vtkm
{ {
namespace exec namespace exec
{ {
class VTKM_ALWAYS_EXPORT ColorTableBase : public vtkm::VirtualObjectBase class VTKM_ALWAYS_EXPORT ColorTable
{ {
public: public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(double) const; inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpace(vtkm::Float64) const;
VTKM_EXEC virtual vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpace(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const = 0; vtkm::Float32 weight) const;
inline VTKM_EXEC float MapThroughOpacitySpace(double value) const; inline VTKM_EXEC vtkm::Float32 MapThroughOpacitySpace(vtkm::Float64 value) const;
double const* ColorNodes = nullptr; vtkm::ColorSpace Space;
vtkm::Vec<float, 3> const* RGB = nullptr;
double const* ONodes = nullptr; vtkm::Float64 const* ColorNodes = nullptr;
float const* Alpha = nullptr; vtkm::Vec3f_32 const* RGB = nullptr;
vtkm::Vec<float, 2> const* MidSharp = nullptr;
vtkm::Float64 const* ONodes = nullptr;
vtkm::Float32 const* Alpha = nullptr;
vtkm::Vec2f_32 const* MidSharp = nullptr;
vtkm::Int32 ColorSize = 0; vtkm::Int32 ColorSize = 0;
vtkm::Int32 OpacitySize = 0; vtkm::Int32 OpacitySize = 0;
vtkm::Vec<float, 3> NaNColor = { 0.5f, 0.0f, 0.0f }; vtkm::Vec3f_32 NaNColor = { 0.5f, 0.0f, 0.0f };
vtkm::Vec<float, 3> BelowRangeColor = { 0.0f, 0.0f, 0.0f }; vtkm::Vec3f_32 BelowRangeColor = { 0.0f, 0.0f, 0.0f };
vtkm::Vec<float, 3> AboveRangeColor = { 0.0f, 0.0f, 0.0f }; vtkm::Vec3f_32 AboveRangeColor = { 0.0f, 0.0f, 0.0f };
bool UseClamping = true; bool UseClamping = true;
private: private:
inline VTKM_EXEC void FindColors(double value, inline VTKM_EXEC void FindColors(vtkm::Float64 value,
vtkm::Vec<float, 3>& first, vtkm::Vec3f_32& first,
vtkm::Vec<float, 3>& second, vtkm::Vec3f_32& second,
float& weight) const; vtkm::Float32& weight) const;
inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpaceRGB(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::Float32 weight) const;
inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpaceHSV(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::Float32 weight) const;
inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpaceHSVWrap(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::Float32 weight) const;
inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpaceLab(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::Float32 weight) const;
inline VTKM_EXEC vtkm::Vec3f_32 MapThroughColorSpaceDiverging(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::Float32 weight) const;
}; };
class VTKM_ALWAYS_EXPORT ColorTableRGB final : public ColorTableBase class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.6, "Use vtkm::exec::ColorTable.") ColorTableBase
: public vtkm::exec::ColorTable
{ {
public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1,
const vtkm::Vec<float, 3>& rgb2,
float weight) const;
}; };
class VTKM_ALWAYS_EXPORT ColorTableHSV final : public ColorTableBase class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.6, "Use vtkm::exec::ColorTable.") ColorTableRGB final
: public ColorTable
{ {
public: public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, ColorTableRGB() { this->Space = vtkm::ColorSpace::RGB; }
const vtkm::Vec<float, 3>& rgb2,
float weight) const;
}; };
class VTKM_ALWAYS_EXPORT ColorTableHSVWrap final : public ColorTableBase class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.6, "Use vtkm::exec::ColorTable.") ColorTableHSV final
: public ColorTable
{ {
public: public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, ColorTableHSV() { this->Space = vtkm::ColorSpace::HSV; }
const vtkm::Vec<float, 3>& rgb2,
float weight) const;
}; };
class VTKM_ALWAYS_EXPORT ColorTableLab final : public ColorTableBase class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.6, "Use vtkm::exec::ColorTable.") ColorTableHSVWrap final
: public ColorTable
{ {
public: public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, ColorTableHSVWrap() { this->Space = vtkm::ColorSpace::HSVWrap; }
const vtkm::Vec<float, 3>& rgb2,
float weight) const;
}; };
class VTKM_ALWAYS_EXPORT ColorTableDiverging final : public ColorTableBase class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.6, "Use vtkm::exec::ColorTable.") ColorTableLab final
: public ColorTable
{ {
public: public:
inline VTKM_EXEC vtkm::Vec<float, 3> MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, ColorTableLab() { this->Space = vtkm::ColorSpace::Lab; }
const vtkm::Vec<float, 3>& rgb2, };
float weight) const;
class VTKM_ALWAYS_EXPORT ColorTableDiverging final : public ColorTable
{
public:
ColorTableDiverging() { this->Space = vtkm::ColorSpace::Diverging; }
}; };
} }
} }

234
vtkm/exec/ColorTable.hxx
View File

@ -21,14 +21,14 @@ namespace detail
{ {
VTKM_EXEC VTKM_EXEC
inline void RGBToHSV(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& hsv) inline void RGBToHSV(const vtkm::Vec3f_32& rgb, vtkm::Vec3f_32& hsv)
{ {
constexpr float onethird = 1.0f / 3.0f; constexpr vtkm::Float32 onethird = 1.0f / 3.0f;
constexpr float onesixth = 1.0f / 6.0f; constexpr vtkm::Float32 onesixth = 1.0f / 6.0f;
constexpr float twothird = 2.0f / 3.0f; constexpr vtkm::Float32 twothird = 2.0f / 3.0f;
const float cmax = vtkm::Max(rgb[0], vtkm::Max(rgb[1], rgb[2])); const vtkm::Float32 cmax = vtkm::Max(rgb[0], vtkm::Max(rgb[1], rgb[2]));
const float cmin = vtkm::Min(rgb[0], vtkm::Min(rgb[1], rgb[2])); const vtkm::Float32 cmin = vtkm::Min(rgb[0], vtkm::Min(rgb[1], rgb[2]));
hsv[0] = 0.0f; hsv[0] = 0.0f;
hsv[1] = 0.0f; hsv[1] = 0.0f;
@ -57,13 +57,13 @@ inline void RGBToHSV(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& hsv)
} }
VTKM_EXEC VTKM_EXEC
inline vtkm::Vec<float, 3> HSVToRGB(const vtkm::Vec<float, 3>& hsv) inline vtkm::Vec3f_32 HSVToRGB(const vtkm::Vec3f_32& hsv)
{ {
vtkm::Vec<float, 3> rgb; vtkm::Vec3f_32 rgb;
constexpr float onethird = 1.0f / 3.0f; constexpr vtkm::Float32 onethird = 1.0f / 3.0f;
constexpr float onesixth = 1.0f / 6.0f; constexpr vtkm::Float32 onesixth = 1.0f / 6.0f;
constexpr float twothird = 2.0f / 3.0f; constexpr vtkm::Float32 twothird = 2.0f / 3.0f;
constexpr float fivesixth = 5.0f / 6.0f; constexpr vtkm::Float32 fivesixth = 5.0f / 6.0f;
// compute RGB from HSV // compute RGB from HSV
if (hsv[0] > onesixth && hsv[0] <= onethird) // green/red if (hsv[0] > onesixth && hsv[0] <= onethird) // green/red
@ -115,7 +115,7 @@ inline vtkm::Vec<float, 3> HSVToRGB(const vtkm::Vec<float, 3>& hsv)
} }
VTKM_EXEC VTKM_EXEC
inline void RGBToLab(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& lab) inline void RGBToLab(const vtkm::Vec3f_32& rgb, vtkm::Vec3f_32& lab)
{ {
// clang-format off // clang-format off
@ -128,9 +128,9 @@ inline void RGBToLab(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& lab)
// management. OpenGL is agnostic on its RGB color space, but it is reasonable // management. OpenGL is agnostic on its RGB color space, but it is reasonable
// to assume it is close to this one. // to assume it is close to this one.
{ //rgb to xyz start ( lab == xyz ) { //rgb to xyz start ( lab == xyz )
float r = rgb[0]; vtkm::Float32 r = rgb[0];
float g = rgb[1]; vtkm::Float32 g = rgb[1];
float b = rgb[2]; vtkm::Float32 b = rgb[2];
if ( r > 0.04045f ) r = vtkm::Pow(( r + 0.055f ) / 1.055f, 2.4f); if ( r > 0.04045f ) r = vtkm::Pow(( r + 0.055f ) / 1.055f, 2.4f);
else r = r / 12.92f; else r = r / 12.92f;
if ( g > 0.04045f ) g = vtkm::Pow(( g + 0.055f ) / 1.055f, 2.4f); if ( g > 0.04045f ) g = vtkm::Pow(( g + 0.055f ) / 1.055f, 2.4f);
@ -145,15 +145,15 @@ inline void RGBToLab(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& lab)
} //rgb to xyz end ( lab == xyz ) } //rgb to xyz end ( lab == xyz )
//xyz to lab start //xyz to lab start
constexpr float onethird = 1.0f / 3.0f; constexpr vtkm::Float32 onethird = 1.0f / 3.0f;
constexpr float sixteen_onesixteen = 16.0f / 116.0f; constexpr vtkm::Float32 sixteen_onesixteen = 16.0f / 116.0f;
constexpr float ref_X = 0.9505f; constexpr vtkm::Float32 ref_X = 0.9505f;
constexpr float ref_Y = 1.000f; constexpr vtkm::Float32 ref_Y = 1.000f;
constexpr float ref_Z = 1.089f; constexpr vtkm::Float32 ref_Z = 1.089f;
float var_X = lab[0] / ref_X; vtkm::Float32 var_X = lab[0] / ref_X;
float var_Y = lab[1] / ref_Y; vtkm::Float32 var_Y = lab[1] / ref_Y;
float var_Z = lab[2] / ref_Z; vtkm::Float32 var_Z = lab[2] / ref_Z;
if ( var_X > 0.008856f ) var_X = vtkm::Pow(var_X, onethird); if ( var_X > 0.008856f ) var_X = vtkm::Pow(var_X, onethird);
else var_X = ( 7.787f * var_X ) + sixteen_onesixteen; else var_X = ( 7.787f * var_X ) + sixteen_onesixteen;
@ -170,12 +170,12 @@ inline void RGBToLab(const vtkm::Vec<float, 3>& rgb, vtkm::Vec<float, 3>& lab)
} }
VTKM_EXEC VTKM_EXEC
inline vtkm::Vec<float, 3> LabToRGB(const vtkm::Vec<float, 3>& lab) inline vtkm::Vec3f_32 LabToRGB(const vtkm::Vec3f_32& lab)
{ {
// clang-format off // clang-format off
vtkm::Vec<float, 3> rgb; vtkm::Vec3f_32 rgb;
{ //lab to xyz start ( rgb == xyz ) { //lab to xyz start ( rgb == xyz )
constexpr float sixteen_onesixteen = 16.0f / 116.0f; constexpr vtkm::Float32 sixteen_onesixteen = 16.0f / 116.0f;
//notice that we are mapping L => g, a => r, and b => b //notice that we are mapping L => g, a => r, and b => b
rgb[1] = ( lab[0] + 16.0f ) / 116.0f; rgb[1] = ( lab[0] + 16.0f ) / 116.0f;
@ -190,22 +190,22 @@ inline vtkm::Vec<float, 3> LabToRGB(const vtkm::Vec<float, 3>& lab)
if ( vtkm::Pow(rgb[2],3) > 0.008856f ) rgb[2] = vtkm::Pow(rgb[2],3); if ( vtkm::Pow(rgb[2],3) > 0.008856f ) rgb[2] = vtkm::Pow(rgb[2],3);
else rgb[2] = ( rgb[2] - sixteen_onesixteen ) / 7.787f; else rgb[2] = ( rgb[2] - sixteen_onesixteen ) / 7.787f;
constexpr float ref_X = 0.9505f; constexpr vtkm::Float32 ref_X = 0.9505f;
constexpr float ref_Y = 1.000f; constexpr vtkm::Float32 ref_Y = 1.000f;
constexpr float ref_Z = 1.089f; constexpr vtkm::Float32 ref_Z = 1.089f;
rgb[0] *= ref_X; //Observer= 2 deg Illuminant= D65 rgb[0] *= ref_X; //Observer= 2 deg Illuminant= D65
rgb[1] *= ref_Y; rgb[1] *= ref_Y;
rgb[2] *= ref_Z; rgb[2] *= ref_Z;
} // lab to xyz end } // lab to xyz end
//xyz to rgb start //xyz to rgb start
rgb = vtkm::Vec<float,3>( rgb = vtkm::Vec3f_32(
rgb[0] * 3.2406f + rgb[1] * -1.5372f + rgb[2] * -0.4986f, rgb[0] * 3.2406f + rgb[1] * -1.5372f + rgb[2] * -0.4986f,
rgb[0] * -0.9689f + rgb[1] * 1.8758f + rgb[2] * 0.0415f, rgb[0] * -0.9689f + rgb[1] * 1.8758f + rgb[2] * 0.0415f,
rgb[0] * 0.0557f + rgb[1] * -0.2040f + rgb[2] * 1.0570f); rgb[0] * 0.0557f + rgb[1] * -0.2040f + rgb[2] * 1.0570f);
float& r = rgb[0]; vtkm::Float32& r = rgb[0];
float& g = rgb[1]; vtkm::Float32& g = rgb[1];
float& b = rgb[2]; vtkm::Float32& b = rgb[2];
// The following performs a "gamma correction" specified by the sRGB color // The following performs a "gamma correction" specified by the sRGB color
// space. sRGB is defined by a canonical definition of a display monitor and // space. sRGB is defined by a canonical definition of a display monitor and
@ -215,7 +215,7 @@ inline vtkm::Vec<float, 3> LabToRGB(const vtkm::Vec<float, 3>& lab)
// several applications including Adobe Photoshop and Microsoft Windows color // several applications including Adobe Photoshop and Microsoft Windows color
// management. OpenGL is agnostic on its RGB color space, but it is reasonable // management. OpenGL is agnostic on its RGB color space, but it is reasonable
// to assume it is close to this one. // to assume it is close to this one.
constexpr float one_twopointfour = ( 1.0f / 2.4f ); constexpr vtkm::Float32 one_twopointfour = ( 1.0f / 2.4f );
if (r > 0.0031308f) r = 1.055f * (vtkm::Pow(r, one_twopointfour)) - 0.055f; if (r > 0.0031308f) r = 1.055f * (vtkm::Pow(r, one_twopointfour)) - 0.055f;
else r = 12.92f * r; else r = 12.92f * r;
if (g > 0.0031308f) g = 1.055f * (vtkm::Pow(g ,one_twopointfour)) - 0.055f; if (g > 0.0031308f) g = 1.055f * (vtkm::Pow(g ,one_twopointfour)) - 0.055f;
@ -226,7 +226,7 @@ inline vtkm::Vec<float, 3> LabToRGB(const vtkm::Vec<float, 3>& lab)
// Clip colors. ideally we would do something that is perceptually closest // Clip colors. ideally we would do something that is perceptually closest
// (since we can see colors outside of the display gamut), but this seems to // (since we can see colors outside of the display gamut), but this seems to
// work well enough. // work well enough.
const float maxVal = vtkm::Max(r, vtkm::Max(g,b)); const vtkm::Float32 maxVal = vtkm::Max(r, vtkm::Max(g,b));
if (maxVal > 1.0f) if (maxVal > 1.0f)
{ {
r /= maxVal; r /= maxVal;
@ -243,14 +243,14 @@ inline vtkm::Vec<float, 3> LabToRGB(const vtkm::Vec<float, 3>& lab)
// Convert to a special polar version of CIELAB (useful for creating // Convert to a special polar version of CIELAB (useful for creating
// continuous diverging color maps). // continuous diverging color maps).
VTKM_EXEC VTKM_EXEC
inline void LabToMsh(const vtkm::Vec<float, 3>& lab, vtkm::Vec<float, 3>& msh) inline void LabToMsh(const vtkm::Vec3f_32& lab, vtkm::Vec3f_32& msh)
{ {
const float& L = lab[0]; const vtkm::Float32& L = lab[0];
const float& a = lab[1]; const vtkm::Float32& a = lab[1];
const float& b = lab[2]; const vtkm::Float32& b = lab[2];
float& M = msh[0]; vtkm::Float32& M = msh[0];
float& s = msh[1]; vtkm::Float32& s = msh[1];
float& h = msh[2]; vtkm::Float32& h = msh[2];
M = vtkm::Sqrt(L * L + a * a + b * b); M = vtkm::Sqrt(L * L + a * a + b * b);
s = (M > 0.001f) ? vtkm::ACos(L / M) : 0.0f; s = (M > 0.001f) ? vtkm::ACos(L / M) : 0.0f;
@ -260,23 +260,23 @@ inline void LabToMsh(const vtkm::Vec<float, 3>& lab, vtkm::Vec<float, 3>& msh)
// Convert from a special polar version of CIELAB (useful for creating // Convert from a special polar version of CIELAB (useful for creating
// continuous diverging color maps). // continuous diverging color maps).
VTKM_EXEC VTKM_EXEC
inline vtkm::Vec<float, 3> MshToLab(const vtkm::Vec<float, 3>& msh) inline vtkm::Vec3f_32 MshToLab(const vtkm::Vec3f_32& msh)
{ {
const float& M = msh[0]; const vtkm::Float32& M = msh[0];
const float& s = msh[1]; const vtkm::Float32& s = msh[1];
const float& h = msh[2]; const vtkm::Float32& h = msh[2];
vtkm::Vec<float, 3> r( vtkm::Vec3f_32 r(
M * vtkm::Cos(s), M * vtkm::Sin(s) * vtkm::Cos(h), M * vtkm::Sin(s) * vtkm::Sin(h)); M * vtkm::Cos(s), M * vtkm::Sin(s) * vtkm::Cos(h), M * vtkm::Sin(s) * vtkm::Sin(h));
return r; return r;
} }
// Given two angular orientations, returns the smallest angle between the two. // Given two angular orientations, returns the smallest angle between the two.
VTKM_EXEC VTKM_EXEC
inline float DivergingAngleDiff(float a1, float a2) inline vtkm::Float32 DivergingAngleDiff(vtkm::Float32 a1, vtkm::Float32 a2)
{ {
constexpr float f_pi = vtkm::Pif(); constexpr vtkm::Float32 f_pi = vtkm::Pif();
constexpr float f_two_pi = vtkm::TwoPif(); constexpr vtkm::Float32 f_two_pi = vtkm::TwoPif();
float adiff = a1 - a2; vtkm::Float32 adiff = a1 - a2;
if (adiff < 0.0f) if (adiff < 0.0f)
adiff = -adiff; adiff = -adiff;
while (adiff >= f_two_pi) while (adiff >= f_two_pi)
@ -289,9 +289,9 @@ inline float DivergingAngleDiff(float a1, float a2)
// For the case when interpolating from a saturated color to an unsaturated // For the case when interpolating from a saturated color to an unsaturated
// color, find a hue for the unsaturated color that makes sense. // color, find a hue for the unsaturated color that makes sense.
VTKM_EXEC VTKM_EXEC
inline float DivergingAdjustHue(const vtkm::Vec<float, 3>& msh, float unsatM) inline vtkm::Float32 DivergingAdjustHue(const vtkm::Vec3f_32& msh, vtkm::Float32 unsatM)
{ {
const float sinS = vtkm::Sin(msh[1]); const vtkm::Float32 sinS = vtkm::Sin(msh[1]);
if (msh[0] >= unsatM - 0.1f) if (msh[0] >= unsatM - 0.1f)
{ {
@ -302,9 +302,10 @@ inline float DivergingAdjustHue(const vtkm::Vec<float, 3>& msh, float unsatM)
{ {
// This equation is designed to make the perceptual change of the // This equation is designed to make the perceptual change of the
// interpolation to be close to constant. // interpolation to be close to constant.
float hueSpin = msh[1] * vtkm::Sqrt(unsatM * unsatM - msh[0] * msh[0]) / (msh[0] * sinS); vtkm::Float32 hueSpin =
msh[1] * vtkm::Sqrt(unsatM * unsatM - msh[0] * msh[0]) / (msh[0] * sinS);
constexpr float one_third_pi = vtkm::Pi_3f(); constexpr vtkm::Float32 one_third_pi = vtkm::Pi_3f();
// Spin hue away from 0 except in purple hues. // Spin hue away from 0 except in purple hues.
if (msh[2] > -one_third_pi) if (msh[2] > -one_third_pi)
{ {
@ -322,10 +323,10 @@ inline float DivergingAdjustHue(const vtkm::Vec<float, 3>& msh, float unsatM)
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableBase::MapThroughColorSpace(double value) const vtkm::Vec3f_32 ColorTable::MapThroughColorSpace(vtkm::Float64 value) const
{ {
vtkm::Vec<float, 3> rgb1, rgb2; vtkm::Vec3f_32 rgb1, rgb2;
float weight = 0; vtkm::Float32 weight = 0;
this->FindColors(value, rgb1, rgb2, weight); this->FindColors(value, rgb1, rgb2, weight);
if (weight == 0) if (weight == 0)
{ {
@ -343,10 +344,31 @@ vtkm::Vec<float, 3> ColorTableBase::MapThroughColorSpace(double value) const
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
void ColorTableBase::FindColors(double value, vtkm::Vec3f_32 ColorTable::MapThroughColorSpace(const vtkm::Vec3f_32& rgb1,
vtkm::Vec<float, 3>& rgb1, const vtkm::Vec3f_32& rgb2,
vtkm::Vec<float, 3>& rgb2, vtkm::Float32 weight) const
float& weight) const {
switch (this->Space)
{
case vtkm::ColorSpace::RGB:
return this->MapThroughColorSpaceRGB(rgb1, rgb2, weight);
case vtkm::ColorSpace::HSV:
return this->MapThroughColorSpaceHSV(rgb1, rgb2, weight);
case vtkm::ColorSpace::HSVWrap:
return this->MapThroughColorSpaceHSVWrap(rgb1, rgb2, weight);
case vtkm::ColorSpace::Lab:
return this->MapThroughColorSpaceLab(rgb1, rgb2, weight);
case vtkm::ColorSpace::Diverging:
return this->MapThroughColorSpaceDiverging(rgb1, rgb2, weight);
}
}
//---------------------------------------------------------------------------
VTKM_EXEC
void ColorTable::FindColors(vtkm::Float64 value,
vtkm::Vec3f_32& rgb1,
vtkm::Vec3f_32& rgb2,
vtkm::Float32& weight) const
{ {
// All the special cases have equivalent rgb1 and rgb2 values so we // All the special cases have equivalent rgb1 and rgb2 values so we
// set the weight to 0.0f as a default // set the weight to 0.0f as a default
@ -402,13 +424,13 @@ void ColorTableBase::FindColors(double value,
const auto w = const auto w =
(value - this->ColorNodes[first]) / (this->ColorNodes[second] - this->ColorNodes[first]); (value - this->ColorNodes[first]) / (this->ColorNodes[second] - this->ColorNodes[first]);
weight = static_cast<float>(w); weight = static_cast<vtkm::Float32>(w);
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
float ColorTableBase::MapThroughOpacitySpace(double value) const vtkm::Float32 ColorTable::MapThroughOpacitySpace(vtkm::Float64 value) const
{ {
if (vtkm::IsNan(value)) if (vtkm::IsNan(value))
{ //If we are trying to find the opacity of NaN use a constant of 1.0 { //If we are trying to find the opacity of NaN use a constant of 1.0
@ -442,7 +464,7 @@ float ColorTableBase::MapThroughOpacitySpace(double value) const
} }
} }
const auto w = (value - this->ONodes[first]) / (this->ONodes[second] - this->ONodes[first]); const auto w = (value - this->ONodes[first]) / (this->ONodes[second] - this->ONodes[first]);
float weight = static_cast<float>(w); vtkm::Float32 weight = static_cast<vtkm::Float32>(w);
//we only need the previous midpoint and sharpness as they control this region //we only need the previous midpoint and sharpness as they control this region
const auto& alpha1 = this->Alpha[first]; const auto& alpha1 = this->Alpha[first];
@ -490,20 +512,20 @@ float ColorTableBase::MapThroughOpacitySpace(double value) const
} }
// Compute some coefficients we will need for the hermite curve // Compute some coefficients we will need for the hermite curve
const float ww = weight * weight; const vtkm::Float32 ww = weight * weight;
const float www = weight * weight * weight; const vtkm::Float32 www = weight * weight * weight;
const float h1 = 2.0f * www - 3.0f * ww + 1.0f; const vtkm::Float32 h1 = 2.0f * www - 3.0f * ww + 1.0f;
const float h2 = -2.0f * www + 3.0f * ww; const vtkm::Float32 h2 = -2.0f * www + 3.0f * ww;
const float h3 = www - 2.0f * ww + weight; const vtkm::Float32 h3 = www - 2.0f * ww + weight;
const float h4 = www - ww; const vtkm::Float32 h4 = www - ww;
// Use one slope for both end points // Use one slope for both end points
const float slope = alpha2 - alpha1; const vtkm::Float32 slope = alpha2 - alpha1;
const float t = (1.0f - midsharp[1]) * slope; const vtkm::Float32 t = (1.0f - midsharp[1]) * slope;
// Compute the value // Compute the value
float result = h1 * alpha1 + h2 * alpha2 + h3 * t + h4 * t; vtkm::Float32 result = h1 * alpha1 + h2 * alpha2 + h3 * t + h4 * t;
// Final error check to make sure we don't go outside // Final error check to make sure we don't go outside
// the Y range // the Y range
@ -515,20 +537,20 @@ float ColorTableBase::MapThroughOpacitySpace(double value) const
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableRGB::MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, vtkm::Vec3f_32 ColorTable::MapThroughColorSpaceRGB(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const vtkm::Float32 weight) const
{ {
return vtkm::Lerp(rgb1, rgb2, weight); return vtkm::Lerp(rgb1, rgb2, weight);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableHSV::MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, vtkm::Vec3f_32 ColorTable::MapThroughColorSpaceHSV(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const vtkm::Float32 weight) const
{ {
vtkm::Vec<float, 3> hsv1, hsv2; vtkm::Vec3f_32 hsv1, hsv2;
detail::RGBToHSV(rgb1, hsv1); detail::RGBToHSV(rgb1, hsv1);
detail::RGBToHSV(rgb2, hsv2); detail::RGBToHSV(rgb2, hsv2);
@ -542,15 +564,15 @@ vtkm::Vec<float, 3> ColorTableHSV::MapThroughColorSpace(const vtkm::Vec<float, 3
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableHSVWrap::MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, vtkm::Vec3f_32 ColorTable::MapThroughColorSpaceHSVWrap(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const vtkm::Float32 weight) const
{ {
vtkm::Vec<float, 3> hsv1, hsv2; vtkm::Vec3f_32 hsv1, hsv2;
detail::RGBToHSV(rgb1, hsv1); detail::RGBToHSV(rgb1, hsv1);
detail::RGBToHSV(rgb2, hsv2); detail::RGBToHSV(rgb2, hsv2);
const float diff = hsv1[0] - hsv2[0]; const vtkm::Float32 diff = hsv1[0] - hsv2[0];
if (diff > 0.5f) if (diff > 0.5f)
{ {
hsv1[0] -= 1.0f; hsv1[0] -= 1.0f;
@ -570,11 +592,11 @@ vtkm::Vec<float, 3> ColorTableHSVWrap::MapThroughColorSpace(const vtkm::Vec<floa
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableLab::MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, vtkm::Vec3f_32 ColorTable::MapThroughColorSpaceLab(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const vtkm::Float32 weight) const
{ {
vtkm::Vec<float, 3> lab1, lab2; vtkm::Vec3f_32 lab1, lab2;
detail::RGBToLab(rgb1, lab1); detail::RGBToLab(rgb1, lab1);
detail::RGBToLab(rgb2, lab2); detail::RGBToLab(rgb2, lab2);
@ -585,27 +607,27 @@ vtkm::Vec<float, 3> ColorTableLab::MapThroughColorSpace(const vtkm::Vec<float, 3
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
VTKM_EXEC VTKM_EXEC
vtkm::Vec<float, 3> ColorTableDiverging::MapThroughColorSpace(const vtkm::Vec<float, 3>& rgb1, vtkm::Vec3f_32 ColorTable::MapThroughColorSpaceDiverging(const vtkm::Vec3f_32& rgb1,
const vtkm::Vec<float, 3>& rgb2, const vtkm::Vec3f_32& rgb2,
float weight) const vtkm::Float32 weight) const
{ {
vtkm::Vec<float, 3> lab1, lab2; vtkm::Vec3f_32 lab1, lab2;
detail::RGBToLab(rgb1, lab1); detail::RGBToLab(rgb1, lab1);
detail::RGBToLab(rgb2, lab2); detail::RGBToLab(rgb2, lab2);
vtkm::Vec<float, 3> msh1, msh2; vtkm::Vec3f_32 msh1, msh2;
detail::LabToMsh(lab1, msh1); detail::LabToMsh(lab1, msh1);
detail::LabToMsh(lab2, msh2); detail::LabToMsh(lab2, msh2);
// If the endpoints are distinct saturated colors, then place white in between // If the endpoints are distinct saturated colors, then place white in between
// them. // them.
constexpr float one_third_pi = vtkm::Pi_3f(); constexpr vtkm::Float32 one_third_pi = vtkm::Pi_3f();
if ((msh1[1] > 0.05f) && (msh2[1] > 0.05f) && if ((msh1[1] > 0.05f) && (msh2[1] > 0.05f) &&
(detail::DivergingAngleDiff(msh1[2], msh2[2]) > one_third_pi)) (detail::DivergingAngleDiff(msh1[2], msh2[2]) > one_third_pi))
{ {
// Insert the white midpoint by setting one end to white and adjusting the // Insert the white midpoint by setting one end to white and adjusting the
// scalar value. // scalar value.
float Mmid = vtkm::Max(msh1[0], msh2[0]); vtkm::Float32 Mmid = vtkm::Max(msh1[0], msh2[0]);
Mmid = vtkm::Max(88.0f, Mmid); Mmid = vtkm::Max(88.0f, Mmid);
if (weight < 0.5f) if (weight < 0.5f)
{ {
@ -640,20 +662,6 @@ vtkm::Vec<float, 3> ColorTableDiverging::MapThroughColorSpace(const vtkm::Vec<fl
return detail::LabToRGB(tmp); return detail::LabToRGB(tmp);
} }
} }
} } // namespace vtkm::exec
// Cuda seems to have a bug where it expects the template class VirtualObjectTransfer
// to be instantiated in a consistent order among all the translation units of an
// executable. Failing to do so results in random crashes and incorrect results.
// We workaroud this issue by explicitly instantiating VirtualObjectTransfer for
// all the portal types here.
#ifdef VTKM_CUDA
#include <vtkm/cont/internal/VirtualObjectTransferInstantiate.h>
VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::exec::ColorTableRGB);
VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::exec::ColorTableHSV);
VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::exec::ColorTableHSVWrap);
VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::exec::ColorTableLab);
VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::exec::ColorTableDiverging);
#endif
#endif #endif

2
vtkm/filter/testing/UnitTestFieldToColors.cxx
View File

@ -22,7 +22,7 @@ void TestFieldToColors()
//build a color table with clamping off and verify that sampling works //build a color table with clamping off and verify that sampling works
vtkm::Range range{ 0.0, 50.0 }; vtkm::Range range{ 0.0, 50.0 };
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::COOL_TO_WARM); vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::CoolToWarm);
table.RescaleToRange(range); table.RescaleToRange(range);
table.SetClampingOff(); table.SetClampingOff();
table.SetAboveRangeColor(vtkm::Vec<float, 3>{ 1.0f, 0.0f, 0.0f }); //red table.SetAboveRangeColor(vtkm::Vec<float, 3>{ 1.0f, 0.0f, 0.0f }); //red

2
vtkm/rendering/Actor.cxx
View File

@ -44,7 +44,7 @@ struct Actor::InternalsType
InternalsType(const vtkm::cont::DynamicCellSet& cells, InternalsType(const vtkm::cont::DynamicCellSet& cells,
const vtkm::cont::CoordinateSystem& coordinates, const vtkm::cont::CoordinateSystem& coordinates,
const vtkm::cont::Field& scalarField, const vtkm::cont::Field& scalarField,
const vtkm::cont::ColorTable& colorTable = vtkm::cont::ColorTable::Preset::DEFAULT) const vtkm::cont::ColorTable& colorTable = vtkm::cont::ColorTable::Preset::Default)
: Cells(cells) : Cells(cells)
, Coordinates(coordinates) , Coordinates(coordinates)
, ScalarField(scalarField) , ScalarField(scalarField)

2
vtkm/rendering/ColorBarAnnotation.cxx
View File

@ -17,7 +17,7 @@ namespace rendering
{ {
ColorBarAnnotation::ColorBarAnnotation() ColorBarAnnotation::ColorBarAnnotation()
: ColorTable(vtkm::cont::ColorSpace::LAB) : ColorTable(vtkm::ColorSpace::Lab)
, Position(vtkm::Range(-0.88, +0.88), vtkm::Range(+0.87, +0.92), vtkm::Range(0, 0)) , Position(vtkm::Range(-0.88, +0.88), vtkm::Range(+0.87, +0.92), vtkm::Range(0, 0))
, Horizontal(true) , Horizontal(true)
, FieldName("") , FieldName("")

16
vtkm/worklet/colorconversion/TransferFunction.h
View File

@ -23,7 +23,7 @@ namespace colorconversion
struct TransferFunction : public vtkm::worklet::WorkletMapField struct TransferFunction : public vtkm::worklet::WorkletMapField
{ {
TransferFunction(const vtkm::exec::ColorTableBase* table) TransferFunction(const vtkm::exec::ColorTable table)
: ColorTable(table) : ColorTable(table)
{ {
} }
@ -34,7 +34,7 @@ struct TransferFunction : public vtkm::worklet::WorkletMapField
template <typename T> template <typename T>
VTKM_EXEC void operator()(const T& in, vtkm::Vec3ui_8& output) const VTKM_EXEC void operator()(const T& in, vtkm::Vec3ui_8& output) const
{ {
vtkm::Vec<float, 3> rgb = this->ColorTable->MapThroughColorSpace(static_cast<double>(in)); vtkm::Vec<float, 3> rgb = this->ColorTable.MapThroughColorSpace(static_cast<double>(in));
output[0] = colorconversion::ColorToUChar(rgb[0]); output[0] = colorconversion::ColorToUChar(rgb[0]);
output[1] = colorconversion::ColorToUChar(rgb[1]); output[1] = colorconversion::ColorToUChar(rgb[1]);
output[2] = colorconversion::ColorToUChar(rgb[2]); output[2] = colorconversion::ColorToUChar(rgb[2]);
@ -43,8 +43,8 @@ struct TransferFunction : public vtkm::worklet::WorkletMapField
template <typename T> template <typename T>
VTKM_EXEC void operator()(const T& in, vtkm::Vec4ui_8& output) const VTKM_EXEC void operator()(const T& in, vtkm::Vec4ui_8& output) const
{ {
vtkm::Vec<float, 3> rgb = this->ColorTable->MapThroughColorSpace(static_cast<double>(in)); vtkm::Vec<float, 3> rgb = this->ColorTable.MapThroughColorSpace(static_cast<double>(in));
float alpha = this->ColorTable->MapThroughOpacitySpace(static_cast<double>(in)); float alpha = this->ColorTable.MapThroughOpacitySpace(static_cast<double>(in));
output[0] = colorconversion::ColorToUChar(rgb[0]); output[0] = colorconversion::ColorToUChar(rgb[0]);
output[1] = colorconversion::ColorToUChar(rgb[1]); output[1] = colorconversion::ColorToUChar(rgb[1]);
output[2] = colorconversion::ColorToUChar(rgb[2]); output[2] = colorconversion::ColorToUChar(rgb[2]);
@ -54,21 +54,21 @@ struct TransferFunction : public vtkm::worklet::WorkletMapField
template <typename T> template <typename T>
VTKM_EXEC void operator()(const T& in, vtkm::Vec<float, 3>& output) const VTKM_EXEC void operator()(const T& in, vtkm::Vec<float, 3>& output) const
{ {
output = this->ColorTable->MapThroughColorSpace(static_cast<double>(in)); output = this->ColorTable.MapThroughColorSpace(static_cast<double>(in));
} }
template <typename T> template <typename T>
VTKM_EXEC void operator()(const T& in, vtkm::Vec<float, 4>& output) const VTKM_EXEC void operator()(const T& in, vtkm::Vec<float, 4>& output) const
{ {
vtkm::Vec<float, 3> rgb = this->ColorTable->MapThroughColorSpace(static_cast<double>(in)); vtkm::Vec<float, 3> rgb = this->ColorTable.MapThroughColorSpace(static_cast<double>(in));
float alpha = this->ColorTable->MapThroughOpacitySpace(static_cast<double>(in)); float alpha = this->ColorTable.MapThroughOpacitySpace(static_cast<double>(in));
output[0] = rgb[0]; output[0] = rgb[0];
output[1] = rgb[1]; output[1] = rgb[1];
output[2] = rgb[2]; output[2] = rgb[2];
output[3] = alpha; output[3] = alpha;
} }
const vtkm::exec::ColorTableBase* ColorTable; const vtkm::exec::ColorTable ColorTable;
}; };
} }
} }