itkGeometricalQuadEdge.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 itkGeometricalQuadEdge_h
#define itkGeometricalQuadEdge_h
 
#include "itkQuadEdge.h"
 
namespace itk
{
template <typename TVRef, typename TFRef, typename TPrimalData, typename TDualData, bool PrimalDual = true>
class ITK_TEMPLATE_EXPORT GeometricalQuadEdge : public QuadEdge
{
public:
  using Self = GeometricalQuadEdge;
  using Superclass = QuadEdge;
  using RawPointer = Self *;

  using DualType = GeometricalQuadEdge<TFRef, TVRef, TDualData, TPrimalData, !PrimalDual>;

  using OriginRefType = TVRef;
  using DualOriginRefType = TFRef;
  using PrimalDataType = TPrimalData;
  using DualDataType = TDualData;
  // Line Cell Id in Mesh Cell Container
  // used to go up to LineCell level
  using LineCellIdentifier = TFRef;
 
public:
  using IteratorGeom = QuadEdgeMeshIteratorGeom<Self>;
  using ConstIteratorGeom = QuadEdgeMeshConstIteratorGeom<Self>;

  inline itkQEDefineIteratorGeomMethodsMacro(Onext);
  inline itkQEDefineIteratorGeomMethodsMacro(Sym);
  inline itkQEDefineIteratorGeomMethodsMacro(Lnext);
  inline itkQEDefineIteratorGeomMethodsMacro(Rnext);
  inline itkQEDefineIteratorGeomMethodsMacro(Dnext);
  inline itkQEDefineIteratorGeomMethodsMacro(Oprev);
  inline itkQEDefineIteratorGeomMethodsMacro(Lprev);
  inline itkQEDefineIteratorGeomMethodsMacro(Rprev);
  inline itkQEDefineIteratorGeomMethodsMacro(Dprev);
  inline itkQEDefineIteratorGeomMethodsMacro(InvOnext);
  inline itkQEDefineIteratorGeomMethodsMacro(InvLnext);
  inline itkQEDefineIteratorGeomMethodsMacro(InvRnext);
  inline itkQEDefineIteratorGeomMethodsMacro(InvDnext);
  itkQEAccessorsMacro(Superclass, Self, DualType);
 
public:
  GeometricalQuadEdge();
  GeometricalQuadEdge(const GeometricalQuadEdge &) = default;
  GeometricalQuadEdge(GeometricalQuadEdge &&) = default;
  GeometricalQuadEdge &
  operator=(const GeometricalQuadEdge &) = default;
  GeometricalQuadEdge &
  operator=(GeometricalQuadEdge &&) = default;
  ~GeometricalQuadEdge() override = default;

  inline void
  SetOrigin(const OriginRefType v)
  {
    m_Origin = v;
  }
 
  inline void
  SetDestination(const OriginRefType v)
  {
    this->GetSym()->SetOrigin(v);
  }
 
  inline void
  SetRight(const DualOriginRefType v)
  {
    this->GetRot()->SetOrigin(v);
  }
 
  inline void
  SetLeft(const DualOriginRefType v)
  {
    this->GetInvRot()->SetOrigin(v);
  }

  bool
  SetLnextRingWithSameLeftFace(const DualOriginRefType faceGeom, int maxSize = 100);
 
  inline void
  UnsetOrigin()
  {
    m_Origin = m_NoPoint;
  }
  inline void
  UnsetDestination()
  {
    this->GetSym()->UnsetOrigin();
  }
  inline void
  UnsetRight()
  {
    this->GetRot()->UnsetOrigin();
  }
  inline void
  UnsetLeft()
  {
    this->GetInvRot()->UnsetOrigin();
  }

  // ORIENTATION_NOTE: this definition of GetLeft (or GetRight)
  // implicitly assumes that the Onext order is counter-clockwise !
  inline const OriginRefType
  GetOrigin() const
  {
    return (m_Origin);
  }
  inline const OriginRefType
  GetDestination() const
  {
    return (GetSym()->GetOrigin());
  }
  inline const DualOriginRefType
  GetRight() const
  {
    return (GetRot()->GetOrigin());
  }
  inline const DualOriginRefType
  GetLeft() const
  {
    return (GetInvRot()->GetOrigin());
  }

  bool
  IsOriginSet() const;
 
  bool
  IsDestinationSet() const;
 
  bool
  IsRightSet() const;
 
  bool
  IsLeftSet() const;

  inline void
  SetPrimalData(const PrimalDataType data)
  {
    m_Data = data;
    this->SetPrimalData();
  }
  inline void
  SetDualData(const DualDataType data)
  {
    this->GetRot()->SetPrimalData(data);
  }

  inline void
  SetPrimalData()
  {
    m_DataSet = true;
  }
  inline void
  SetDualData()
  {
    this->GetRot()->SetPrimalData();
  }
 
  inline void
  UnsetPrimalData()
  {
    m_Data = false;
  }
  inline void
  UnsetDualData()
  {
    this->GetRot()->UnsetPrimalData();
  }

  inline PrimalDataType
  GetPrimalData()
  {
    return (m_Data);
  }
  inline DualDataType
  GetDualData()
  {
    return (this->GetRot()->GetPrimalData());
  }

  inline bool
  IsPrimalDataSet()
  {
    return (m_DataSet);
  }
  inline bool
  IsDualDataSet()
  {
    return (this->GetRot()->IsPrimalDataSet());
  }

  inline bool
  IsWire()
  {
    return (!(this->IsLeftSet()) && !(this->IsRightSet()));
  }

  inline bool
  IsAtBorder()
  {
    return ((this->IsLeftSet() && !this->IsRightSet()) || (!this->IsLeftSet() && this->IsRightSet()));
  }

  inline bool
  IsInternal() const
  {
    return (this->IsLeftSet() && this->IsRightSet());
  }
 
  bool
  IsOriginInternal() const;
 
  bool
  IsLnextSharingSameFace(int maxSize = 100);
 
  bool
  IsLnextOfTriangle();
 
  bool
  IsInOnextRing(Self *);
 
  bool
  IsInLnextRing(Self *);
 
  Self *
  GetNextBorderEdgeWithUnsetLeft(Self * edgeTest = nullptr);
 
  bool
  InsertAfterNextBorderEdgeWithUnsetLeft(Self * isol, Self * hint = nullptr);
 
  bool
  ReorderOnextRingBeforeAddFace(Self * second);

  inline bool
  IsOriginDisconnected()
  {
    return (this == this->GetOnext());
  }
  inline bool
  IsDestinationDisconnected()
  {
    return (this->GetSym()->IsOriginDisconnected());
  }
  inline bool
  IsDisconnected()
  {
    return (this->IsOriginDisconnected() && this->IsDestinationDisconnected());
  }

  void
  Disconnect();
 
  inline void
  SetIdent(const LineCellIdentifier & User_Value)
  {
    this->m_LineCellIdent = User_Value;
  }
  inline LineCellIdentifier
  GetIdent()
  {
    return (this->m_LineCellIdent);
  }
 
public:
  // Reserved OriginRefType designated to represent the absence of Origin
  static const OriginRefType m_NoPoint;
 
protected:
  OriginRefType      m_Origin{};         // Geometrical information
  PrimalDataType     m_Data{};           // User data associated to this edge.
  bool               m_DataSet{ false }; // Indicates if the data is set.
  LineCellIdentifier m_LineCellIdent{};
};
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkGeometricalQuadEdge.hxx"
#endif
 
#endif