vtkSMTransferFunction2DProxy.h

Go to the documentation of this file.

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

// ParaView includes
#include "vtkRemotingViewsModule.h" // needed for export macro
#include "vtkSMProxy.h"

// VTK includes
#include <vtkImageData.h>    // needed for vtkImageData
#include <vtkSmartPointer.h> // for ivars

// Forward declarations

class VTKREMOTINGVIEWS_EXPORT vtkSMTransferFunction2DProxy : public vtkSMProxy
{
public:
  static vtkSMTransferFunction2DProxy* New();


  vtkTypeMacro(vtkSMTransferFunction2DProxy, vtkSMProxy);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual bool RescaleTransferFunction(const double range[4], bool extend = false)
  {
    return this->RescaleTransferFunction(range[0], range[1], range[2], range[3], extend);
  }
  virtual bool RescaleTransferFunction(
    double rangeXMin, double rangeXMax, double rangeYMin, double rangeYMax, bool extend = false);


  static bool RescaleTransferFunction(vtkSMProxy* proxy, double rangeXMin, double rangeXMax,
    double rangeYMin, double rangeYMax, bool extend = false);
  static bool RescaleTransferFunction(vtkSMProxy* proxy, const double range[4], bool extend = false)
  {
    return vtkSMTransferFunction2DProxy::RescaleTransferFunction(
      proxy, range[0], range[1], range[2], range[3], extend);
  }


  virtual bool RescaleTransferFunctionToDataRange(bool extend = false);
  static bool RescaleTransferFunctionToDataRange(vtkSMProxy* proxy, bool extend = false)
  {
    vtkSMTransferFunction2DProxy* self = vtkSMTransferFunction2DProxy::SafeDownCast(proxy);
    return self ? self->RescaleTransferFunctionToDataRange(extend) : false;
  }


  virtual bool ComputeDataRange(double range[4]);
  static bool ComputeDataRange(vtkSMProxy* proxy, double range[4])
  {
    vtkSMTransferFunction2DProxy* self = vtkSMTransferFunction2DProxy::SafeDownCast(proxy);
    return self ? self->ComputeDataRange(range) : false;
  }


  virtual vtkSmartPointer<vtkImageData> ComputeDataHistogram2D(int numberOfBins);
  static vtkSmartPointer<vtkImageData> ComputeDataHistogram2D(vtkSMProxy* proxy, int numberOfBins)
  {
    vtkSMTransferFunction2DProxy* self = vtkSMTransferFunction2DProxy::SafeDownCast(proxy);
    return self ? self->ComputeDataHistogram2D(numberOfBins) : nullptr;
  }


  virtual vtkImageData* GetHistogram2DCache() { return this->Histogram2DCache; }
  static vtkImageData* GetHistogram2DCache(vtkSMProxy* proxy)
  {
    vtkSMTransferFunction2DProxy* self = vtkSMTransferFunction2DProxy::SafeDownCast(proxy);
    return self ? self->GetHistogram2DCache() : nullptr;
  }


  virtual bool GetRange(double range[4]);
  static bool GetRange(vtkSMProxy* proxy, double range[4])
  {
    vtkSMTransferFunction2DProxy* self = vtkSMTransferFunction2DProxy::SafeDownCast(proxy);
    return self ? self->GetRange(range) : false;
  }

  static const int BOX_PROPERTY_SIZE = 8;

protected:
  vtkSMTransferFunction2DProxy() = default;
  ~vtkSMTransferFunction2DProxy() override = default;

  // Helper members
  vtkSmartPointer<vtkImageData> Histogram2DCache;

private:
  vtkSMTransferFunction2DProxy(const vtkSMTransferFunction2DProxy&) = delete;
  void operator=(const vtkSMTransferFunction2DProxy) = delete;
};

#endif // vtkSMTransferFunction2DProxy_h