itkquadedgetest1.cxx

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkQuadEdgeTest1.cxx,v $
  Language:  C++
  Date:      $Date: 2007-09-05 21:24:32 $
  Version:   $Revision: 1.30 $

  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.

=========================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "itkQuadEdge.h"
#include <iostream>

int itkQuadEdgeTest1( int , char* [] )
{
  typedef itk::QuadEdge        QuadEdgeType;

  // Tests for the GetRot() SetRot() methods
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    const QuadEdgeType * quadEdge1c = quadEdge1;

    quadEdge1->GetRot(); // testing null case

    // Verify that it can be set.
    quadEdge1->SetRot( quadEdge2 );
    if( quadEdge1->GetRot() != quadEdge2 )
      {
      std::cerr << "Error in SetRot() / GetRot() " << std::endl;
      return EXIT_FAILURE;
      }
    // Test the const version
    if( quadEdge1c->GetRot() != quadEdge2 )
      {
      std::cerr << "Error in const GetRot() " << std::endl;
      return EXIT_FAILURE;
      }

    // Verify that it can be changed.
    quadEdge1->SetRot( quadEdge3 );
    if( quadEdge1->GetRot() != quadEdge3 )
      {
      std::cerr << "Error in changing SetRot() / GetRot() " << std::endl;
      return EXIT_FAILURE;
      }
    // Test the const version
    if( quadEdge1c->GetRot() != quadEdge3 )
      {
      std::cerr << "Error in changed const GetRot() " << std::endl;
      return EXIT_FAILURE;
      }

    std::cout << "GetRot()/SetRot() Test passed ! " << std::endl;

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    } // end of local scope for tests

    // Tests for the GetOnext() SetOnext() methods
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    const QuadEdgeType * quadEdge1c = quadEdge1;

    quadEdge1->GetOnext(); // testing null case

    // Verify that it can be set.
    quadEdge1->SetOnext( quadEdge2 );
    if( quadEdge1->GetOnext() != quadEdge2 )
      {
      std::cerr << "Error in SetOnext() / GetOnext() " << std::endl;
      return EXIT_FAILURE;
      }
    // Test the const version
    if( quadEdge1c->GetOnext() != quadEdge2 )
      {
      std::cerr << "Error in const GetOnext() " << std::endl;
      return EXIT_FAILURE;
      }

    // Verify that it can be changed.
    quadEdge1->SetOnext( quadEdge3 );
    if( quadEdge1->GetOnext() != quadEdge3 )
      {
      std::cerr << "Error in changing SetOnext() / GetOnext() " << std::endl;
      return EXIT_FAILURE;
      }
    // Test the const version
    if( quadEdge1c->GetOnext() != quadEdge3 )
      {
      std::cerr << "Error changed const GetOnext() " << std::endl;
      return EXIT_FAILURE;
      }

    std::cout << "GetOnext()/SetOnext() Test passed ! " << std::endl;

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    } // end of local scope for tests

    // Tests for the GetSym() methods
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;
    const QuadEdgeType * quadEdge1c = quadEdge1;
    const QuadEdgeType * quadEdge2c = quadEdge2;
    const QuadEdgeType * quadEdge3c = quadEdge3;
    const QuadEdgeType * quadEdge4c = quadEdge4;

    // testing first GetSym()'s fail case
    if( quadEdge1->GetSym() || quadEdge1c->GetSym() )
      {
      std::cerr << "Error GetSym( ) should fail here " << std::endl;
      return EXIT_FAILURE;
      }

    // testing the second GetSym()'s fail case
    quadEdge1->SetRot( quadEdge2 );
    if( quadEdge1->GetSym() || quadEdge1c->GetSym() )
      {
      std::cerr << "Error GetSym( ) should fail here " << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge2->SetRot( quadEdge3 );
    quadEdge3->SetRot( quadEdge4 );
    quadEdge4->SetRot( quadEdge1 );

    if( quadEdge1->GetSym() != quadEdge3 )
      {
      std::cerr << "Error in GetSym() " << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge1c->GetSym() != quadEdge3 )
      {
      std::cerr << "Error in const GetSym() " << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge2->GetSym() != quadEdge4 )
      {
      std::cerr << "Error in GetSym() B " << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge2c->GetSym() != quadEdge4 )
      {
      std::cerr << "Error in const GetSym() B" << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge3->GetSym() != quadEdge1 )
      {
      std::cerr << "Error in GetSym() C " << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge3c->GetSym() != quadEdge1 )
      {
      std::cerr << "Error in const GetSym() C" << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge4->GetSym() != quadEdge2 )
      {
      std::cerr << "Error in GetSym() D " << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge4c->GetSym() != quadEdge2 )
      {
      std::cerr << "Error in const GetSym() D" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    delete quadEdge4;

    std::cout << "GetSym()   Test passed ! " << std::endl;
    }


    // Tests for the GetLnext() methods
    // returns the next edge with same left face
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA = new QuadEdgeType;
    QuadEdgeType * quadEdgeB = new QuadEdgeType;
    const QuadEdgeType * quadEdge1c = quadEdge1;

    // testing first fail case
    if( quadEdge1->GetLnext() || quadEdge1c->GetLnext() )
      {
      std::cerr << "Error in GetLNext()" << std::endl;
      return EXIT_FAILURE;
      }

    //                        /
    //                       / quadEdgeA
    //          Face        /
    //                     /
    //                    /
    //   --------------->O
    //   quadEdge1
    //

    quadEdge1->SetRot( quadEdge2 );
    quadEdge2->SetRot( quadEdge3 );
    quadEdge3->SetRot( quadEdge4 );
    quadEdge4->SetRot( quadEdge1 );

    // testing second fail case
    quadEdge4->SetOnext( NULL );
    if( quadEdge1->GetLnext() || quadEdge1c->GetLnext() )
      {
      std::cerr << "Error in GetLnext()" << std::endl;
      return EXIT_FAILURE;
      }
    
    // testing third fail case
    quadEdge4->SetOnext( quadEdgeB );
    if( quadEdge1->GetLnext() || quadEdge1c->GetLnext() )
      {
      std::cerr << "Error in GetLnext()" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdgeB->SetRot( quadEdgeA );

    if( quadEdge1->GetLnext() != quadEdgeA )
      {
      std::cerr << "Error in GetLnext()" << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge1c->GetLnext() != quadEdgeA )
      {
      std::cerr << "Error in const GetLnext()" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    delete quadEdge4;
    delete quadEdgeA;
    delete quadEdgeB;

    std::cout << "GetLnext() Test passed ! " << std::endl;
    }

    // Tests for the GetRnext() methods
    // returns the next edge with same right face
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA = new QuadEdgeType;
    QuadEdgeType * quadEdgeB = new QuadEdgeType;
    const QuadEdgeType * quadEdge1c = quadEdge1;
    const QuadEdgeType * quadEdgeAc = quadEdgeA;

    // testing first fail case
    if( quadEdge1->GetRnext() || quadEdge1c->GetRnext( ) )
      {
      std::cerr << "Error in GetRnext()" << std::endl;
      return EXIT_FAILURE;
      }

    //
    //        quadEdge1
    //   --------------------->O
    //                        /
    //                       /
    //          Face        /
    //                     /quadEdgeA
    //                    /
    //

    quadEdge1->SetRot( quadEdge2 );
    quadEdge2->SetRot( quadEdge3 );
    quadEdge3->SetRot( quadEdge4 );
    quadEdge4->SetRot( quadEdge1 );

    quadEdge2->SetOnext( NULL );
    if( quadEdge1->GetRnext() || quadEdge1c->GetRnext( ) )
      {
      std::cerr << "Error in GetRnext()" << std::endl;
      return EXIT_FAILURE;
      }
    
    quadEdge2->SetOnext( quadEdgeB );
    quadEdgeB->SetOnext( quadEdge2 );
    if( quadEdge1->GetRnext() || quadEdge1c->GetRnext( ) )
      {
      std::cerr << "Error in GetRnext()" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdgeA->SetRot( quadEdgeB );

    if( quadEdgeA->GetRnext() != quadEdge1 )
      {
      std::cerr << "Error in GetRnext()" << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdgeAc->GetRnext() != quadEdge1 )
      {
      std::cerr << "Error in const GetRnext()" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    delete quadEdge4;
    delete quadEdgeA;
    delete quadEdgeB;

    std::cout << "GetRnext() Test passed ! " << std::endl;
    }

    // Tests for the GetDnext() methods
    // returns the next edge with same right face
    // and same destination
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;

    QuadEdgeType * quadEdgeA = new QuadEdgeType;
    QuadEdgeType * quadEdgeB = new QuadEdgeType;
    QuadEdgeType * quadEdgeC = new QuadEdgeType;
    QuadEdgeType * quadEdgeD = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

    if( quadEdge1->GetDnext() || quadEdge1c->GetDnext( ) )
      {
      std::cerr << "Error in GetDnext()" << std::endl;
      return EXIT_FAILURE;
      }


    //
    //        quadEdge1
    //   -------------------->-O
    //                         ^
    //                         |
    //          Face           |
    //                         |  quadEdgeC
    //                         |
    //

    quadEdge1->SetRot( quadEdge2 );
    quadEdge2->SetRot( quadEdge3 );
    quadEdge3->SetRot( quadEdge4 );
    quadEdge4->SetRot( quadEdge1 );

    quadEdge3->SetOnext( NULL );
    if( quadEdge1->GetDnext() || quadEdge1c->GetDnext( ) )
      {
      std::cerr << "Error in GetDnext()" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge3->SetOnext( quadEdgeA );
    if( quadEdge1->GetDnext() || quadEdge1c->GetDnext( ) )
      {
      std::cerr << "Error in GetDnext()" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdgeA->SetRot( quadEdgeB );
    quadEdgeB->SetRot( quadEdgeC );
    quadEdgeC->SetRot( quadEdgeD );
    quadEdgeD->SetRot( quadEdgeA );

    if( quadEdge1->GetDnext() != quadEdgeC )
      {
      std::cerr << "Error in GetDnext()" << std::endl;
      return EXIT_FAILURE;
      }

    if( quadEdge1c->GetDnext() != quadEdgeC )
      {
      std::cerr << "Error in const GetDnext()" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    delete quadEdge4;

    delete quadEdgeA;
    delete quadEdgeB;
    delete quadEdgeC;
    delete quadEdgeD;

    std::cout << "GetDnext() Test passed ! " << std::endl;
    }


    // Tests for the GetOprev() methods
    // returns the previous edge with same origin
    // and same destination
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;

    QuadEdgeType * quadEdgeA = new QuadEdgeType;
    QuadEdgeType * quadEdgeB = new QuadEdgeType;
    QuadEdgeType * quadEdgeC = new QuadEdgeType;
    QuadEdgeType * quadEdgeD = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

    if( quadEdge1->GetOprev() || quadEdge1c->GetOprev( ) )
      {
      std::cerr << "Error in GetOprev()" << std::endl;
      return EXIT_FAILURE;
      }

    //
    //                        ^/^
    //                        /
    //                       / quadEdgeA
    //          Face        /