itkSimplexMeshAdaptTopologyFilter.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 itkSimplexMeshAdaptTopologyFilter_h
#define itkSimplexMeshAdaptTopologyFilter_h

#include "itkPolygonCell.h"
#include "itkCellInterfaceVisitor.h"

#include "itkSimplexMesh.h"
#include "itkMeshToMeshFilter.h"
#include "itkVectorContainer.h"

#include "vxl_version.h"
#include "vnl/vnl_cross.h"

namespace itk
{
template< typename TInputMesh, typename TOutputMesh >
class ITK_TEMPLATE_EXPORT SimplexMeshAdaptTopologyFilter:public MeshToMeshFilter< TInputMesh, TOutputMesh >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(SimplexMeshAdaptTopologyFilter);

  using Self = SimplexMeshAdaptTopologyFilter;

  using Superclass = MeshToMeshFilter< TInputMesh, TOutputMesh >;

  using Pointer = SmartPointer< Self >;

  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro(SimplexMeshAdaptTopologyFilter, MeshToMeshFilter);

  using InputMeshType = TInputMesh;
  using InputMeshPointer = typename InputMeshType::Pointer;
  using InputPointType = typename InputMeshType::PointType;
  using InputVectorType = typename InputMeshType::VectorType;
  using InputPixelType = typename InputMeshType::PixelType;
  using InputCellTraitsType = typename InputMeshType::MeshTraits::CellTraits;
  using InputCellType = typename InputMeshType::CellType;
  using PointIdentifier = typename InputMeshType::PointIdentifier;
  using CellIdentifier = typename InputMeshType::CellIdentifier;
  using InputCellPointIdIterator = typename InputCellType::PointIdIterator;
  using InputCellAutoPointer = typename InputCellType::CellAutoPointer;
  using CellAutoPointer = typename InputMeshType::CellAutoPointer;
  using InputPolygonType = itk::PolygonCell< InputCellType >;
  using InputPolygonPointIdIterator = typename InputPolygonType::PointIdIterator;
  using CovariantVectorType = CovariantVector< typename InputVectorType::ValueType, 3 >;
  using OutputMeshType = TOutputMesh;
  using OutputMeshPointer = typename OutputMeshType::Pointer;
  using OutputCellType = typename OutputMeshType::CellType;
  using OutputPolygonType = itk::PolygonCell< OutputCellType >;

  using DoubleValueMapType = typename itk::MapContainer< CellIdentifier, double >;
  using DoubleContainerIterator = typename DoubleValueMapType::Iterator;

  class SimplexCellVisitor
  {
public:
    InputMeshPointer            mesh;
    double                      totalArea;
    double                      totalCurvature;
    double                      minCellSize;
    double                      maxCellSize;
    typename DoubleValueMapType::Pointer areaMap;
    typename DoubleValueMapType::Pointer curvatureMap;

    double minCurvature;
    double maxCurvature;

    SimplexCellVisitor()
    {
      areaMap = DoubleValueMapType::New();
      curvatureMap = DoubleValueMapType::New();
      totalArea = 0;
      totalCurvature = 0;
      minCellSize = NumericTraits< double >::max();
      maxCellSize = 0;
      minCurvature = NumericTraits< double >::max();
      maxCurvature = 0;
    }

    void Visit(CellIdentifier cellId, InputPolygonType *poly)
    {
      typename InputPolygonType::PointIdIterator it =  poly->PointIdsBegin();

      double        meanCurvature = 0;
      PointIdentifier refPoint = *it;
      double        val = mesh->GetMeanCurvature(*it++);
      meanCurvature += std::abs(val);

      PointIdentifier id1 = *it;
      val = mesh->GetMeanCurvature(*it++);
      meanCurvature += std::abs(val);

      PointIdentifier id2;

      double area = 0;

      int cnt = 0;

      while ( it != poly->PointIdsEnd() )
        {
        id2 = *it;
        area += ComputeArea(refPoint, id1, id2);
        id1 = id2;
        val = mesh->GetMeanCurvature(*it);
        meanCurvature += std::abs(val);
        cnt++;
        it++;
        }

      meanCurvature /= (double)cnt;
      totalArea += area;
      totalCurvature += meanCurvature;

      areaMap->InsertElement(cellId, area);
      curvatureMap->InsertElement(cellId, meanCurvature);

      if ( area > maxCellSize ) { maxCellSize = area; }
      if ( area < minCellSize ) { minCellSize = area; }
      if ( meanCurvature > maxCurvature ) { maxCurvature = meanCurvature; }
      if ( meanCurvature < minCurvature ) { minCurvature = meanCurvature; }
    }

    double ComputeArea(PointIdentifier p1, PointIdentifier p2, PointIdentifier p3)
    {
      InputPointType v1, v2, v3;

      v1.Fill(0);
      v2.Fill(0);
      v3.Fill(0);

      mesh->GetPoint(p1, &v1);
      mesh->GetPoint(p2, &v2);
      mesh->GetPoint(p3, &v3);
      return std::abs (vnl_cross_3d( ( v2 - v1 ).GetVnlVector(), ( v3 - v1 ).GetVnlVector() ).two_norm() / 2.0);
    }

    typename DoubleValueMapType::Pointer GetAreaMap()
    {
      return areaMap;
    }

    typename DoubleValueMapType::Pointer GetCurvatureMap()
    {
      return curvatureMap;
    }

    double GetTotalMeshArea()
    {
      return totalArea;
    }

    double GetTotalMeanCurvature()
    {
      return totalCurvature / ( curvatureMap->Size() );
    }

    double GetMaximumCellSize()
    {
      return maxCellSize;
    }

    double GetMinimumCellSize()
    {
      return minCellSize;
    }

    double GetMaximumCurvature()
    {
      return maxCurvature;
    }

    double GetMinimumCurvature()
    {
      return minCurvature;
    }
  };

  // cell visitor stuff
  using SimplexVisitorInterfaceType = itk::CellInterfaceVisitorImplementation<
                                                   InputPixelType,
                                                   InputCellTraitsType,
                                                   InputPolygonType,
                                                   SimplexCellVisitor >;

  using SimplexVisitorInterfacePointer = typename SimplexVisitorInterfaceType::Pointer;
  using CellMultiVisitorType = typename InputCellType::MultiVisitor;
  using CellMultiVisitorPointer = typename CellMultiVisitorType::Pointer;

  itkSetMacro(Threshold, double);
  itkGetConstMacro(Threshold, double);

  itkSetMacro(SelectionMethod, int);
  itkGetConstMacro(SelectionMethod, int);

  itkGetConstMacro(ModifiedCount, int);

protected:

  SimplexMeshAdaptTopologyFilter();
  ~SimplexMeshAdaptTopologyFilter() override = default;

  void PrintSelf(std::ostream & os, Indent indent) const override;

  void GenerateData() override;

  void Initialize();

  void ComputeCellParameters();

  void CopyInputMeshToOutputMeshGeometryData();

  void ModifyNeighborCells(CellIdentifier id1, CellIdentifier id2, PointIdentifier insertPointId);

  InputPointType ComputeCellCenter(InputCellAutoPointer & simplexCell);

  CellIdentifier m_IdOffset;

  double m_Threshold{0.5};

  int m_SelectionMethod{0};

  int m_ModifiedCount{0};

  OutputMeshPointer m_Output;

  InputCellAutoPointer m_NewSimplexCellPointer;
};
} //end of namespace

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSimplexMeshAdaptTopologyFilter.hxx"
#endif

#endif // itkSimplexMeshAdaptTopologyFilter_h