vtkRandomAttributeGenerator.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkRandomAttributeGenerator.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkRandomAttributeGenerator_h
#define vtkRandomAttributeGenerator_h

#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkPassInputTypeAlgorithm.h"

class vtkDataSet;
class vtkCompositeDataSet;

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();
  ~vtkRandomAttributeGenerator() override {}

  int RequestData(vtkInformation *, vtkInformationVector **,
                  vtkInformationVector *) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;

  int       DataType;
  int       NumberOfComponents;
  vtkIdType NumberOfTuples;
  double    MinimumComponentValue;
  double    MaximumComponentValue;

  vtkTypeBool GeneratePointScalars;
  vtkTypeBool GeneratePointVectors;
  vtkTypeBool GeneratePointNormals;
  vtkTypeBool GeneratePointTCoords;
  vtkTypeBool GeneratePointTensors;
  vtkTypeBool GeneratePointArray;

  vtkTypeBool GenerateCellScalars;
  vtkTypeBool GenerateCellVectors;
  vtkTypeBool GenerateCellNormals;
  vtkTypeBool GenerateCellTCoords;
  vtkTypeBool GenerateCellTensors;
  vtkTypeBool GenerateCellArray;

  vtkTypeBool GenerateFieldArray;
  bool AttributesConstantPerBlock;

  // Helper functions
  vtkDataArray *GenerateData(int dataType, vtkIdType numTuples, int numComp,
                             int minComp, int maxComp, double min, double max);
  int RequestData(vtkDataSet *input, vtkDataSet *output);
  int RequestData(vtkCompositeDataSet *input, vtkCompositeDataSet *output);
  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;
};

#endif