itkGeometricalQuadEdge.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkGeometricalQuadEdge.h,v $
  Language:  C++
  Date:      $Date: 2007/02/25 15:03:11 $
  Version:   $Revision: 1.11 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

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

public:

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

  itkQEDefineIteratorGeomMethodsMacro( Onext );
  itkQEDefineIteratorGeomMethodsMacro( Sym );
  itkQEDefineIteratorGeomMethodsMacro( Lnext );
  itkQEDefineIteratorGeomMethodsMacro( Rnext );
  itkQEDefineIteratorGeomMethodsMacro( Dnext );
  itkQEDefineIteratorGeomMethodsMacro( Oprev );
  itkQEDefineIteratorGeomMethodsMacro( Lprev );
  itkQEDefineIteratorGeomMethodsMacro( Rprev );
  itkQEDefineIteratorGeomMethodsMacro( Dprev );
  itkQEDefineIteratorGeomMethodsMacro( InvOnext );
  itkQEDefineIteratorGeomMethodsMacro( InvLnext );
  itkQEDefineIteratorGeomMethodsMacro( InvRnext );
  itkQEDefineIteratorGeomMethodsMacro( InvDnext );


  itkQEAccessorsMacro( Superclass, Self, DualType );

public:
  GeometricalQuadEdge();
  virtual ~GeometricalQuadEdge();

  void SetOrigin( const OriginRefType v )
    { m_Origin = v; }

  void SetDestination( const OriginRefType v )
    { this->GetSym()->SetOrigin( v ); }

  void SetRight( const DualOriginRefType v )
    { this->GetRot()->SetOrigin( v ); }

  void SetLeft( const DualOriginRefType v )
    { this->GetInvRot()->SetOrigin( v ); }

  bool SetLnextRingWithSameLeftFace( const DualOriginRefType faceGeom,
                                     int maxSize = 100 );

  void UnsetOrigin()   { m_Origin = m_NoPoint; }
  void UnsetDestination()  { this->GetSym()->UnsetOrigin(); }
  void UnsetRight() { this->GetRot()->UnsetOrigin(); }
  void UnsetLeft()  { this->GetInvRot()->UnsetOrigin(); }

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

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

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

  void SetPrimalData() { m_DataSet = true; }
  void SetDualData()   { this->GetRot()->SetPrimalData(); }

  void UnsetPrimalData() { m_Data = false; }
  void UnsetDualData()   { this->GetRot()->UnsetPrimalData(); }

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

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

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

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

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

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

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

} 

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

#endif 

---