itkBinaryMask3DMeshSource.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  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 itkBinaryMask3DMeshSource_h
#define itkBinaryMask3DMeshSource_h
 
#include "vnl/vnl_matrix_fixed.h"
#include "itkMesh.h"
#include "itkImageToMeshFilter.h"
#include "itkTriangleCell.h"
#include "itkCovariantVector.h"
#include "itkDefaultStaticMeshTraits.h"
#include "itkImageRegionConstIterator.h"
 
namespace itk
{
template <typename TInputImage, typename TOutputMesh>
class ITK_TEMPLATE_EXPORT BinaryMask3DMeshSource : public ImageToMeshFilter<TInputImage, TOutputMesh>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(BinaryMask3DMeshSource);

  using Self = BinaryMask3DMeshSource;
  using Superclass = ImageToMeshFilter<TInputImage, TOutputMesh>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(BinaryMask3DMeshSource);

  using OutputMeshType = TOutputMesh;
  using OMeshTraits = typename OutputMeshType::MeshTraits;
  using OPointType = typename OutputMeshType::PointType;
  using OPixelType = typename OMeshTraits::PixelType;

  using OutputMeshPointer = typename OutputMeshType::Pointer;
  using CellTraits = typename OutputMeshType::CellTraits;
  using PointsContainerPointer = typename OutputMeshType::PointsContainerPointer;
  using PointsContainer = typename OutputMeshType::PointsContainer;
  using CellsContainerPointer = typename OutputMeshType::CellsContainerPointer;
  using CellsContainer = typename OutputMeshType::CellsContainer;
  using doubleVector = CovariantVector<double, 2>;
  using intVector = CovariantVector<int, 2>;

  using TCellInterface = CellInterface<OPixelType, CellTraits>;
  using TriCell = TriangleCell<TCellInterface>;
  using TriCellAutoPointer = typename TriCell::SelfAutoPointer;

  using InputImageType = TInputImage;
  using InputImagePointer = typename InputImageType::Pointer;
  using InputImageConstPointer = typename InputImageType::ConstPointer;
  using InputPixelType = typename InputImageType::PixelType;
  using SpacingType = typename InputImageType::SpacingType;
  using OriginType = typename InputImageType::PointType;
  using RegionType = typename InputImageType::RegionType;
  using SizeType = typename InputImageType::SizeType;

  using InputImageIndexType = typename InputImageType::IndexType;
 
  using InputImageIterator = ImageRegionConstIterator<InputImageType>;
 
  using IdentifierType = itk::IdentifierType;
  using SizeValueType = itk::SizeValueType;
 
  itkSetMacro(ObjectValue, InputPixelType);
 
  itkGetConstMacro(NumberOfNodes, SizeValueType);
  itkGetConstMacro(NumberOfCells, SizeValueType);

  using Superclass::SetInput;
  virtual void
  SetInput(const InputImageType * image);
 
  void
  SetRegionOfInterest(const RegionType & iRegion)
  {
    if (iRegion != m_RegionOfInterest)
    {
      this->m_RegionOfInterest = iRegion;
      this->m_RegionOfInterestProvidedByUser = true;
      this->Modified();
    }
  }
 
  itkGetConstReferenceMacro(RegionOfInterest, RegionType);
 
protected:
  BinaryMask3DMeshSource();
  ~BinaryMask3DMeshSource() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  GenerateData() override;
 
 
  bool       m_RegionOfInterestProvidedByUser{ false };
  RegionType m_RegionOfInterest{};
 
  void
  GenerateOutputInformation() override
  {} // do nothing override
 
private:
  using InputImageSizeType = typename InputImageType::SizeType;
 
  void
  CreateMesh();
 
  void
  XFlip(unsigned char * x); // 7 kinds of transformation
 
  void
  YFlip(unsigned char * x);
 
  void
  ZFlip(unsigned char * x);
 
  void
  XRotation(unsigned char * x);
 
  void
  YRotation(unsigned char * x);
 
  void
  ZRotation(unsigned char * x);
 
  void
  inverse(unsigned char * x);
 
  void
  InitializeLUT(); // initialize the look up table before the mesh
                   // construction
 
  void
  AddCells(unsigned char celltype, unsigned char celltran, int index);
 
  void
  AddNodes(int               index,
           unsigned char *   nodesid,
           IdentifierType *  globalnodesid,
           IdentifierType ** currentrowtmp,
           IdentifierType ** currentframetmp);
 
  void
  CellTransfer(unsigned char * nodesid, unsigned char celltran);
 
  IdentifierType
  SearchThroughLastRow(int index, int start, int end);
 
  IdentifierType
  SearchThroughLastFrame(int index, int start, int end);
 
  unsigned char m_LUT[256][2]{}; // the two lookup tables
 
  IdentifierType m_LastVoxel[14]{};
  IdentifierType m_CurrentVoxel[14]{};
 
  IdentifierType ** m_LastRow{ nullptr };
  IdentifierType ** m_LastFrame{ nullptr };
  IdentifierType ** m_CurrentRow{ nullptr };
  IdentifierType ** m_CurrentFrame{ nullptr };
 
  int           m_CurrentRowIndex{ 0 };
  int           m_CurrentFrameIndex{ 0 };
  int           m_LastRowNum{ 0 };
  int           m_LastFrameNum{ 0 };
  int           m_CurrentRowNum{ 200 };
  int           m_CurrentFrameNum{ 2000 };
  unsigned char m_AvailableNodes[14]{};
 
  double m_LocationOffset[14][3]{};
 
  SizeValueType m_NumberOfNodes{ 0 };
  SizeValueType m_NumberOfCells{ 0 };
 
  int m_NodeLimit{ 2000 };
  int m_CellLimit{ 4000 };
  int m_ImageWidth{ 0 };
  int m_ImageHeight{ 0 };
  int m_ImageDepth{ 0 };
  int m_ColFlag{ 0 };
  int m_RowFlag{ 0 };
  int m_FrameFlag{ 0 };
  int m_LastRowIndex{ 0 };
  int m_LastVoxelIndex{ 0 };
  int m_LastFrameIndex{ 0 };
 
  unsigned char  m_PointFound{ 0 };
  InputPixelType m_ObjectValue{};

  OutputMeshType *       m_OutputMesh{};
  const InputImageType * m_InputImage{};
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkBinaryMask3DMeshSource.hxx"
#endif
 
#endif