vtkSegmentationConversionPath.h

Go to the documentation of this file.

/*==============================================================================
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
==============================================================================*/
 
#ifndef __vtkSegmentationConversionPath_h
#define __vtkSegmentationConversionPath_h
 
// VTK includes
#include <vtkCollection.h>
#include <vtkObject.h>
 
// STD includes
#include <vector>
 
// Segmentation includes
#include "vtkSegmentationCoreConfigure.h"
 
class vtkSegmentationConverterRule;

class vtkSegmentationCore_EXPORT vtkSegmentationConversionPath : public vtkObject
{
public:
  static vtkSegmentationConversionPath* New();
  vtkTypeMacro(vtkSegmentationConversionPath, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  unsigned int GetCost();

  int AddRule(vtkSegmentationConverterRule* rule);

  void AddRules(vtkSegmentationConversionPath* path);

  int GetNumberOfRules();

  vtkSegmentationConverterRule* GetRule(int index) VTK_EXPECTS(0 <= index && index < GetNumberOfRules());

  void RemoveRule(int index) VTK_EXPECTS(0 <= index && index < GetNumberOfRules());

  void RemoveAllRules();

  void Copy(vtkSegmentationConversionPath* source);
 
protected:
  std::vector<vtkSmartPointer<vtkSegmentationConverterRule>> Rules;
 
protected:
  vtkSegmentationConversionPath();
  ~vtkSegmentationConversionPath() override;
 
private:
  vtkSegmentationConversionPath(const vtkSegmentationConversionPath&) = delete;
  void operator=(const vtkSegmentationConversionPath&) = delete;
};

class vtkSegmentationCore_EXPORT vtkSegmentationConversionPaths : public vtkCollection
{
public:
  vtkTypeMacro(vtkSegmentationConversionPaths, vtkCollection);
  static vtkSegmentationConversionPaths* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void AddPath(vtkSegmentationConversionPath*);

  void AddPaths(vtkSegmentationConversionPaths*);

  vtkSegmentationConversionPath* GetNextPath();

  vtkSegmentationConversionPath* GetPath(int index) { return vtkSegmentationConversionPath::SafeDownCast(this->GetItemAsObject(index)); }

  vtkSegmentationConversionPath* GetNextPath(vtkCollectionSimpleIterator& cookie);

  int GetNumberOfPaths() { return this->GetNumberOfItems(); };
 
protected:
  vtkSegmentationConversionPaths() = default;
  ~vtkSegmentationConversionPaths() override = default;
 
private:
  // hide the standard AddItem from the user and the compiler.
  void AddItem(vtkObject* o) { this->vtkCollection::AddItem(o); }
 
private:
  vtkSegmentationConversionPaths(const vtkSegmentationConversionPaths&) = delete;
  void operator=(const vtkSegmentationConversionPaths&) = delete;
};
 
//----------------------------------------------------------------------------
inline void vtkSegmentationConversionPaths::AddPath(vtkSegmentationConversionPath* f)
{
  this->vtkCollection::AddItem(f);
}
 
//----------------------------------------------------------------------------
inline void vtkSegmentationConversionPaths::AddPaths(vtkSegmentationConversionPaths* paths)
{
  vtkSegmentationConversionPath* path = nullptr;
  vtkCollectionSimpleIterator it;
  for (paths->InitTraversal(it); (path = paths->GetNextPath(it));)
  {
    this->AddItem(path);
  }
}
 
//----------------------------------------------------------------------------
inline vtkSegmentationConversionPath* vtkSegmentationConversionPaths::GetNextPath()
{
  return static_cast<vtkSegmentationConversionPath*>(this->GetNextItemAsObject());
}
 
#endif