itkQuadEdge.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkQuadEdge.h,v $
  Language:  C++
  Date:      $Date: 2010-06-14 15:03:58 $
  Version:   $Revision: 1.21 $

  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 __itkQuadEdge_h
#define __itkQuadEdge_h

#include "itkQuadEdgeMeshBaseIterator.h"

#include "itkMacro.h"

// Debugging macros for classes that do not derive from the itkObject.
// FIXME: Maybe variations of these macros should be moved into
// itkMacro.h
//
#define itkQEDebugMacro( x )                                        \
{                                                                   \
    OStringStream itkmsg;                                           \
    itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << "\n"   \
           << " (" << this << "): " x                               \
           << "\n\n";                                               \
    OutputWindowDisplayDebugText( itkmsg.str( ).c_str( ) );         \
}
#define itkQEWarningMacro( x )                                      \
{                                                                   \
    OStringStream itkmsg;                                           \
    itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" \
           << " (" << this << "): " x                               \
           << "\n\n";                                               \
    OutputWindowDisplayWarningText( itkmsg.str( ).c_str( ) );       \
}


// -------------------------------------------------------------------------
#define itkQEAccessorsMacro( st, pt, dt )                               \
   pt* GetOnext()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetOnext() ) );             \
    }                                                                   \
                                                                        \
   dt* GetRot()                                                         \
    {                                                                   \
    return( dynamic_cast<  dt* >( this->st::GetRot() ) );               \
    }                                                                   \
                                                                        \
   pt* GetSym()                                                         \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetSym() ) );               \
    }                                                                   \
                                                                        \
   pt* GetLnext()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetLnext() ) );             \
    }                                                                   \
                                                                        \
   pt* GetRnext()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetRnext() ) );             \
    }                                                                   \
                                                                        \
   pt* GetDnext()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetDnext() ) );             \
    }                                                                   \
                                                                        \
   pt* GetOprev()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetOprev() ) );             \
    }                                                                   \
                                                                        \
   pt* GetLprev()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetLprev() ) );             \
    }                                                                   \
                                                                        \
   pt* GetRprev()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetRprev() ) );             \
    }                                                                   \
                                                                        \
   pt* GetDprev()                                                       \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetDprev() ) );             \
    }                                                                   \
                                                                        \
   dt* GetInvRot()                                                      \
    {                                                                   \
    return( dynamic_cast< dt* >( this->st::GetInvRot() ) );             \
    }                                                                   \
                                                                        \
   pt* GetInvOnext()                                                    \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetInvOnext() ) );          \
    }                                                                   \
                                                                        \
   pt* GetInvLnext()                                                    \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetInvLnext() ) );          \
    }                                                                   \
                                                                        \
   pt* GetInvRnext()                                                    \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetInvRnext() ) );          \
    }                                                                   \
                                                                        \
   pt* GetInvDnext()                                                    \
    {                                                                   \
    return( dynamic_cast<  pt* >( this->st::GetInvDnext() ) );          \
    }                                                                   \
  const pt* GetOnext() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetOnext() ) );        \
    }                                                                   \
                                                                        \
  const dt* GetRot() const                                              \
    {                                                                   \
    return( dynamic_cast< const dt* >( this->st::GetRot() ) );          \
    }                                                                   \
                                                                        \
  const pt* GetSym() const                                              \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetSym() ) );          \
    }                                                                   \
                                                                        \
  const pt* GetLnext() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetLnext() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetRnext() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetRnext() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetDnext() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetDnext() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetOprev() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetOprev() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetLprev() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetLprev() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetRprev() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetRprev() ) );        \
    }                                                                   \
                                                                        \
  const pt* GetDprev() const                                            \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetDprev() ) );        \
    }                                                                   \
                                                                        \
  const dt* GetInvRot() const                                           \
    {                                                                   \
    return( dynamic_cast< const dt* >( this->st::GetInvRot() ) );       \
    }                                                                   \
                                                                        \
  const pt* GetInvOnext() const                                         \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetInvOnext() ) );     \
    }                                                                   \
                                                                        \
  const pt* GetInvLnext() const                                         \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetInvLnext() ) );     \
    }                                                                   \
                                                                        \
  const pt* GetInvRnext() const                                         \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetInvRnext() ) );     \
    }                                                                   \
                                                                        \
  const pt* GetInvDnext() const                                         \
    {                                                                   \
    return( dynamic_cast< const pt* >( this->st::GetInvDnext() ) );     \
    }


namespace itk
{

class QuadEdge
{
public:
  typedef QuadEdge Self;

  typedef QuadEdgeMeshIterator< Self >      Iterator;
  typedef QuadEdgeMeshConstIterator< Self > ConstIterator;

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

  QuadEdge();
  virtual ~QuadEdge();

  inline void SetOnext( Self* onext ) { this->m_Onext = onext; }
  inline void SetRot( Self* rot )     { this->m_Rot = rot; }

  inline Self* GetOnext() {return this->m_Onext;}
  inline Self* GetRot()   {return this->m_Rot;}
  inline const Self* GetOnext() const {return this->m_Onext;}
  inline const Self* GetRot() const   {return this->m_Rot;}

// TODO fix this ref
//   * \sa \ref DoxySurgeryConnectivity
   inline void Splice( Self* b )
    {
    Self * aNext     = this->GetOnext();
    Self * bNext     = b->GetOnext();
    Self * alpha     = aNext->GetRot();
    Self * beta      = bNext->GetRot();
    Self * alphaNext = alpha->GetOnext();
    Self * betaNext  = beta->GetOnext();

    this->SetOnext( bNext );
    b->SetOnext( aNext );
    alpha->SetOnext( betaNext );
    beta->SetOnext( alphaNext );
    }


  //  Second order accessors.

  inline Self* GetSym() 
    { 
    if(this->m_Rot) 
      {
      return( this->m_Rot->m_Rot );
      }
    return( this->m_Rot );
    }
  inline const Self* GetSym() const
    {
    if( this->m_Rot) 
      {
      return( this->m_Rot->m_Rot );
      }
    return( this->m_Rot );
    }

  Self* GetLnext(); 
  const Self* GetLnext() const;

  Self* GetRnext();
  const Self* GetRnext() const;

  Self* GetDnext();
  const Self* GetDnext() const;

  Self* GetOprev();
  const Self* GetOprev() const;

  Self* GetLprev();
  const Self* GetLprev() const;

  Self* GetRprev();
  const Self* GetRprev() const;

  Self* GetDprev();
  const Self* GetDprev() const;

  inline Self * GetInvRot() 
    {
#ifdef NDEBUG
    return( this->GetRot()->GetRot()->GetRot() );
#else
    Self * p1 = this->GetRot();
    if( !p1 ) return NULL;
    Self * p2 = p1->GetRot();
    if( !p2 ) return NULL;
    Self * p3 = p2->GetRot();
    if( !p3 ) return NULL;
    return p3;
#endif
    }
  inline Self * GetInvOnext() { return this->GetOprev(); }
  inline Self * GetInvLnext() { return this->GetLprev(); }
  inline Self * GetInvRnext() { return this->GetRprev(); }
  inline Self * GetInvDnext() { return this->GetDprev(); }
  inline const Self * GetInvRot() const 
    {
#ifdef NDEBUG
    return( this->GetRot()->GetRot()->GetRot() );
#else
    const Self * p1 = this->GetRot();
    if( !p1 ) return NULL;
    const Self * p2 = p1->GetRot();
    if( !p2 ) return NULL;
    const Self * p3 = p2->GetRot();
    if( !p3 ) return NULL;
    return p3;
#endif
    }
  inline const Self * GetInvOnext() const { return this->GetOprev(); }
  inline const Self * GetInvLnext() const { return this->GetLprev(); }
  inline const Self * GetInvRnext() const { return this->GetRprev(); }
  inline const Self * GetInvDnext() const { return this->GetDprev(); }

  inline bool IsHalfEdge() const { return( ( m_Onext == this ) || ( m_Rot == NULL ) ); }
  inline bool IsIsolated() const { return( this == this->GetOnext() ); }
  bool IsEdgeInOnextRing( Self* testEdge ) const;
  bool IsLnextGivenSizeCyclic( const int size ) const;
  unsigned int GetOrder() const;

private: 
};

} 

#endif