vtkSMColorMapEditorHelper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMColorMapEditorHelper_h
#define vtkSMColorMapEditorHelper_h

#include "vtkObject.h"              // Superclass
#include "vtkRemotingViewsModule.h" // needed for exports
#include "vtkSmartPointer.h"        // For LastLUTProxy

#include <array>   // For array
#include <cstdint> // For int
#include <map>     // For map
#include <string>  // For string
#include <vector>  // For vector

class vtkPVArrayInformation;
class vtkPVProminentValuesInformation;
class vtkSMProperty;
class vtkSMProxy;
class vtkSMPVRepresentationProxy;

// template <bool UseBlockProperties = false>
class VTKREMOTINGVIEWS_EXPORT vtkSMColorMapEditorHelper : public vtkObject
{
public:
  static vtkSMColorMapEditorHelper* New();
  vtkTypeMacro(vtkSMColorMapEditorHelper, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum SelectedPropertiesTypes
  {
    Representation = 0,
    Blocks = 1
  };

  enum BlockPropertyState : std::uint8_t
  {
    // Property is disabled because it can not be edited
    Disabled = 0x0,
    // Property is inherited from the representation
    RepresentationInherited = 0x1,
    // Property is inherited from a block
    BlockInherited = 0x2,
    // Property is inherited from a block and the representation
    MixedInherited = 0x3,
    // Property is set in all blocks
    Set = 0x4,
    // Property is set in some blocks and representation inherited
    SetAndRepresentationInherited = 0x5,
    // Property is set in some blocks and block inherited
    SetAndBlockInherited = 0x6,
    // Property is set in some blocks and mixed inherited
    SetAndMixedInherited = 0x7,
    // Number of possible states
    NumberOfStates = 0x8
  };


  vtkSetClampMacro(SelectedPropertiesType, int, SelectedPropertiesTypes::Representation,
    SelectedPropertiesTypes::Blocks);
  void SetSelectedPropertiesTypeToRepresentation()
  {
    this->SetSelectedPropertiesType(SelectedPropertiesTypes::Representation);
  }
  void SetSelectedPropertiesTypeToBlocks()
  {
    this->SetSelectedPropertiesType(SelectedPropertiesTypes::Blocks);
  }
  vtkGetMacro(SelectedPropertiesType, int);

  static SelectedPropertiesTypes GetPropertyType(vtkSMProperty* property);


  static std::pair<std::string, BlockPropertyState> HasBlockProperty(
    vtkSMProxy* proxy, const std::string& blockSelector, const std::string& propertyName);
  static std::pair<std::string, BlockPropertyState> GetBlockPropertyStateFromBlockPropertyStates(
    const std::vector<std::pair<std::string, BlockPropertyState>>& states);
  static std::pair<std::string, BlockPropertyState> HasBlockProperty(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const std::string& propertyName);
  static std::pair<std::string, BlockPropertyState> HasBlockProperties(vtkSMProxy* proxy,
    const std::string& blockSelector, const std::vector<std::string>& propertyNames);
  static std::pair<std::string, BlockPropertyState> HasBlocksProperties(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const std::vector<std::string>& propertyNames);

  static std::vector<std::string> GetSelectedBlockSelectors(vtkSMProxy* proxy);

  static std::vector<std::string> GetColorArraysBlockSelectors(vtkSMProxy* proxy);
  static vtkSMProxy* GetLookupTable(vtkSMProxy* proxy);
  static vtkSMProxy* GetLookupTable(vtkSMProxy* proxy, vtkSMProxy* view);
  static vtkSMProxy* GetBlockLookupTable(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksLookupTables(proxy, { blockSelector }).front();
  }
  static std::vector<vtkSMProxy*> GetBlocksLookupTables(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  static vtkSMProxy* GetBlockLookupTable(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksLookupTables(proxy, view, { blockSelector }).front();
  }
  static std::vector<vtkSMProxy*> GetBlocksLookupTables(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::vector<std::string>& blockSelectors);
  std::vector<vtkSMProxy*> GetSelectedLookupTables(vtkSMProxy* proxy);
  std::vector<vtkSMProxy*> GetSelectedLookupTables(vtkSMProxy* proxy, vtkSMProxy* view);


  static bool GetUsingScalarColoring(vtkSMProxy* proxy);
  static bool GetBlockUsingScalarColoring(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksUsingScalarColoring(proxy, { blockSelector })
      .front();
  }
  static std::vector<vtkTypeBool> GetBlocksUsingScalarColoring(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  static bool GetAnyBlockUsingScalarColoring(vtkSMProxy* proxy);
  std::vector<vtkTypeBool> GetSelectedUsingScalarColorings(vtkSMProxy* proxy);
  bool GetAnySelectedUsingScalarColoring(vtkSMProxy* proxy);


  static void SetupLookupTable(vtkSMProxy* proxy);
  static void SetupBlocksLookupTables(vtkSMProxy* proxy);


  static bool UpdateScalarBarRange(vtkSMProxy* proxy, vtkSMProxy* view, bool deleteRange);
  static std::vector<vtkTypeBool> UpdateBlocksScalarBarRange(
    vtkSMProxy* proxy, vtkSMProxy* view, bool deleteRange);


  static bool SetScalarColoring(vtkSMProxy* proxy, const char* arrayName, int attributeType);
  static bool SetBlockScalarColoring(
    vtkSMProxy* proxy, const std::string& blockSelector, const char* arrayName, int attributeType)
  {
    return vtkSMColorMapEditorHelper::SetBlocksScalarColoring(
      proxy, { blockSelector }, arrayName, attributeType)
      .front();
  }
  static std::vector<vtkTypeBool> SetBlocksScalarColoring(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType);
  std::vector<vtkTypeBool> SetSelectedScalarColoring(
    vtkSMProxy* proxy, const char* arrayName, int attributeType);


  static bool SetScalarColoring(
    vtkSMProxy* proxy, const char* arrayName, int attributeType, int component);
  static bool SetBlockScalarColoring(vtkSMProxy* proxy, const std::string& blockSelector,
    const char* arrayName, int attributeType, int component)
  {
    return vtkSMColorMapEditorHelper::SetBlocksScalarColoring(
      proxy, { blockSelector }, arrayName, attributeType, component)
      .front();
  }
  static std::vector<vtkTypeBool> SetBlocksScalarColoring(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType,
    int component);
  std::vector<vtkTypeBool> SetSelectedScalarColoring(
    vtkSMProxy* proxy, const char* arrayName, int attributeType, int component);


  static bool RescaleTransferFunctionToDataRange(
    vtkSMProxy* proxy, bool extend = false, bool force = true);
  static bool RescaleBlockTransferFunctionToDataRange(
    vtkSMProxy* proxy, const std::string& blockSelector, bool extend = false, bool force = true)
  {
    return vtkSMColorMapEditorHelper::RescaleBlocksTransferFunctionToDataRange(
      proxy, { blockSelector }, extend, force)
      .front();
  }
  static std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRange(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, bool extend = false, bool force = true);
  std::vector<vtkTypeBool> RescaleSelectedTransferFunctionToDataRange(
    vtkSMProxy* proxy, bool extend = false, bool force = true);


  static bool RescaleTransferFunctionToDataRange(vtkSMProxy* proxy, const char* arrayName,
    int attributeType, bool extend = false, bool force = true);
  static bool RescaleBlockTransferFunctionToDataRange(vtkSMProxy* proxy,
    const std::string& blockSelector, const char* arrayName, int attributeType, bool extend = false,
    bool force = true)
  {
    return vtkSMColorMapEditorHelper::RescaleBlocksTransferFunctionToDataRange(
      proxy, { blockSelector }, arrayName, attributeType, extend, force)
      .front();
  }
  static std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRange(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType,
    bool extend = false, bool force = true);
  std::vector<vtkTypeBool> RescaleSelectedTransferFunctionToDataRange(vtkSMProxy* proxy,
    const char* arrayName, int attributeType, bool extend = false, bool force = true);


  static bool RescaleTransferFunctionToDataRangeOverTime(vtkSMProxy* proxy);
  static bool RescaleBlockTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::RescaleBlocksTransferFunctionToDataRangeOverTime(
      proxy, { blockSelector })
      .front();
  }
  static std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<vtkTypeBool> RescaleSelectedTransferFunctionToDataRangeOverTime(vtkSMProxy* proxy);


  static bool RescaleTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const char* arrayName, int attributeType);
  static bool RescaleBlockTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const std::string& blockSelector, const char* arrayName, int attributeType)
  {
    return vtkSMColorMapEditorHelper::RescaleBlocksTransferFunctionToDataRangeOverTime(
      proxy, { blockSelector }, arrayName, attributeType)
      .front();
  }
  static std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, const char* arrayName,
    int attributeType);
  std::vector<vtkTypeBool> RescaleSelectedTransferFunctionToDataRangeOverTime(
    vtkSMProxy* proxy, const char* arrayName, int attributeType);


  static bool RescaleTransferFunctionToVisibleRange(vtkSMProxy* proxy, vtkSMProxy* view);
  static bool RescaleTransferFunctionToVisibleRange(
    vtkSMProxy* proxy, vtkSMProxy* view, const char* arrayName, int attributeType);


  static bool SetScalarBarVisibility(vtkSMProxy* proxy, vtkSMProxy* view, bool visible);
  static bool SetBlockScalarBarVisibility(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::string& blockSelector, bool visible)
  {
    return vtkSMColorMapEditorHelper::SetBlocksScalarBarVisibility(
      proxy, view, { blockSelector }, visible)
      .front();
  }
  static std::vector<vtkTypeBool> SetBlocksScalarBarVisibility(vtkSMProxy* proxy, vtkSMProxy* view,
    const std::vector<std::string>& blockSelectors, bool visible);
  std::vector<vtkTypeBool> SetSelectedScalarBarVisibility(
    vtkSMProxy* proxy, vtkSMProxy* view, bool visible);


  static bool HideScalarBarIfNotNeeded(vtkSMProxy* repr, vtkSMProxy* view);
  static bool HideBlocksScalarBarIfNotNeeded(vtkSMProxy* repr, vtkSMProxy* view);


  static bool IsScalarBarVisible(vtkSMProxy* repr, vtkSMProxy* view);
  static bool IsBlockScalarBarVisible(
    vtkSMProxy* repr, vtkSMProxy* view, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::IsBlocksScalarBarVisible(repr, view, { blockSelector })
      .front();
  }
  static std::vector<vtkTypeBool> IsBlocksScalarBarVisible(
    vtkSMProxy* repr, vtkSMProxy* view, const std::vector<std::string>& blockSelectors);


  static vtkPVArrayInformation* GetArrayInformationForColorArray(
    vtkSMProxy* proxy, bool checkRepresentedData = true);
  static vtkPVArrayInformation* GetBlockArrayInformationForColorArray(
    vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksArrayInformationForColorArray(
      proxy, { blockSelector })
      .front();
  }
  static std::vector<vtkPVArrayInformation*> GetBlocksArrayInformationForColorArray(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);


  static std::string GetDecoratedArrayName(vtkSMProxy* proxy, const std::string& arrayName);
  static std::string GetBlockDecoratedArrayName(
    vtkSMProxy* proxy, const std::string& blockSelector, const std::string& arrayName)
  {
    return vtkSMColorMapEditorHelper::GetBlocksDecoratedArrayNames(
      proxy, { blockSelector }, arrayName)
      .front();
  }
  static std::vector<std::string> GetBlocksDecoratedArrayNames(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const std::string& arrayName);


  static vtkPVProminentValuesInformation* GetProminentValuesInformationForColorArray(
    vtkSMProxy* proxy, double uncertaintyAllowed = 1e-6, double fraction = 1e-3,
    bool force = false);
  static vtkPVProminentValuesInformation* GetBlockProminentValuesInformationForColorArray(
    vtkSMProxy* proxy, const std::string& blockSelector, double uncertaintyAllowed = 1e-6,
    double fraction = 1e-3, bool force = false)
  {
    return vtkSMColorMapEditorHelper::GetBlocksProminentValuesInformationForColorArray(
      proxy, { blockSelector }, uncertaintyAllowed, fraction, force)
      .front();
  }
  static std::vector<vtkPVProminentValuesInformation*>
  GetBlocksProminentValuesInformationForColorArray(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, double uncertaintyAllowed = 1e-6,
    double fraction = 1e-3, bool force = false);


  static int GetEstimatedNumberOfAnnotationsOnScalarBar(vtkSMProxy* proxy, vtkSMProxy* view);
  static int GetBlockEstimatedNumberOfAnnotationsOnScalarBar(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksEstimatedNumberOfAnnotationsOnScalarBars(
      proxy, view, { blockSelector })
      .front();
  }
  static std::vector<int> GetBlocksEstimatedNumberOfAnnotationsOnScalarBars(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::vector<std::string>& blockSelectors);
  std::vector<int> GetSelectedEstimatedNumberOfAnnotationsOnScalarBars(
    vtkSMProxy* proxy, vtkSMProxy* view);
  int GetAnySelectedEstimatedNumberOfAnnotationsOnScalarBar(vtkSMProxy* proxy, vtkSMProxy* view);


  static int IsScalarBarStickyVisible(vtkSMProxy* proxy, vtkSMProxy* view);
  static int IsBlockScalarBarStickyVisible(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::IsBlocksScalarBarStickyVisible(proxy, view, { blockSelector })
      .front();
  }
  static std::vector<int> IsBlocksScalarBarStickyVisible(
    vtkSMProxy* proxy, vtkSMProxy* view, const std::vector<std::string>& blockSelectors);

  using Color = std::array<double, 3>;

  static bool IsColorValid(Color color);
  static void SetColor(vtkSMProxy* proxy, Color color);
  static void SetBlockColor(vtkSMProxy* proxy, const std::string& blockSelector, Color color)
  {
    vtkSMColorMapEditorHelper::SetBlocksColor(proxy, { blockSelector }, color);
  }
  static void SetBlocksColor(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, Color color);
  static void RemoveBlockColor(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksColors(proxy, { blockSelector });
  }
  static void RemoveBlocksColors(vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  void SetSelectedColor(vtkSMProxy* proxy, Color color);
  static Color GetColor(vtkSMProxy* proxy);
  static Color GetBlockColor(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksColors(proxy, { blockSelector }).front();
  }
  static std::vector<Color> GetBlocksColors(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<Color> GetSelectedColors(vtkSMProxy* proxy);


  static vtkSMProperty* GetColorArrayProperty(vtkSMProxy* proxy);
  static vtkSMProperty* GetBlockColorArrayProperty(vtkSMProxy* proxy);
  vtkSMProperty* GetSelectedColorArrayProperty(vtkSMProxy* proxy);

  using ColorArray = std::pair<int, std::string>;

  static bool IsColorArrayValid(const ColorArray& array);
  static std::vector<ColorArray> GetBlocksColorArrays(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  static int GetBlockColorArrayAssociation(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlockColorArray(proxy, blockSelector).first;
  }
  static std::string GetBlockColorArrayName(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlockColorArray(proxy, blockSelector).second;
  }
  static std::map<ColorArray, std::vector<std::string>> GetCommonColorArraysBlockSelectors(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<ColorArray> GetSelectedColorArrays(vtkSMProxy* proxy);


  static vtkSMProperty* GetUseSeparateColorMapProperty(vtkSMProxy* proxy);
  static vtkSMProperty* GetBlockUseSeparateColorMapProperty(vtkSMProxy* proxy);
  vtkSMProperty* GetSelectedUseSeparateColorMapProperty(vtkSMProxy* proxy);


  static bool IsUseSeparateColorMapValid(int useSeparateColorMap);
  static void SetUseSeparateColorMap(vtkSMProxy* proxy, bool use);
  static void SetBlockUseSeparateColorMap(
    vtkSMProxy* proxy, const std::string& blockSelector, bool use)
  {
    vtkSMColorMapEditorHelper::SetBlocksUseSeparateColorMap(proxy, { blockSelector }, use);
  }
  static void SetBlocksUseSeparateColorMap(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, bool use);
  static void RemoveBlockUseSeparateColorMap(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksUseSeparateColorMaps(proxy, { blockSelector });
  }
  static void RemoveBlocksUseSeparateColorMaps(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  void SetSelectedUseSeparateColorMap(vtkSMProxy* proxy, bool use);
  static bool GetUseSeparateColorMap(vtkSMProxy* proxy);
  static int GetBlockUseSeparateColorMap(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksUseSeparateColorMaps(proxy, { blockSelector })
      .front();
  }
  static std::vector<int> GetBlocksUseSeparateColorMaps(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<int> GetSelectedUseSeparateColorMaps(vtkSMProxy* proxy);
  bool GetAnySelectedUseSeparateColorMap(vtkSMProxy* proxy);


  static bool IsMapScalarsValid(int mapScalars);
  static void SetMapScalars(vtkSMProxy* proxy, bool mapScalars);
  static void SetBlockMapScalars(
    vtkSMProxy* proxy, const std::string& blockSelector, bool mapScalars)
  {
    vtkSMColorMapEditorHelper::SetBlocksMapScalars(proxy, { blockSelector }, mapScalars);
  }
  static void SetBlocksMapScalars(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, bool mapScalars);
  static void RemoveBlockMapScalars(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksMapScalars(proxy, { blockSelector });
  }
  static void RemoveBlocksMapScalars(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  void SetSelectedMapScalars(vtkSMProxy* proxy, bool mapScalars);
  static bool GetMapScalars(vtkSMProxy* proxy);
  static int GetBlockMapScalars(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksMapScalars(proxy, { blockSelector }).front();
  }
  static std::vector<int> GetBlocksMapScalars(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<int> GetSelectedMapScalars(vtkSMProxy* proxy);
  bool GetAnySelectedMapScalars(vtkSMProxy* proxy);


  static bool IsInterpolateScalarsBeforeMappingValid(int interpolate);
  static void SetInterpolateScalarsBeforeMapping(vtkSMProxy* proxy, bool interpolate);
  static void SetBlockInterpolateScalarsBeforeMapping(
    vtkSMProxy* proxy, const std::string& blockSelector, bool interpolate)
  {
    vtkSMColorMapEditorHelper::SetBlocksInterpolateScalarsBeforeMapping(
      proxy, { blockSelector }, interpolate);
  }
  static void SetBlocksInterpolateScalarsBeforeMapping(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, bool interpolate);
  static void RemoveBlockInterpolateScalarsBeforeMapping(
    vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksInterpolateScalarsBeforeMappings(
      proxy, { blockSelector });
  }
  static void RemoveBlocksInterpolateScalarsBeforeMappings(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  void SetSelectedInterpolateScalarsBeforeMapping(vtkSMProxy* proxy, bool interpolate);
  static bool GetInterpolateScalarsBeforeMapping(vtkSMProxy* proxy);
  static int GetBlockInterpolateScalarsBeforeMapping(
    vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksInterpolateScalarsBeforeMappings(
      proxy, { blockSelector })
      .front();
  }
  static std::vector<int> GetBlocksInterpolateScalarsBeforeMappings(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<int> GetSelectedInterpolateScalarsBeforeMappings(vtkSMProxy* proxy);
  bool GetAnySelectedInterpolateScalarsBeforeMapping(vtkSMProxy* proxy);


  static bool IsOpacityValid(double opacity);
  static void SetOpacity(vtkSMProxy* proxy, double opacity);
  static void SetBlockOpacity(vtkSMProxy* proxy, const std::string& blockSelector, double opacity)
  {
    vtkSMColorMapEditorHelper::SetBlocksOpacity(proxy, { blockSelector }, opacity);
  }
  static void SetBlocksOpacity(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, double opacity);
  static void RemoveBlockOpacity(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksOpacities(proxy, { blockSelector });
  }
  static void RemoveBlocksOpacities(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  void SetSelectedOpacity(vtkSMProxy* proxy, double opacity);
  static double GetOpacity(vtkSMProxy* proxy);
  static double GetBlockOpacity(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksOpacities(proxy, { blockSelector }).front();
  }
  static std::vector<double> GetBlocksOpacities(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  std::vector<double> GetSelectedOpacities(vtkSMProxy* proxy);


  static void ResetBlockProperty(
    vtkSMProxy* proxy, const std::string& blockSelector, const std::string& propertyName)
  {
    vtkSMColorMapEditorHelper::ResetBlocksProperty(proxy, { blockSelector }, propertyName);
  }
  static void RemoveBlockProperties(vtkSMProxy* proxy, const std::string& blockSelector,
    const std::vector<std::string>& propertyNames)
  {
    vtkSMColorMapEditorHelper::ResetBlocksProperties(proxy, { blockSelector }, propertyNames);
  }
  static void ResetBlocksProperty(vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors,
    const std::string& propertyName)
  {
    vtkSMColorMapEditorHelper::ResetBlocksProperties(proxy, blockSelectors, { propertyName });
  }
  static void ResetBlocksProperties(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const std::vector<std::string>& propertyNames);

protected:
  vtkSMColorMapEditorHelper();
  ~vtkSMColorMapEditorHelper() override;


  // Add proxy parameter?
  static bool RescaleTransferFunctionToDataRange(
    vtkSMProxy* proxy, vtkPVArrayInformation* info, bool extend = false, bool force = true);
  static bool RescaleBlockTransferFunctionToDataRange(vtkSMProxy* proxy,
    const std::string& blockSelector, vtkPVArrayInformation* info, bool extend = false,
    bool force = true)
  {
    return vtkSMColorMapEditorHelper::RescaleBlocksTransferFunctionToDataRange(
      proxy, { blockSelector }, { info }, extend, force)
      .front();
  }
  static std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRange(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, std::vector<vtkPVArrayInformation*> infos,
    bool extend = false, bool force = true);


  static void SetColorArray(vtkSMProxy* proxy, int attributeType, std::string arrayName);
  static void SetBlockColorArray(
    vtkSMProxy* proxy, const std::string& blockSelector, int attributeType, std::string arrayName)
  {
    vtkSMColorMapEditorHelper::SetBlocksColorArray(
      proxy, { blockSelector }, attributeType, arrayName);
  }
  static void SetBlocksColorArray(vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors,
    int attributeType, std::string arrayName);
  static void RemoveBlockColorArray(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksColorArrays(proxy, { blockSelector });
  }
  static void RemoveBlocksColorArrays(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  static ColorArray GetColorArray(vtkSMProxy* proxy);
  static ColorArray GetBlockColorArray(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetBlocksColorArrays(proxy, { blockSelector }).front();
  }


  static void SetBlockLookupTable(
    vtkSMProxy* proxy, const std::string& blockSelector, vtkSMProxy* lutProxy)
  {
    vtkSMColorMapEditorHelper::SetBlocksLookupTable(proxy, { blockSelector }, lutProxy);
  }
  static void SetBlocksLookupTable(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, vtkSMProxy* lutProxy);
  static void RemoveBlockLookupTable(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    vtkSMColorMapEditorHelper::RemoveBlocksLookupTables(proxy, { blockSelector });
  }
  static void RemoveBlocksLookupTables(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);

  static bool SetScalarColoringInternal(
    vtkSMProxy* proxy, const char* arrayName, int attributeType, bool useComponent, int component);
  static std::vector<vtkTypeBool> SetBlocksScalarColoringInternal(vtkSMProxy* proxy,
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType,
    bool useComponent, int component);
  std::vector<vtkTypeBool> SetSelectedScalarColoringInternal(
    vtkSMProxy* proxy, const char* arrayName, int attributeType, bool useComponent, int component);


  static vtkSMProxy* GetLastLookupTable(vtkSMProxy* proxy);
  static void SetLastLookupTable(vtkSMProxy* proxy, vtkSMProxy* lutProxy);
  static vtkSMProxy* GetLastBlockLookupTable(vtkSMProxy* proxy, const std::string& blockSelector)
  {
    return vtkSMColorMapEditorHelper::GetLastBlocksLookupTables(proxy, { blockSelector }).front();
  }
  static std::vector<vtkSMProxy*> GetLastBlocksLookupTables(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors);
  static void SetLastBlockLookupTable(
    vtkSMProxy* proxy, const std::string& blockSelector, vtkSMProxy* lutProxy)
  {
    vtkSMColorMapEditorHelper::SetLastBlocksLookupTable(proxy, { blockSelector }, lutProxy);
  }
  static void SetLastBlocksLookupTable(
    vtkSMProxy* proxy, const std::vector<std::string>& blockSelectors, vtkSMProxy* lutProxy);

  friend class vtkSMPVRepresentationProxy;

private:
  vtkSMColorMapEditorHelper(const vtkSMColorMapEditorHelper&) = delete;
  void operator=(const vtkSMColorMapEditorHelper&) = delete;

  int SelectedPropertiesType = SelectedPropertiesTypes::Representation;
};

#endif