vtkAMRStreamingVolumeRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkAMRStreamingVolumeRepresentation_h
#define vtkAMRStreamingVolumeRepresentation_h
 
#include "vtkBoundingBox.h" // needed for vtkBoundingBox.
#include "vtkPVDataRepresentation.h"
#include "vtkRemotingViewsModule.h" // for export macros
#include "vtkSmartPointer.h"        // needed for vtkSmartPointer.
 
class vtkAMRStreamingPriorityQueue;
class vtkColorTransferFunction;
class vtkImageData;
class vtkOverlappingAMR;
class vtkPiecewiseFunction;
class vtkPVLODVolume;
class vtkPVRenderView;
class vtkResampledAMRImageSource;
class vtkSmartVolumeMapper;
class vtkVolumeProperty;
class vtkAMRVolumeMapper;
 
class VTKREMOTINGVIEWS_EXPORT vtkAMRStreamingVolumeRepresentation : public vtkPVDataRepresentation
{
public:
  static vtkAMRStreamingVolumeRepresentation* New();
  vtkTypeMacro(vtkAMRStreamingVolumeRepresentation, vtkPVDataRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum ResamplingModes
  {
    RESAMPLE_OVER_DATA_BOUNDS = 0,
    RESAMPLE_USING_VIEW_FRUSTUM = 1
  };
 
 
  void SetResamplingMode(int val);
  vtkGetMacro(ResamplingMode, int);
 
  int ProcessViewRequest(vtkInformationRequestKey* request_type, vtkInformation* inInfo,
    vtkInformation* outInfo) override;
 
  void SetVisibility(bool val) override;
 
  void SetNumberOfSamples(int x, int y, int z);
 
 
  vtkSetClampMacro(StreamingRequestSize, int, 1, 10000);
  vtkGetMacro(StreamingRequestSize, int);
 
 
  void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, const char* name) override;
  void SetInputArrayToProcess(
    int idx, int port, int connection, int fieldAssociation, int fieldAttributeType) override
  {
    this->Superclass::SetInputArrayToProcess(
      idx, port, connection, fieldAssociation, fieldAttributeType);
  }
  void SetInputArrayToProcess(int idx, vtkInformation* info) override
  {
    this->Superclass::SetInputArrayToProcess(idx, info);
  }
  void SetInputArrayToProcess(int idx, int port, int connection, const char* fieldAssociation,
    const char* attributeTypeorName) override
  {
    this->Superclass::SetInputArrayToProcess(
      idx, port, connection, fieldAssociation, attributeTypeorName);
  }
 
  //***************************************************************************
  // Scalar coloring API (forwarded for vtkSmartVolumeMapper.
 
  //***************************************************************************
  // Forwarded to Actor.
  void SetOrientation(double, double, double);
  void SetOrigin(double, double, double);
  void SetPickable(int val);
  void SetPosition(double, double, double);
  void SetScale(double, double, double);
 
  //***************************************************************************
  // Forwarded to vtkVolumeProperty.
  void SetInterpolationType(int val);
  void SetColor(vtkColorTransferFunction* lut);
  void SetScalarOpacity(vtkPiecewiseFunction* pwf);
  void SetScalarOpacityUnitDistance(double val);
  void SetAmbient(double);
  void SetDiffuse(double);
  void SetSpecular(double);
  void SetSpecularPower(double);
  void SetShade(bool);
  void SetIndependantComponents(bool);
 
  //***************************************************************************
  // Forwarded to vtkSmartVolumeMapper.
  void SetRequestedRenderMode(int);
 
protected:
  vtkAMRStreamingVolumeRepresentation();
  ~vtkAMRStreamingVolumeRepresentation() override;
 
  bool AddToView(vtkView* view) override;
 
  bool RemoveFromView(vtkView* view) override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
 
  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
 
  vtkGetMacro(StreamingCapablePipeline, bool);
 
 
  vtkGetMacro(InStreamingUpdate, bool);
 
  bool StreamingUpdate(vtkPVRenderView* view, const double view_planes[24]);
 
  vtkSmartPointer<vtkDataObject> ProcessedData;
 
  vtkSmartPointer<vtkDataObject> ProcessedPiece;
 
  vtkSmartPointer<vtkAMRStreamingPriorityQueue> PriorityQueue;
 
  vtkSmartPointer<vtkResampledAMRImageSource> Resampler;
 
 
  vtkSmartPointer<vtkSmartVolumeMapper> VolumeMapper;
  vtkSmartPointer<vtkAMRVolumeMapper> AMRVolumeMapper;
  vtkSmartPointer<vtkVolumeProperty> Property;
  vtkSmartPointer<vtkPVLODVolume> Actor;
 
  vtkBoundingBox DataBounds;
 
  int ResamplingMode;
  int StreamingRequestSize;
 
private:
  vtkAMRStreamingVolumeRepresentation(const vtkAMRStreamingVolumeRepresentation&) = delete;
  void operator=(const vtkAMRStreamingVolumeRepresentation&) = delete;
 
  bool StreamingCapablePipeline;
 
  bool InStreamingUpdate;
};
 
#endif