vtkLabeledImagePointSampler.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 vtkLabeledImagePointSampler_h
#define vtkLabeledImagePointSampler_h
 
#include "vtkContourValues.h"        // Manage countour values
#include "vtkFiltersMeshingModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkImageData;
 
class VTKFILTERSMESHING_EXPORT vtkLabeledImagePointSampler : public vtkPolyDataAlgorithm
{
public:

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


  vtkSetMacro(BackgroundPointMapping, int);
  vtkGetMacro(BackgroundPointMapping, int);
  vtkBooleanMacro(BackgroundPointMapping, int);
  vtkSetMacro(BackgroundPointLabel, int);
  vtkGetMacro(BackgroundPointLabel, int);


  enum DensityDistributionType
  {
    LINEAR = 0,
    EXPONENTIAL = 1
  };

  vtkSetClampMacro(DensityDistribution, int, LINEAR, EXPONENTIAL);
  vtkGetMacro(DensityDistribution, int);
  void SetDensityDistributionToLinear() { this->SetDensityDistribution(LINEAR); }
  void SetDensityDistributionToExponential() { this->SetDensityDistribution(EXPONENTIAL); }


  vtkSetClampMacro(N, unsigned int, 1, 100);
  vtkGetMacro(N, unsigned int);


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


  vtkSetVector2Macro(RandomProbabilityRange, double);
  vtkGetVectorMacro(RandomProbabilityRange, double, 2);


  enum OutputLabelsSelection
  {
    ALL_POINTS = 0,
    LABELED_POINTS = 1,
    BACKGROUND_POINTS = 2
  };

  vtkSetClampMacro(OutputType, int, ALL_POINTS, BACKGROUND_POINTS);
  vtkGetMacro(OutputType, int);
  void SetOutputTypeToAllPoints() { this->SetOutputType(ALL_POINTS); }
  void SetOutputTypeToLabeledPoints() { this->SetOutputType(LABELED_POINTS); }
  void SetOutputTypeToBackgroundPoints() { this->SetOutputType(BACKGROUND_POINTS); }


  vtkSetMacro(Joggle, vtkTypeBool);
  vtkGetMacro(Joggle, vtkTypeBool);
  vtkBooleanMacro(Joggle, vtkTypeBool);
  vtkSetClampMacro(JoggleRadius, double, 0, 0.5);
  vtkGetMacro(JoggleRadius, double);
  vtkSetMacro(JoggleRadiusIsAbsolute, vtkTypeBool);
  vtkBooleanMacro(JoggleRadiusIsAbsolute, vtkTypeBool);
  vtkGetMacro(JoggleRadiusIsAbsolute, vtkTypeBool);
  vtkSetMacro(ConstrainJoggle, vtkTypeBool);
  vtkBooleanMacro(ConstrainJoggle, vtkTypeBool);
  vtkGetMacro(ConstrainJoggle, vtkTypeBool);
  vtkSetClampMacro(JoggleConstraint, double, 0, 1);
  vtkGetMacro(JoggleConstraint, double);
 
  //---------------The following are methods used to set/get and generate
  //---------------label values.

  void SetValue(int i, double value) { this->Labels->SetValue(i, value); }
  void SetLabel(int i, double value) { this->Labels->SetValue(i, value); }


  double GetValue(int i) { return this->Labels->GetValue(i); }
  double GetLabel(int i) { return this->Labels->GetValue(i); }


  double* GetValues() { return this->Labels->GetValues(); }
  double* GetLabels() { return this->Labels->GetValues(); }


  void GetValues(double* contourValues) { this->Labels->GetValues(contourValues); }
  void GetLabels(double* contourValues) { this->Labels->GetValues(contourValues); }


  void SetNumberOfLabels(int number) { this->Labels->SetNumberOfContours(number); }
  void SetNumberOfContours(int number) { this->Labels->SetNumberOfContours(number); }


  vtkIdType GetNumberOfLabels() { return this->Labels->GetNumberOfContours(); }
  vtkIdType GetNumberOfContours() { return this->Labels->GetNumberOfContours(); }


  void GenerateLabels(int numLabels, double range[2])
  {
    this->Labels->GenerateValues(numLabels, range);
  }
  void GenerateValues(int numContours, double range[2])
  {
    this->Labels->GenerateValues(numContours, range);
  }
  void GenerateLabels(int numLabels, double rangeStart, double rangeEnd)
  {
    this->Labels->GenerateValues(numLabels, rangeStart, rangeEnd);
  }
  void GenerateValues(int numContours, double rangeStart, double rangeEnd)
  {
    this->Labels->GenerateValues(numContours, rangeStart, rangeEnd);
  }

  //---------------Done defining label-related methods.


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

  vtkMTimeType GetMTime() override;
 
protected:
  vtkLabeledImagePointSampler();
  ~vtkLabeledImagePointSampler() override = default;
 
  vtkTypeBool BackgroundPointMapping;
  int BackgroundPointLabel;
  int DensityDistribution;
  unsigned int N;
  int OutputType;
 
  vtkTypeBool Randomize;
  double RandomProbabilityRange[2];
 
  vtkTypeBool Joggle;
  double JoggleRadius;
  vtkTypeBool JoggleRadiusIsAbsolute;
  vtkTypeBool ConstrainJoggle;
  double JoggleConstraint;
 
  vtkSmartPointer<vtkContourValues> Labels;
 
  vtkTypeBool GenerateVerts;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
private:
  vtkLabeledImagePointSampler(const vtkLabeledImagePointSampler&) = delete;
  void operator=(const vtkLabeledImagePointSampler&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif