vtkSMPVRepresentationProxy.h

Go to the documentation of this file.

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

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

#include <set>           // needed for std::set
#include <unordered_map> // needed for std::unordered_map

class vtkPVArrayInformation;

class VTKREMOTINGVIEWS_EXPORT vtkSMPVRepresentationProxy : public vtkSMRepresentationProxy
{
public:
  static vtkSMPVRepresentationProxy* New();
  vtkTypeMacro(vtkSMPVRepresentationProxy, vtkSMRepresentationProxy);
  void PrintSelf(ostream& os, vtkIndent indent) override;


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


  virtual bool GetUsingScalarColoring();
  virtual bool GetBlockUsingScalarColoring(const std::string& blockSelector)
  {
    return this->GetBlocksUsingScalarColoring({ blockSelector }).front();
  }
  virtual std::vector<vtkTypeBool> GetBlocksUsingScalarColoring(
    const std::vector<std::string>& blockSelectors);
  virtual bool GetAnyBlockUsingScalarColoring();


  vtkSMProxy* GetLookupTable(vtkSMProxy* view);
  vtkSMProxy* GetBlockLookupTable(vtkSMProxy* view, const std::string& blockSelector)
  {
    return this->GetBlocksLookupTables(view, { blockSelector }).front();
  }
  std::vector<vtkSMProxy*> GetBlocksLookupTables(
    vtkSMProxy* view, const std::vector<std::string>& blockSelectors);


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


  virtual bool SetScalarColoring(const char* arrayName, int attributeType);
  virtual bool SetBlockScalarColoring(
    const std::string& blockSelector, const char* arrayName, int attributeType)
  {
    return this->SetBlocksScalarColoring({ blockSelector }, arrayName, attributeType).front();
  }
  virtual std::vector<vtkTypeBool> SetBlocksScalarColoring(
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType);


  virtual bool SetScalarColoring(const char* arrayName, int attributeType, int component);
  virtual bool SetBlockScalarColoring(
    const std::string& blockSelector, const char* arrayName, int attributeType, int component)
  {
    return this->SetBlocksScalarColoring({ blockSelector }, arrayName, attributeType, component)
      .front();
  }
  virtual std::vector<vtkTypeBool> SetBlocksScalarColoring(
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType,
    int component);


  virtual bool RescaleTransferFunctionToDataRange(bool extend = false, bool force = true);
  virtual bool RescaleBlockTransferFunctionToDataRange(
    const std::string& blockSelector, bool extend = false, bool force = true)
  {
    return this->RescaleBlocksTransferFunctionToDataRange({ blockSelector }, extend, force).front();
  }
  virtual std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRange(
    const std::vector<std::string>& blockSelectors, bool extend = false, bool force = true);


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


  virtual bool RescaleTransferFunctionToDataRangeOverTime();
  virtual bool RescaleBlockTransferFunctionToDataRangeOverTime(const std::string& blockSelector)
  {
    return this->RescaleBlocksTransferFunctionToDataRangeOverTime({ blockSelector }).front();
  }
  virtual std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRangeOverTime(
    const std::vector<std::string>& blockSelectors);


  virtual bool RescaleTransferFunctionToDataRangeOverTime(const char* arrayName, int attributeType);
  virtual bool RescaleBlockTransferFunctionToDataRangeOverTime(
    const std::string& blockSelector, const char* arrayName, int attributeType)
  {
    return this
      ->RescaleBlocksTransferFunctionToDataRangeOverTime(
        { blockSelector }, arrayName, attributeType)
      .front();
  }
  virtual std::vector<vtkTypeBool> RescaleBlocksTransferFunctionToDataRangeOverTime(
    const std::vector<std::string>& blockSelectors, const char* arrayName, int attributeType);


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


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


  virtual bool HideScalarBarIfNotNeeded(vtkSMProxy* view);
  virtual bool HideBlocksScalarBarIfNotNeeded(vtkSMProxy* view);


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


  virtual vtkPVArrayInformation* GetArrayInformationForColorArray(bool checkRepresentedData = true);
  virtual vtkPVArrayInformation* GetBlockArrayInformationForColorArray(
    const std::string& blockSelector)
  {
    return this->GetBlocksArrayInformationForColorArray({ blockSelector }).front();
  }
  virtual std::vector<vtkPVArrayInformation*> GetBlocksArrayInformationForColorArray(
    const std::vector<std::string>& blockSelectors);


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


  int GetEstimatedNumberOfAnnotationsOnScalarBar(vtkSMProxy* view);
  int GetBlockEstimatedNumberOfAnnotationsOnScalarBar(
    vtkSMProxy* view, const std::string& blockSelector)
  {
    return this->GetBlocksEstimatedNumberOfAnnotationsOnScalarBars(view, { blockSelector }).front();
  }
  std::vector<int> GetBlocksEstimatedNumberOfAnnotationsOnScalarBars(
    vtkSMProxy* view, const std::vector<std::string>& blockSelectors);

  bool SetRepresentationType(const char* type) override;

  bool GetVolumeIndependentRanges();


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

  void ViewUpdated(vtkSMProxy* view) override;


  std::pair<int, std::string> GetBlockColorArray(const std::string& blockSelector)
  {
    return this->GetBlocksColorArrays({ blockSelector }).front();
  }
  std::vector<std::pair<int, std::string>> GetBlocksColorArrays(
    const std::vector<std::string>& blockSelectors);
  int GetBlockColorArrayAssociation(const std::string& blockSelector)
  {
    return this->GetBlockColorArray(blockSelector).first;
  }
  std::string GetBlockColorArrayName(const std::string& blockSelector)
  {
    return this->GetBlockColorArray(blockSelector).second;
  }


  void SetBlockUseSeparateColorMap(const std::string& blockSelector, bool use)
  {
    this->SetBlocksUseSeparateColorMap({ blockSelector }, use);
  }
  void SetBlocksUseSeparateColorMap(const std::vector<std::string>& blockSelectors, bool use);
  bool GetBlockUseSeparateColorMap(const std::string& blockSelector)
  {
    return this->GetBlocksUseSeparateColorMaps({ blockSelector }).front();
  }
  std::vector<vtkTypeBool> GetBlocksUseSeparateColorMaps(
    const std::vector<std::string>& blockSelectors);

protected:
  vtkSMPVRepresentationProxy();
  ~vtkSMPVRepresentationProxy() override;

  void CreateVTKObjects() override;

  // Whenever the "Representation" property is modified, we ensure that the
  // this->InvalidateDataInformation() is called.
  void OnPropertyUpdated(vtkObject*, unsigned long, void* calldata);

  void SetPropertyModifiedFlag(const char* name, int flag) override;

  int ReadXMLAttributes(vtkSMSessionProxyManager* pm, vtkPVXMLElement* element) override;

  vtkSmartPointer<vtkSMProxy> LastLookupTable;
  std::unordered_map<std::string, vtkSmartPointer<vtkSMProxy>> LastBlocksLookupTables;

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

  bool InReadXMLAttributes;
  std::set<std::string> RepresentationSubProxies;
};

#endif