vtkSlicerSegmentationGeometryLogic.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.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through CANARIE and the Applied Cancer Research Unit program
  of Cancer Care Ontario with funds provided by the Ontario Ministry of Health and
  Long-Term Care
 
==============================================================================*/
 
// .NAME vtkSlicerSegmentationGeometryLogic
// .SECTION Description
// This class manages the logic associated with converting and handling
// segmentation node objects.
 
#ifndef __vtkSlicerSegmentationGeometryLogic_h
#define __vtkSlicerSegmentationGeometryLogic_h
 
// Slicer includes
#include "vtkSlicerSegmentationsModuleLogicExport.h"
 
// Segmentations includes
#include "vtkMRMLSegmentationNode.h"
 
// vtkSegmentationCore includes
#include "vtkOrientedImageData.h"
 
class VTK_SLICER_SEGMENTATIONS_LOGIC_EXPORT vtkSlicerSegmentationGeometryLogic : public vtkObject
{
public:
  static vtkSlicerSegmentationGeometryLogic* New();
  vtkTypeMacro(vtkSlicerSegmentationGeometryLogic, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  std::string CalculateOutputGeometry();
 
  bool IsSourceSegmentationWithBinaryLabelmapMaster();
 
  bool InputSegmentationCanBeResampled();
 
  void ComputeSourceAxisIndexForInputAxis();
 
  bool ResampleLabelmapsInSegmentationNode();
 
  vtkGetObjectMacro(OutputGeometryImageData, vtkOrientedImageData);
 
  void ResetGeometryImageData();
 
 
  vtkGetObjectMacro(InputSegmentationNode, vtkMRMLSegmentationNode);
  vtkSetObjectMacro(InputSegmentationNode, vtkMRMLSegmentationNode);
 
  vtkGetObjectMacro(SourceGeometryNode, vtkMRMLDisplayableNode);
  virtual void SetSourceGeometryNode(vtkMRMLDisplayableNode* node);
 
 
  vtkGetMacro(IsotropicSpacing, bool);
  vtkSetMacro(IsotropicSpacing, bool);
  vtkBooleanMacro(IsotropicSpacing, bool);
 
 
  vtkGetMacro(OversamplingFactor, double);
  vtkSetMacro(OversamplingFactor, double);
 
 
  vtkGetVectorMacro(UserSpacing, double, 3);
  vtkSetVectorMacro(UserSpacing, double, 3);
 
  vtkGetVectorMacro(InputAxisIndexForSourceAxis, int, 3);
 
  vtkGetVectorMacro(SourceAxisIndexForInputAxis, int, 3);
 
 
  vtkGetMacro(PadOutputGeometry, bool);
  vtkSetMacro(PadOutputGeometry, bool);
  vtkBooleanMacro(PadOutputGeometry, bool);
 
protected:
  vtkSlicerSegmentationGeometryLogic();
  ~vtkSlicerSegmentationGeometryLogic() override;
 
protected:
 
  std::string CalculateOutputGeometryFromImage();
 
  std::string CalculateOutputGeometryFromBounds(bool keepCurrentAxisDirections);
 
  void CalculatePaddedOutputGeometry();
 
  vtkMRMLSegmentationNode* InputSegmentationNode{ nullptr };
  vtkMRMLDisplayableNode* SourceGeometryNode{ nullptr };
  bool IsotropicSpacing{ false };
  double OversamplingFactor{ 1.0 };
  bool PadOutputGeometry{ true };
  double UserSpacing[3]{ 1.0, 1.0, 1.0 };
  vtkOrientedImageData* OutputGeometryImageData{ nullptr };
  int InputAxisIndexForSourceAxis[3]{ 0, 1, 2 };
  int SourceAxisIndexForInputAxis[3]{ 0, 1, 2 };
 
private:
  vtkSlicerSegmentationGeometryLogic(const vtkSlicerSegmentationGeometryLogic&) = delete;
  void operator=(const vtkSlicerSegmentationGeometryLogic&) = delete;
};
 
#endif