Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-31 03:00:57 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
f2d6ce5221
vtk-m/vtkm/cont/ColorTable.h

590 lines
23 KiB
C
Raw Normal View History

Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_ColorTable_h
#define vtk_m_cont_ColorTable_h
#include <vtkm/Range.h>
#include <vtkm/Types.h>
#include <vtkm/cont/vtkm_cont_export.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ColorTableSamples.h>
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/exec/ColorTable.h>
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
#include <set>
namespace vtkm
{
namespace cont
{
namespace detail
{
struct ColorTableInternals;
}
/// \brief Color Table for coloring arbitrary fields
///
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The `vtkm::cont::ColorTable` allows for color mapping in RGB or HSV space and
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// uses a piecewise hermite functions to allow opacity interpolation that can be
/// piecewise constant, piecewise linear, or somewhere in-between
/// (a modified piecewise hermite function that squishes the function
/// according to a sharpness parameter).
///
/// For colors interpolation is handled using a piecewise linear function.
///
/// For opacity we define a piecewise function mapping. This mapping allows the addition
/// of control points, and allows the user to control the function between
/// the control points. A piecewise hermite curve is used between control
/// points, based on the sharpness and midpoint parameters. A sharpness of
/// 0 yields a piecewise linear function and a sharpness of 1 yields a
/// piecewise constant function. The midpoint is the normalized distance
/// between control points at which the curve reaches the median Y value.
/// The midpoint and sharpness values specified when adding a node are used
/// to control the transition to the next node with the last node's values being
/// ignored.
///
/// When adding opacity nodes without an explicit midpoint and sharpness we
/// will default to to Midpoint = 0.5 (halfway between the control points) and
/// Sharpness = 0.0 (linear).
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// ColorTable also contains which ColorSpace should be used for interpolation.
/// The color space is selected with the `vtkm::ColorSpace` enumeration.
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Currently the valid ColorSpaces are:
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// - `RGB`
/// - `HSV`
/// - `HSVWrap`
/// - `Lab`
/// - `Diverging`
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// In `HSVWrap` mode, it will take the shortest path
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// in Hue (going back through 0 if that is the shortest way around the hue
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// circle) whereas HSV will not go through 0 (in order to
/// match the current functionality of `vtkLookupTable`). In `Lab` mode,
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// it will take the shortest path in the Lab color space with respect to the
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// CIE Delta E 2000 color distance measure. `Diverging` is a special
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// mode where colors will pass through white when interpolating between two
/// saturated colors.
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// 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`.
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// 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
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
{
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
std::shared_ptr<detail::ColorTableInternals> Internals;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
public:
Add a preset enum to ColorTable You can still select presets through strings (and we leave ourselves open to add more presets through strings than enumerating with the enum), but this provides a way to select a preset that is verified by the compiler.
2018-04-02 17:08:43 +00:00
enum struct Preset
{
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
Default,
CoolToWarm,
CoolToWarmExtended,
Viridis,
Inferno,
Plasma,
BlackBodyRadiation,
XRay,
Green,
BlackBlueWhite,
BlueToOrange,
GrayToRed,
ColdAndHot,
BlueGreenOrange,
YellowGrayBlue,
RainbowUniform,
Jet,
RainbowDesaturated,
Add a preset enum to ColorTable You can still select presets through strings (and we leave ourselves open to add more presets through strings than enumerating with the enum), but this provides a way to select a preset that is verified by the compiler.
2018-04-02 17:08:43 +00:00
};
/// \brief Construct a color table from a preset
///
/// Constructs a color table from a given preset, which might include a NaN color.
/// The alpha table will have 2 entries of alpha = 1.0 with linear interpolation
///
/// Note: these are a select set of the presets you can get by providing a string identifier.
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
ColorTable(vtkm::cont::ColorTable::Preset preset = vtkm::cont::ColorTable::Preset::Default);
Add a preset enum to ColorTable You can still select presets through strings (and we leave ourselves open to add more presets through strings than enumerating with the enum), but this provides a way to select a preset that is verified by the compiler.
2018-04-02 17:08:43 +00:00
Make LAB the default color space Interpolations in LAB are perceptually uniform, which generally makes it a better choice as the color space.
2018-04-02 16:46:43 +00:00
/// \brief Construct a color table from a preset color table
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// Constructs a color table from a given preset, which might include a NaN color.
/// The alpha table will have 2 entries of alpha = 1.0 with linear interpolation
///
/// Note: Names are case insensitive
/// Currently supports the following color tables:
///
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Default"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Cool to Warm"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Cool to Warm Extended"
/// "Viridis"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Inferno"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Plasma"
/// "Black-Body Radiation"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "X Ray"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Green"
/// "Black - Blue - White"
/// "Blue to Orange"
/// "Gray to Red"
/// "Cold and Hot"
/// "Blue - Green - Orange"
/// "Yellow - Gray - Blue"
/// "Rainbow Uniform"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Jet"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Rainbow Desaturated"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Make LAB the default color space Interpolations in LAB are perceptually uniform, which generally makes it a better choice as the color space.
2018-04-02 16:46:43 +00:00
explicit ColorTable(const std::string& name);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Construct a color table with a zero positions, and an invalid range
///
/// Note: The color table will have 0 entries
/// Note: The alpha table will have 0 entries
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
explicit ColorTable(vtkm::ColorSpace space);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// 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 alpha table will have 2 entries of alpha = 1.0 with linear
/// interpolation
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
ColorTable(const vtkm::Range& range, vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Construct a color table with 2 positions
//
/// Note: The alpha table will have 2 entries of alpha = 1.0 with linear
/// interpolation
ColorTable(const vtkm::Range& range,
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
const vtkm::Vec3f_32& rgb1,
const vtkm::Vec3f_32& rgb2,
vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Construct color and alpha and table with 2 positions
///
/// Note: The alpha table will use linear interpolation
ColorTable(const vtkm::Range& range,
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
const vtkm::Vec4f_32& rgba1,
const vtkm::Vec4f_32& rgba2,
vtkm::ColorSpace space = vtkm::ColorSpace::Lab);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// Construct a color table with a list of colors and alphas. For this version you must also
/// specify a name.
///
/// This constructor is mostly used for presets.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
ColorTable(
const std::string& name,
vtkm::ColorSpace colorSpace,
const vtkm::Vec3f_64& nanColor,
const std::vector<vtkm::Float64>& rgbPoints,
const std::vector<vtkm::Float64>& alphaPoints = { 0.0, 1.0, 0.5, 0.0, 1.0, 1.0, 0.5, 0.0 });
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
~ColorTable();
correct warnings in color table
2020-01-16 22:33:22 +00:00
ColorTable& operator=(const ColorTable&) = default;
ColorTable(const ColorTable&) = default;
Add missing constructors/assignment operators Having a custom assignment operator means that the compiler isn't required to generate the implicit copy constructor. This makes sure they are constructed.
2020-01-13 20:54:59 +00:00
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
const std::string& GetName() const;
void SetName(const std::string& name);
Add a preset enum to ColorTable You can still select presets through strings (and we leave ourselves open to add more presets through strings than enumerating with the enum), but this provides a way to select a preset that is verified by the compiler.
2018-04-02 17:08:43 +00:00
bool LoadPreset(vtkm::cont::ColorTable::Preset preset);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Returns the name of all preset color tables
///
Add a preset enum to ColorTable You can still select presets through strings (and we leave ourselves open to add more presets through strings than enumerating with the enum), but this provides a way to select a preset that is verified by the compiler.
2018-04-02 17:08:43 +00:00
/// This list will include all presets defined in vtkm::cont::ColorTable::Preset and could
/// include extras as well.
///
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
static std::set<std::string> GetPresets();
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Load a preset color table
///
/// Removes all existing all values in both color and alpha tables,
/// and will reset the NaN Color if the color table has that information.
/// Will not modify clamping, below, and above range state.
///
/// Note: Names are case insensitive
///
/// Currently supports the following color tables:
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Default"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Cool to Warm"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Cool to Warm Extended"
/// "Viridis"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Inferno"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Plasma"
/// "Black-Body Radiation"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "X Ray"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Green"
/// "Black - Blue - White"
/// "Blue to Orange"
/// "Gray to Red"
/// "Cold and Hot"
/// "Blue - Green - Orange"
/// "Yellow - Gray - Blue"
/// "Rainbow Uniform"
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// "Jet"
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// "Rainbow Desaturated"
///
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
bool LoadPreset(const std::string& name);
/// Make a deep copy of the current color table
///
/// The ColorTable is implemented so that all stack based copies are 'shallow'
/// copies. This means that they all alter the same internal instance. But
/// sometimes you need to make an actual fully independent copy.
ColorTable MakeDeepCopy();
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::ColorSpace GetColorSpace() const;
void SetColorSpace(vtkm::ColorSpace space);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// If clamping is disabled values that lay out side
/// the color table range are colored based on Below
/// and Above settings.
///
/// By default clamping is enabled
void SetClampingOn() { this->SetClamping(true); }
void SetClampingOff() { this->SetClamping(false); }
void SetClamping(bool state);
bool GetClamping() const;
/// Color to use when clamping is disabled for any value
/// that is below the given range
///
/// Default value is {0,0,0}
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
void SetBelowRangeColor(const vtkm::Vec3f_32& c);
const vtkm::Vec3f_32& GetBelowRangeColor() const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Color to use when clamping is disabled for any value
/// that is above the given range
///
/// Default value is {0,0,0}
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
void SetAboveRangeColor(const vtkm::Vec3f_32& c);
const vtkm::Vec3f_32& GetAboveRangeColor() const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
void SetNaNColor(const vtkm::Vec3f_32& c);
const vtkm::Vec3f_32& GetNaNColor() const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
Make default ColorTable preset Changed the "default" ColorTable preset from "cool to warm" to "viridis." Also made a default constructor for ColorTable that sets it to this default preset. The main reason to change to viridis for the default is that it is in LAB space. We are concerned that having the default ColorTable preset being Diverging space could lead to users using that color space inappropriately.
2018-04-02 21:28:25 +00:00
/// Remove all existing values in both color and alpha tables.
/// Does not remove the clamping, below, and above range state or colors.
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
void Clear();
/// Remove only color table values
void ClearColors();
/// Remove only alpha table values
void ClearAlpha();
/// Reverse the rgb values inside the color table
void ReverseColors();
/// Reverse the alpha, mid, and sharp values inside the opacity table.
///
/// Note: To keep the shape correct the mid and sharp values of the last
/// node are not included in the reversal
void ReverseAlpha();
/// Returns min and max position of all function points
const vtkm::Range& GetRange() const;
/// Rescale the color and opacity transfer functions to match the
/// input range.
void RescaleToRange(const vtkm::Range& range);
// Functions for Colors
/// Adds a point to the color function. If the point already exists, it
/// will be updated to the new value.
///
/// Note: rgb values need to be between 0 and 1.0 (inclusive).
/// Return the index of the point (0 based), or -1 osn error.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddPoint(vtkm::Float64 x, const vtkm::Vec3f_32& rgb);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Adds a point to the color function. If the point already exists, it
/// will be updated to the new value.
///
/// Note: hsv values need to be between 0 and 1.0 (inclusive).
/// Return the index of the point (0 based), or -1 on error.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddPointHSV(vtkm::Float64 x, const vtkm::Vec3f_32& hsv);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Add a line segment to the color function. All points which lay between x1 and x2
/// (inclusive) are removed from the function.
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddSegment(vtkm::Float64 x1,
const vtkm::Vec3f_32& rgb1,
vtkm::Float64 x2,
const vtkm::Vec3f_32& rgb2);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Add a line segment to the color function. All points which lay between x1 and x2
/// (inclusive) are removed from the function.
///
/// 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
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddSegmentHSV(vtkm::Float64 x1,
const vtkm::Vec3f_32& hsv1,
vtkm::Float64 x2,
const vtkm::Vec3f_32& hsv2);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// 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)
/// Return the index of the point (0 based), or -1 on error.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool GetPoint(vtkm::Int32 index, vtkm::Vec4f_64&) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// 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
/// the function and re-inserted in the proper sorted location.
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 UpdatePoint(vtkm::Int32 index, const vtkm::Vec4f_64&);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Remove the Color function point that exists at exactly x
///
/// Return true if the point x exists and has been removed
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool RemovePoint(vtkm::Float64 x);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Remove the Color function point n
///
/// Return true if n >= 0 && n < GetNumberOfPoints
bool RemovePoint(vtkm::Int32 index);
/// Returns the number of points in the color function
vtkm::Int32 GetNumberOfPoints() const;
// Functions for Opacity
/// Adds a point to the opacity function. If the point already exists, it
/// will be updated to the new value. Uses a midpoint of 0.5 (halfway between the control points)
/// and sharpness of 0.0 (linear).
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddPointAlpha(vtkm::Float64 x, vtkm::Float32 alpha)
{
return AddPointAlpha(x, alpha, 0.5f, 0.0f);
}
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Adds a point to the opacity function. If the point already exists, it
/// will be updated to the new value.
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddPointAlpha(vtkm::Float64 x,
vtkm::Float32 alpha,
vtkm::Float32 midpoint,
vtkm::Float32 sharpness);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// 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
/// 0.5 (halfway between the control points) and sharpness of 0.0 (linear).
///
/// 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
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
vtkm::Float32 alpha1,
vtkm::Float64 x2,
vtkm::Float32 alpha2)
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
{
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Vec2f_32 mid_sharp(0.5f, 0.0f);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
return AddSegmentAlpha(x1, alpha1, x2, alpha2, mid_sharp, mid_sharp);
}
/// Add a line segment to the opacity function. All points which lay between x1 and x2
/// (inclusive) are removed from the function.
///
/// 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
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 AddSegmentAlpha(vtkm::Float64 x1,
vtkm::Float32 alpha1,
vtkm::Float64 x2,
vtkm::Float32 alpha2,
const vtkm::Vec2f_32& mid_sharp1,
const vtkm::Vec2f_32& mid_sharp2);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Get the location, alpha, midpoint and sharpness information for an existing
/// point in the opacity function.
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool GetPointAlpha(vtkm::Int32 index, vtkm::Vec4f_64&) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Update the location, alpha, midpoint and sharpness information for an existing
/// point in the opacity function.
/// If the location value for the index is modified the point is removed from
/// the function and re-inserted in the proper sorted location
///
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::Int32 UpdatePointAlpha(vtkm::Int32 index, const vtkm::Vec4f_64&);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Remove the Opacity function point that exists at exactly x
///
/// Return true if the point x exists and has been removed
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool RemovePointAlpha(vtkm::Float64 x);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// Remove the Opacity function point n
///
/// Return true if n >= 0 && n < GetNumberOfPointsAlpha
bool RemovePointAlpha(vtkm::Int32 index);
/// Returns the number of points in the alpha function
vtkm::Int32 GetNumberOfPointsAlpha() const;
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Fill the Color table from a vtkm::Float64 pointer
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The vtkm::Float64 pointer is required to have the layout out of [X1, R1,
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the
/// number of nodes.
/// This will remove any existing color control points.
///
/// Note: n represents the length of the array, so ( n/4 == number of control points )
///
/// Note: This is provided as a interoperability method with VTK
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Fill the Color table from a vtkm::Float32 pointer
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The vtkm::Float64 pointer is required to have the layout out of [X1, R1,
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// G1, B1, X2, R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the
/// number of nodes.
/// This will remove any existing color control points.
///
/// Note: n represents the length of the array, so ( n/4 == number of control points )
///
/// Note: This is provided as a interoperability method with VTK
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool FillColorTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Fill the Opacity table from a vtkm::Float64 pointer
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The vtkm::Float64 pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2,
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// ..., 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
/// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear
/// interpolation of the alpha.
///
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// This will remove any existing opacity control points.
///
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// Note: n represents the length of the array, so ( n/4 == number of control points )
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float64* ptr);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Fill the Opacity table from a vtkm::Float32 pointer
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The vtkm::Float32 pointer is required to have the layout out of [X1, A1, M1, S1, X2, A2, M2, S2,
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// ..., 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
/// the Si values represent sharpness. Use 0.5 for midpoint and 0.0 for sharpness to have linear
/// interpolation of the alpha.
///
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// This will remove any existing opacity control points.
///
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
/// Note: n represents the length of the array, so ( n/4 == number of control points )
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// Will return false and not modify anything if n is <= 0 or ptr == nullptr
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
bool FillOpacityTableFromDataPointer(vtkm::Int32 n, const vtkm::Float32* ptr);
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// \brief generate RGB colors using regular spaced samples along the range.
///
/// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within vtkm::Float32 space and the following are within a tolerance:
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples
///
/// Note: This will return false if the number of samples is less than 2
Move ColorTable::Sample methods to vtkm_cont There is little value to declare them `inline`. Instead, just have them compiled once in the `vtkm_cont` library.
2020-09-14 21:47:42 +00:00
bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ColorTableSamplesRGBA& samples,
vtkm::Float64 tolerance = 0.002) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// \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
/// values using either vtkm::Float32 or vtkm::Float64 space.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within vtkm::Float32 space and the following are within a tolerance:
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples
///
/// Note: This will return false if the number of samples is less than 2
Move ColorTable::Sample methods to vtkm_cont There is little value to declare them `inline`. Instead, just have them compiled once in the `vtkm_cont` library.
2020-09-14 21:47:42 +00:00
bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ColorTableSamplesRGB& samples,
vtkm::Float64 tolerance = 0.002) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// \brief generate RGBA colors using regular spaced samples along the range.
///
/// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within vtkm::Float32 space and the following are within a tolerance:
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples
///
/// Note: This will return false if the number of samples is less than 2
Move ColorTable::Sample methods to vtkm_cont There is little value to declare them `inline`. Instead, just have them compiled once in the `vtkm_cont` library.
2020-09-14 21:47:42 +00:00
bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8>& colors,
vtkm::Float64 tolerance = 0.002) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
/// \brief generate RGB colors using regular spaced samples along the range.
///
/// Will use the current range of the color table to generate evenly spaced
/// values using either vtkm::Float32 or vtkm::Float64 space.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// Will use vtkm::Float32 space when the difference between the vtkm::Float32 and vtkm::Float64
/// values when the range is within vtkm::Float32 space and the following are within a tolerance:
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
/// - (max-min) / numSamples
/// - ((max-min) / numSamples) * numSamples
///
/// Note: This will return false if the number of samples is less than 2
Move ColorTable::Sample methods to vtkm_cont There is little value to declare them `inline`. Instead, just have them compiled once in the `vtkm_cont` library.
2020-09-14 21:47:42 +00:00
bool Sample(vtkm::Int32 numSamples,
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8>& colors,
vtkm::Float64 tolerance = 0.002) const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
ColorTable can provide vtkm::exec::Colortable to a specific device Previously it wasn't possible to get a color table transfered to a specific device.
2018-07-12 12:28:40 +00:00
/// \brief returns a virtual object pointer of the exec color table
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
///
ColorTable can provide vtkm::exec::Colortable to a specific device Previously it wasn't possible to get a color table transfered to a specific device.
2018-07-12 12:28:40 +00:00
/// This pointer is only valid as long as the ColorTable is unmodified
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
vtkm::exec::ColorTable PrepareForExecution(vtkm::cont::DeviceAdapterId deviceId,
vtkm::cont::Token& token) const;
Convert execution preparation to use tokens Marked the old versions of PrepareFor* that do not use tokens as deprecated and moved all of the code to use the new versions that require a token. This makes the scope of the execution object more explicit so that it will be kept while in use and can potentially be reclaimed afterward.
2020-01-21 20:18:03 +00:00
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// \brief Returns the modified count for changes of the color table
Add a filter that uses ColorTable to color any field from a dataset.
2018-03-29 18:46:39 +00:00
///
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// The `ModifiedCount` of the color table starts at 1 and gets incremented
/// every time a change is made to the color table.
Add a filter that uses ColorTable to color any field from a dataset.
2018-03-29 18:46:39 +00:00
/// 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.
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
/// 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.
Add a filter that uses ColorTable to color any field from a dataset.
2018-03-29 18:46:39 +00:00
vtkm::Id GetModifiedCount() const;
Redesign vtkm::cont::ColorTable to work with separable compilation.
2018-10-26 15:53:52 +00:00
private:
Remove virtual methods from ColorTable 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.
2020-09-14 19:26:16 +00:00
void UpdateArrayHandles() const;
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
};
}
} //namespace vtkm::cont
#endif //vtk_m_cont_ColorTable_h
Reference in New Issue Copy Permalink