itkquadedgetest1.cxx

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

      std::cerr << "Error in GetInvLnext()" << std::endl;
      return EXIT_FAILURE;
      }

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

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

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

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

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

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

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

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

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

    quadEdge3->SetOnext( quadEdgeA );

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

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

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

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

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

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

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

    //                       |
    //                       |
    //                       |
    //                       | quadEdgeA
    //                       |
    //                       |
    //                       V
    //  -------------------> 0
    //      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 );

    quadEdge4->SetOnext( quadEdgeB );

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

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

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

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

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


    // Tests for the IsHalfEdge() method
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

    if( quadEdge1c->IsHalfEdge() != true )
      {
      std::cerr << "Error in IsHalfEdge() A" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge1->SetRot( quadEdge2 );

    if( quadEdge1c->IsHalfEdge() != true )
      {
      std::cerr << "Error in IsHalfEdge() B" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge1->SetOnext( quadEdgeA );

    if( quadEdge1c->IsHalfEdge() != false )
      {
      std::cerr << "Error in IsHalfEdge() C" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge1->SetRot( NULL );

    if( quadEdge1c->IsHalfEdge() != true )
      {
      std::cerr << "Error in IsHalfEdge() D" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdgeA;

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

    // Tests for the IsIsolated() method
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

    if( quadEdge1c->IsIsolated() != true )
      {
      std::cerr << "Error in IsIsolated() A" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge1->SetOnext( quadEdge2 );

    if( quadEdge1c->IsIsolated() != false )
      {
      std::cerr << "Error in IsIsolated() B" << std::endl;
      return EXIT_FAILURE;
      }

    quadEdge1->SetOnext( quadEdge1 );

    if( quadEdge1c->IsIsolated() != true )
      {
      std::cerr << "Error in IsIsolated() C" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;

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

    // Tests for the IsEdgeInOnextRing() method
    { // create a local scope for these tests
    QuadEdgeType * quadEdge1 = new QuadEdgeType;
    QuadEdgeType * quadEdge2 = new QuadEdgeType;
    QuadEdgeType * quadEdge3 = new QuadEdgeType;
    QuadEdgeType * quadEdge4 = new QuadEdgeType;
    QuadEdgeType * quadEdge5 = new QuadEdgeType;
    QuadEdgeType * quadEdge6 = new QuadEdgeType;

    const QuadEdgeType * quadEdge1c = quadEdge1;

    quadEdge1->SetOnext( NULL );
    quadEdge1c->IsEdgeInOnextRing( NULL );

    if( quadEdge1c->IsEdgeInOnextRing( quadEdge6 ) == true )
      {
      std::cerr << "Error in IsEdgeInOnextRing() A" << std::endl;
      return EXIT_FAILURE;
      }

    // Create a ring
    quadEdge1->SetOnext( quadEdge2 );
    quadEdge2->SetOnext( quadEdge3 );
    quadEdge3->SetOnext( quadEdge4 );
    quadEdge4->SetOnext( quadEdge5 );
    quadEdge5->SetOnext( quadEdge1 );

    if( quadEdge1c->IsEdgeInOnextRing( quadEdge6 ) == true )
      {
      std::cerr << "Error in IsEdgeInOnextRing() B" << std::endl;
      return EXIT_FAILURE;
      }

    // Close the ring by adding
    quadEdge5->SetOnext( quadEdge6 );
    quadEdge6->SetOnext( quadEdge1 );

    if( quadEdge1c->IsEdgeInOnextRing( quadEdge6 ) == false )
      {
      std::cerr << "Error in IsEdgeInOnextRing() C" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdge1;
    delete quadEdge2;
    delete quadEdge3;
    delete quadEdge4;
    delete quadEdge5;
    delete quadEdge6;

    std::cout << "IsEdgeInOnextRing() Test passed ! " << std::endl;
    } // end of local scope for tests

    // Tests for the IsLnextGivenSizeCyclic() method
    { // create a local scope for these tests
    //                                           //
    //                                           //
    // Create quad-edges on the three physical   //
    // edges (A,B,C) of a triangular face        //
    //                                           //
    //                                           //
    //                   /\                      //
    //                  /  \                     //
    //                 /    \                    //
    //                /      \                   //
    //           B   /        \  A               //
    //              /          \                 //
    //             /            \                //
    //            /              \               //
    //           /                \              //
    //           ------------------              //
    //                   C   quadEdgeC1-->       //
    //                                           //
    //                                           //
    QuadEdgeType * quadEdgeA1 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA2 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA3 = new QuadEdgeType;
    QuadEdgeType * quadEdgeA4 = new QuadEdgeType;

    QuadEdgeType * quadEdgeB1 = new QuadEdgeType;
    QuadEdgeType * quadEdgeB2 = new QuadEdgeType;
    QuadEdgeType * quadEdgeB3 = new QuadEdgeType;
    QuadEdgeType * quadEdgeB4 = new QuadEdgeType;

    QuadEdgeType * quadEdgeC1 = new QuadEdgeType;
    QuadEdgeType * quadEdgeC2 = new QuadEdgeType;
    QuadEdgeType * quadEdgeC3 = new QuadEdgeType;
    QuadEdgeType * quadEdgeC4 = new QuadEdgeType;

    const QuadEdgeType * quadEdgeA1c = quadEdgeA1;
    const QuadEdgeType * quadEdgeB1c = quadEdgeB1;
    const QuadEdgeType * quadEdgeC1c = quadEdgeC1;
    const QuadEdgeType * quadEdgeA4c = quadEdgeA4;

    quadEdgeA1c->IsLnextGivenSizeCyclic( 3 ); // testing null case

    if( quadEdgeA1c->IsLnextGivenSizeCyclic( 3 ) == true )
      {
      std::cerr << "Error in IsLnextGivenSizeCyclic() A" << std::endl;
      return EXIT_FAILURE;
      }


    // Connect quad-edges inside physical edge A
    quadEdgeA1->SetRot( quadEdgeA2 );
    quadEdgeA2->SetRot( quadEdgeA3 );
    quadEdgeA3->SetRot( quadEdgeA4 );
    quadEdgeA4->SetRot( quadEdgeA1 );

    // Connect quad-edges inside physical edge B
    quadEdgeB1->SetRot( quadEdgeB2 );
    quadEdgeB2->SetRot( quadEdgeB3 );
    quadEdgeB3->SetRot( quadEdgeB4 );
    quadEdgeB4->SetRot( quadEdgeB1 );

    // Connect quad-edges inside physical edge C
    quadEdgeC1->SetRot( quadEdgeC2 );
    quadEdgeC2->SetRot( quadEdgeC3 );
    quadEdgeC3->SetRot( quadEdgeC4 );
    quadEdgeC4->SetRot( quadEdgeC1 );

    // PRIMAL ORING
    // connect Orings of Top point
    quadEdgeA3->SetOnext( quadEdgeB1 );
    quadEdgeB1->SetOnext( quadEdgeA3 );

    // connect Oring of bottom left point
    quadEdgeB3->SetOnext( quadEdgeC1 );
    quadEdgeC1->SetOnext( quadEdgeB3 );

    // connect Oring of bottom right point
    quadEdgeC3->SetOnext( quadEdgeA1 );
    quadEdgeA1->SetOnext( quadEdgeC3 );

    // DUAL ORING (FACE)
    // triangle
    quadEdgeA4->SetOnext( quadEdgeB4 );
    quadEdgeB4->SetOnext( quadEdgeC4 );
    quadEdgeC4->SetOnext( quadEdgeA4 );

    // outside
    quadEdgeA2->SetOnext( quadEdgeC2 );
    quadEdgeC2->SetOnext( quadEdgeB2 );
    quadEdgeB2->SetOnext( quadEdgeA2 );

    const unsigned int quadEdgeA1Order = quadEdgeA1c->GetOrder();
    const unsigned int quadEdgeA1ExpectedOrder = 2;
    if( quadEdgeA1Order  != quadEdgeA1ExpectedOrder )
      {
      std::cerr << "Error in GetOrder() A" << std::endl;
      std::cerr << "Expected " << quadEdgeA1ExpectedOrder;
      std::cerr << ", but got " << quadEdgeA1Order << std::endl;
      return EXIT_FAILURE;
      }

    const unsigned int quadEdgeB1Order = quadEdgeB1c->GetOrder();
    const unsigned int quadEdgeB1ExpectedOrder = 2;
    if( quadEdgeB1Order  != quadEdgeB1ExpectedOrder )
      {
      std::cerr << "Error in GetOrder() B" << std::endl;
      std::cerr << "Expected " << quadEdgeB1ExpectedOrder;
      std::cerr << ", but got " << quadEdgeB1Order << std::endl;
      return EXIT_FAILURE;
      }

    const unsigned int quadEdgeC1Order = quadEdgeC1c->GetOrder();
    const unsigned int quadEdgeC1ExpectedOrder = 2;
    if( quadEdgeC1Order  != quadEdgeC1ExpectedOrder )
      {
      std::cerr << "Error in GetOrder() C" << std::endl;
      std::cerr << "Expected " << quadEdgeC1ExpectedOrder;
      std::cerr << ", but got " << quadEdgeC1Order << std::endl;
      return EXIT_FAILURE;
      }

    const unsigned int quadEdgeA4Order = quadEdgeA4c->GetOrder();
    const unsigned int quadEdgeA4ExpectedOrder = 3;
    if( quadEdgeA4Order  != quadEdgeA4ExpectedOrder )
      {
      std::cerr << "Error in GetOrder() D" << std::endl;
      std::cerr << "Expected " << quadEdgeA4ExpectedOrder;
      std::cerr << ", but got " << quadEdgeA4Order << std::endl;
      return EXIT_FAILURE;
      }

    // Check with the right period
    if( quadEdgeA1c->IsLnextGivenSizeCyclic( 3 ) == false )
      {
      std::cerr << "Error in IsLnextGivenSizeCyclic() B" << std::endl;
      return EXIT_FAILURE;
      }

    // Check a wrong period on purpose
    if( quadEdgeA1c->IsLnextGivenSizeCyclic( 4 ) == true )
      {
      std::cerr << "Error in IsLnextGivenSizeCyclic() C" << std::endl;
      return EXIT_FAILURE;
      }

    delete quadEdgeA1;
    delete quadEdgeA2;
    delete quadEdgeA3;
    delete quadEdgeA4;

    delete quadEdgeB1;
    delete quadEdgeB2;
    delete quadEdgeB3;
    delete quadEdgeB4;

    delete quadEdgeC1;
    delete quadEdgeC2;
    delete quadEdgeC3;
    delete quadEdgeC4;

    std::cout << "IsLnextGivenSizeCyclic() Test passed ! " << std::endl;
    } // end of local scope for tests

  std::cout << "QuadEdge Test Passed !" << std::endl;

  return EXIT_SUCCESS;
}