itkGeometricalQuadEdge.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 __itkGeometricalQuadEdge_h
#define __itkGeometricalQuadEdge_h

#include "itkQuadEdge.h"

namespace itk
{
template< typename TVRef,  typename TFRef,
          typename TPrimalData, typename TDualData,
          bool PrimalDual = true >
class GeometricalQuadEdge:public QuadEdge
{
public:
  typedef GeometricalQuadEdge Self;
  typedef QuadEdge            Superclass;
  typedef Self *              RawPointer;

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

  typedef TVRef       OriginRefType;
  typedef TFRef       DualOriginRefType;
  typedef TPrimalData PrimalDataType;
  typedef TDualData   DualDataType;
  // Line Cell Id in Mesh Cell Container
  // used to go up to LineCell level
  typedef TFRef LineCellIdentifier;

public:

  typedef QuadEdgeMeshIteratorGeom< Self >      IteratorGeom;
  typedef QuadEdgeMeshConstIteratorGeom< Self > ConstIteratorGeom;

  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();
  virtual ~GeometricalQuadEdge() {}

  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)
  // implicitely 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 = 0);

  bool InsertAfterNextBorderEdgeWithUnsetLeft(Self *isol,
                                              Self *hint = 0);

  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;   // Indicates if the data is set.
  LineCellIdentifier m_LineCellIdent;
};
}

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

#endif