vtkRandomAttributeGenerator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkRandomAttributeGenerator_h
#define vtkRandomAttributeGenerator_h
 
#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkPassInputTypeAlgorithm.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellData;
class vtkCompositeDataSet;
class vtkDataSet;
class vtkFieldData;
class vtkHyperTreeGrid;
class vtkPointData;
 
class VTKFILTERSGENERAL_EXPORT vtkRandomAttributeGenerator : public vtkPassInputTypeAlgorithm
{
public:

  static vtkRandomAttributeGenerator* New();
  vtkTypeMacro(vtkRandomAttributeGenerator, vtkPassInputTypeAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetMacro(DataType, int);
  void SetDataTypeToBit() { this->SetDataType(VTK_BIT); }
  void SetDataTypeToChar() { this->SetDataType(VTK_CHAR); }
  void SetDataTypeToUnsignedChar() { this->SetDataType(VTK_UNSIGNED_CHAR); }
  void SetDataTypeToShort() { this->SetDataType(VTK_SHORT); }
  void SetDataTypeToUnsignedShort() { this->SetDataType(VTK_UNSIGNED_SHORT); }
  void SetDataTypeToInt() { this->SetDataType(VTK_INT); }
  void SetDataTypeToUnsignedInt() { this->SetDataType(VTK_UNSIGNED_INT); }
  void SetDataTypeToLong() { this->SetDataType(VTK_LONG); }
  void SetDataTypeToLongLong() { this->SetDataType(VTK_LONG_LONG); }
  void SetDataTypeToUnsignedLong() { this->SetDataType(VTK_UNSIGNED_LONG); }
  void SetDataTypeToUnsignedLongLong() { this->SetDataType(VTK_UNSIGNED_LONG_LONG); }
  void SetDataTypeToIdType() { this->SetDataType(VTK_ID_TYPE); }
  void SetDataTypeToFloat() { this->SetDataType(VTK_FLOAT); }
  void SetDataTypeToDouble() { this->SetDataType(VTK_DOUBLE); }
  vtkGetMacro(DataType, int);


  vtkSetClampMacro(NumberOfComponents, int, 1, VTK_INT_MAX);
  vtkGetMacro(NumberOfComponents, int);


  vtkSetMacro(MinimumComponentValue, double);
  vtkGetMacro(MinimumComponentValue, double);
  void SetComponentRange(double minimumValue, double maximumValue)
  {
    this->SetMinimumComponentValue(minimumValue);
    this->SetMaximumComponentValue(maximumValue);
  }



  vtkSetMacro(MaximumComponentValue, double);
  vtkGetMacro(MaximumComponentValue, double);


  vtkSetClampMacro(NumberOfTuples, vtkIdType, 0, VTK_INT_MAX);
  vtkGetMacro(NumberOfTuples, vtkIdType);


  vtkSetMacro(GeneratePointScalars, vtkTypeBool);
  vtkGetMacro(GeneratePointScalars, vtkTypeBool);
  vtkBooleanMacro(GeneratePointScalars, vtkTypeBool);


  vtkSetMacro(GeneratePointVectors, vtkTypeBool);
  vtkGetMacro(GeneratePointVectors, vtkTypeBool);
  vtkBooleanMacro(GeneratePointVectors, vtkTypeBool);


  vtkSetMacro(GeneratePointNormals, vtkTypeBool);
  vtkGetMacro(GeneratePointNormals, vtkTypeBool);
  vtkBooleanMacro(GeneratePointNormals, vtkTypeBool);


  vtkSetMacro(GeneratePointTensors, vtkTypeBool);
  vtkGetMacro(GeneratePointTensors, vtkTypeBool);
  vtkBooleanMacro(GeneratePointTensors, vtkTypeBool);


  vtkSetMacro(GeneratePointTCoords, vtkTypeBool);
  vtkGetMacro(GeneratePointTCoords, vtkTypeBool);
  vtkBooleanMacro(GeneratePointTCoords, vtkTypeBool);


  vtkSetMacro(GeneratePointArray, vtkTypeBool);
  vtkGetMacro(GeneratePointArray, vtkTypeBool);
  vtkBooleanMacro(GeneratePointArray, vtkTypeBool);


  vtkSetMacro(GenerateCellScalars, vtkTypeBool);
  vtkGetMacro(GenerateCellScalars, vtkTypeBool);
  vtkBooleanMacro(GenerateCellScalars, vtkTypeBool);


  vtkSetMacro(GenerateCellVectors, vtkTypeBool);
  vtkGetMacro(GenerateCellVectors, vtkTypeBool);
  vtkBooleanMacro(GenerateCellVectors, vtkTypeBool);


  vtkSetMacro(GenerateCellNormals, vtkTypeBool);
  vtkGetMacro(GenerateCellNormals, vtkTypeBool);
  vtkBooleanMacro(GenerateCellNormals, vtkTypeBool);


  vtkSetMacro(GenerateCellTensors, vtkTypeBool);
  vtkGetMacro(GenerateCellTensors, vtkTypeBool);
  vtkBooleanMacro(GenerateCellTensors, vtkTypeBool);


  vtkSetMacro(GenerateCellTCoords, vtkTypeBool);
  vtkGetMacro(GenerateCellTCoords, vtkTypeBool);
  vtkBooleanMacro(GenerateCellTCoords, vtkTypeBool);


  vtkSetMacro(GenerateCellArray, vtkTypeBool);
  vtkGetMacro(GenerateCellArray, vtkTypeBool);
  vtkBooleanMacro(GenerateCellArray, vtkTypeBool);


  vtkSetMacro(GenerateFieldArray, vtkTypeBool);
  vtkGetMacro(GenerateFieldArray, vtkTypeBool);
  vtkBooleanMacro(GenerateFieldArray, vtkTypeBool);


  vtkSetMacro(AttributesConstantPerBlock, bool);
  vtkGetMacro(AttributesConstantPerBlock, bool);
  vtkBooleanMacro(AttributesConstantPerBlock, bool);


  void GenerateAllPointDataOn()
  {
    this->GeneratePointScalarsOn();
    this->GeneratePointVectorsOn();
    this->GeneratePointNormalsOn();
    this->GeneratePointTCoordsOn();
    this->GeneratePointTensorsOn();
    this->GeneratePointArrayOn();
  }
  void GenerateAllPointDataOff()
  {
    this->GeneratePointScalarsOff();
    this->GeneratePointVectorsOff();
    this->GeneratePointNormalsOff();
    this->GeneratePointTCoordsOff();
    this->GeneratePointTensorsOff();
    this->GeneratePointArrayOff();
  }
  void GenerateAllCellDataOn()
  {
    this->GenerateCellScalarsOn();
    this->GenerateCellVectorsOn();
    this->GenerateCellNormalsOn();
    this->GenerateCellTCoordsOn();
    this->GenerateCellTensorsOn();
    this->GenerateCellArrayOn();
  }
  void GenerateAllCellDataOff()
  {
    this->GenerateCellScalarsOff();
    this->GenerateCellVectorsOff();
    this->GenerateCellNormalsOff();
    this->GenerateCellTCoordsOff();
    this->GenerateCellTensorsOff();
    this->GenerateCellArrayOff();
  }
  void GenerateAllDataOn()
  {
    this->GenerateAllPointDataOn();
    this->GenerateAllCellDataOn();
    this->GenerateFieldArrayOn();
  }
  void GenerateAllDataOff()
  {
    this->GenerateAllPointDataOff();
    this->GenerateAllCellDataOff();
    this->GenerateFieldArrayOff();
  }

 
protected:
  vtkRandomAttributeGenerator() = default;
  ~vtkRandomAttributeGenerator() override = default;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  int DataType = VTK_FLOAT;
  int NumberOfComponents = 1;
  vtkIdType NumberOfTuples = 0;
  double MinimumComponentValue = 0.0;
  double MaximumComponentValue = 1.0;
 
  vtkTypeBool GeneratePointScalars = 0;
  vtkTypeBool GeneratePointVectors = 0;
  vtkTypeBool GeneratePointNormals = 0;
  vtkTypeBool GeneratePointTCoords = 0;
  vtkTypeBool GeneratePointTensors = 0;
  vtkTypeBool GeneratePointArray = 0;
 
  vtkTypeBool GenerateCellScalars = 0;
  vtkTypeBool GenerateCellVectors = 0;
  vtkTypeBool GenerateCellNormals = 0;
  vtkTypeBool GenerateCellTCoords = 0;
  vtkTypeBool GenerateCellTensors = 0;
  vtkTypeBool GenerateCellArray = 0;
 
  vtkTypeBool GenerateFieldArray = 0;
  bool AttributesConstantPerBlock = false;

  vtkDataArray* GenerateData(int dataType, vtkIdType numTuples, int numComp, int minComp,
    int maxComp, double min, double max);

  template <class T>
  void GenerateRandomTuples(
    T* data, vtkIdType numTuples, int numComp, int minComp, int maxComp, double min, double max);
 
private:
  vtkRandomAttributeGenerator(const vtkRandomAttributeGenerator&) = delete;
  void operator=(const vtkRandomAttributeGenerator&) = delete;

  int ProcessDataSet(vtkDataSet* input, vtkDataSet* output);
  int ProcessComposite(vtkCompositeDataSet* input, vtkCompositeDataSet* output);
  int ProcessHTG(vtkHyperTreeGrid* input, vtkHyperTreeGrid* output);

  void GeneratePointData(vtkPointData* outputPD, vtkIdType numPts);
  void GenerateCellData(vtkCellData* outputCD, vtkIdType numCells);
  void GenerateFieldData(vtkFieldData* outputFD);
};
 
VTK_ABI_NAMESPACE_END
#endif