itkquadedgetest1.cxx

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

    //                     /
    //                    /
    //   <---------------O
    //       quadEdge1
    //

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

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

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

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

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

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

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

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

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


  // Tests for the GetLprev() methods
  // returns the previous 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;
    QuadEdgeType * quadEdgeC = new QuadEdgeType;
    QuadEdgeType * quadEdgeD = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

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

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

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

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

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

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

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

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

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

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


    // Tests for the GetRprev() methods
    // returns the previous 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;
    QuadEdgeType * quadEdgeC = new QuadEdgeType;
    QuadEdgeType * quadEdgeD = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

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

    //
    //
    //
    //
    //     ???
    //
    //
    //
    //
    //

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

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

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

    quadEdge3->SetOnext( quadEdgeA );

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

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

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

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

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


    // Tests for the GetDprev() methods
    // returns the previous 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->GetDprev() || quadEdge1c->GetDprev( ) )
      {
      std::cerr << "Error in GetDprev()" << std::endl;
      return EXIT_FAILURE;
      }
    //                       |
    //                       |
    //                       |
    //                       | quadEdgeA
    //                       |
    //                       |
    //                       V
    //  -------------------> 0
    //      quadEdge1
    //

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

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

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

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

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

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

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

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

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

    // Tests for the GetInvRot() 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;

    // Testing incomplete connections.
    if( quadEdge1->GetInvRot() || quadEdge1c->GetInvRot( ) )
      {
      std::cerr << "Error in GetInvRot()" << std::endl;
      return EXIT_FAILURE;
      }

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

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

    quadEdge3->SetRot( quadEdge4 );

    // Finally, the well constructed case
    quadEdge1->SetRot( quadEdge2 );
    quadEdge2->SetRot( quadEdge3 );
    quadEdge3->SetRot( quadEdge4 );
    quadEdge4->SetRot( quadEdge1 );

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

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

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

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

    // Tests for the GetInvOnext() 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;

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

    //
    //                        ^/^
    //                        /
    //                       / quadEdgeA
    //          Face        /
    //                     /
    //                    /
    //   <---------------O
    //       quadEdge1
    //

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

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

    quadEdge2->SetOnext( quadEdgeD ); // rely on this one
    quadEdgeA->SetOnext( quadEdge1 );

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

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

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

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

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

    // Tests for the GetInvLnext() methods
    // returns the previous 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;
    QuadEdgeType * quadEdgeC = new QuadEdgeType;
    QuadEdgeType * quadEdgeD = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

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

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

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

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

    quadEdge1->SetOnext( quadEdgeC );

    if( quadEdge1->GetInvLnext() != quadEdgeA )
      {