vtkSurfaceNetsAtlas.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 vtkSurfaceNetsAtlas_h
#define vtkSurfaceNetsAtlas_h

#include "vtkFiltersCoreModule.h" // for export macro
#include "vtkPartitionedDataSetCollectionAlgorithm.h"
#include "vtkSmartPointer.h"  // for vtkSmartPointer
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO

#include <atomic> // for std::atomic
#include <memory> // for std::unique_ptr
#include <string> // for std::string
#include <vector> // for std::vector

VTK_ABI_NAMESPACE_BEGIN

class vtkIdTypeArray;
class vtkPolyData;

class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO vtkSurfaceNetsAtlas
  : public vtkPartitionedDataSetCollectionAlgorithm
{
public:

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

  // ==========================================================================
  // Extraction mode
  // ==========================================================================

  enum ExtractionModes
  {
    EXTRACT_ALL = 0,
    EXTRACT_LABEL_SET = 1,
  };


  vtkSetClampMacro(ExtractionMode, int, EXTRACT_ALL, EXTRACT_LABEL_SET);
  vtkGetMacro(ExtractionMode, int);
  void SetExtractionModeToAll() { this->SetExtractionMode(EXTRACT_ALL); }
  void SetExtractionModeToLabelSet() { this->SetExtractionMode(EXTRACT_LABEL_SET); }

  // ==========================================================================
  // Output style
  // ==========================================================================

  enum OutputStyles
  {
    OUTPUT_STYLE_ALL = 0,
    OUTPUT_STYLE_BOUNDARY = 1
  };


  vtkSetClampMacro(OutputStyle, int, OUTPUT_STYLE_ALL, OUTPUT_STYLE_BOUNDARY);
  vtkGetMacro(OutputStyle, int);
  void SetOutputStyleToAll() { this->SetOutputStyle(OUTPUT_STYLE_ALL); }
  void SetOutputStyleToBoundary() { this->SetOutputStyle(OUTPUT_STYLE_BOUNDARY); }


  vtkSetMacro(BackgroundLabel, vtkIdType);
  vtkGetMacro(BackgroundLabel, vtkIdType);

  // ==========================================================================
  // Selected labels (used when ExtractionMode is EXTRACT_LABEL_SET)
  // ==========================================================================


  void AddSelectedLabel(vtkIdType label);
  void RemoveSelectedLabel(vtkIdType label);
  void ClearSelectedLabels();


  void SetNumberOfSelectedLabels(int n);
  int GetNumberOfSelectedLabels() const;


  void SetSelectedLabel(int i, vtkIdType label);
  vtkIdType GetSelectedLabel(int i) const;


  std::vector<vtkIdType> GetSelectedLabels() const;
  void SetSelectedLabels(const std::vector<vtkIdType>& labels);


  void GenerateSelectedLabels(int numLabels, vtkIdType rangeStart, vtkIdType rangeEnd);
  void GenerateSelectedLabels(int numLabels, vtkIdType range[2]);
  void GenerateSelectedLabels(vtkIdType rangeStart, vtkIdType rangeEnd);

  // ==========================================================================
  // Label names
  // ==========================================================================


  int GetNumberOfLabelNames() const;
  void SetLabelName(vtkIdType label, const std::string& name);
  std::string GetLabelName(vtkIdType label) const;
  void AddLabelName(vtkIdType label, const std::string& name);
  void RemoveLabelName(vtkIdType label);
  void ClearLabelNames();

  // ==========================================================================
  // Optional outputs
  // ==========================================================================


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


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


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

  // ==========================================================================
  // Atlas inspection (Phase 2: queries against the built atlas)
  //
  // These methods inspect the atlas built from the most recent Update().
  // They require the filter to have been executed at least once with a
  // valid input; otherwise they return zero / empty results (the
  // "invalid" sentinel for index-returning methods is -1).
  //
  // None of these methods trigger re-execution.
  // ==========================================================================

  // -- Label queries ---------------------------------------------------------

  int GetNumberOfLabels() const;


  bool HasLabel(vtkIdType label) const;
  bool HasLabel(const std::string& name) const;

  vtkIdType GetLabelForName(const std::string& name) const;


  int GetLIDForLabel(vtkIdType label) const;
  int GetLIDForLabel(const std::string& name) const;
  vtkIdType GetLabelForLID(int lid) const;

  // -- Adjacency queries -----------------------------------------------------


  bool AreAdjacent(vtkIdType label0, vtkIdType label1) const;
  bool AreAdjacent(const std::string& name0, const std::string& name1) const;


  std::vector<vtkIdType> GetAdjacentLabels(vtkIdType label) const;
  std::vector<vtkIdType> GetAdjacentLabels(const std::string& name) const;

  // -- Patch queries ---------------------------------------------------------

  vtkIdType GetNumberOfPatches() const;

  void GetPatchLabels(int patchID, vtkIdType labels[2]) const;


  int GetPatchID(vtkIdType label0, vtkIdType label1) const;
  int GetPatchID(const std::string& name0, const std::string& name1) const;

  vtkIdType GetPatchCellCount(int patchID) const;


  std::vector<int> GetPatchesForLabel(vtkIdType label) const;
  std::vector<int> GetPatchesForLabel(const std::string& name) const;

protected:
  vtkSurfaceNetsAtlas();
  ~vtkSurfaceNetsAtlas() override;

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

  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

private:
  vtkSurfaceNetsAtlas(const vtkSurfaceNetsAtlas&) = delete;
  void operator=(const vtkSurfaceNetsAtlas&) = delete;

  void BuildAtlas(vtkPolyData* input);

  template <bool IsPatch>
  vtkSmartPointer<vtkPolyData> ExtractLabel(vtkPolyData* source,
    const std::vector<const std::vector<vtkIdType>*>& groups, vtkIdType label,
    std::atomic<unsigned char>* ptUses, std::vector<vtkIdType>& pointMap) const;

  void BuildOutput(vtkPolyData* input, vtkPartitionedDataSetCollection* output) const;

  // -- Parameters ------------------------------------------------------------

  int ExtractionMode = EXTRACT_ALL;
  int OutputStyle = OUTPUT_STYLE_BOUNDARY;
  vtkIdType BackgroundLabel = 0;
  bool GenerateRegions = true;
  bool GeneratePatches = true;
  bool ResolveNonManifoldPoints = false;

  std::vector<vtkIdType> Labels;

  // The atlas information
  struct AtlasData;
  std::unique_ptr<AtlasData> Atlas;

  vtkTimeStamp AtlasBuildTime;
};

VTK_ABI_NAMESPACE_END
#endif