itkBinaryMask3DMeshSource.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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_ASSIGN(BinaryMask3DMeshSource);

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

  itkNewMacro(Self);

  itkTypeMacro(BinaryMask3DMeshSource, ImageToMeshFilter);

  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 *inputImage);

  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 *tp);     // 7 kinds of transformation

  void YFlip(unsigned char *tp);

  void ZFlip(unsigned char *tp);

  void XRotation(unsigned char *tp);

  void YRotation(unsigned char *tp);

  void ZRotation(unsigned char *tp);

  void inverse(unsigned char *tp);

  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};

  unsigned short m_CurrentRowIndex{0};
  unsigned short m_CurrentFrameIndex{0};
  unsigned short m_LastRowNum{0};
  unsigned short m_LastFrameNum{0};
  unsigned short m_CurrentRowNum{200};
  unsigned short 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