C++ PlanarFigureList::push_back方法代码示例

  static PlanarFigureList CreateDeepCopiedPlanarFigures(PlanarFigureList original)
  {
    PlanarFigureList copiedPlanarFigures;

    PlanarFigureList::iterator it1;

    for ( it1 = original.begin(); it1 != original.end(); ++it1 )
    {
      mitk::PlanarFigure::Pointer copiedFigure = (*it1)->Clone();

      copiedPlanarFigures.push_back(copiedFigure);
    }
    return copiedPlanarFigures;
  }

  static PlanarFigureList CreateDeepCopiedPlanarFigures(PlanarFigureList original)
  {
    PlanarFigureList copiedPlanarFigures;

    PlanarFigureList::iterator it1;

    for ( it1 = original.begin(); it1 != original.end(); ++it1 )
    {
      mitk::PlanarFigure::Pointer copiedFigure;
      if(strcmp((*it1)->GetNameOfClass(), "PlanarAngle") == 0)
      {
        copiedFigure    = mitk::PlanarAngle::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarCircle") == 0)
      {
        copiedFigure    = mitk::PlanarCircle::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarLine") == 0)
      {
        copiedFigure    = mitk::PlanarLine::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarPolygon") == 0)
      {
        copiedFigure    = mitk::PlanarPolygon::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarSubdivisionPolygon") == 0)
      {
        copiedFigure    = mitk::PlanarSubdivisionPolygon::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarCross") == 0)
      {
        copiedFigure    = mitk::PlanarCross::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarRectangle") == 0)
      {
        copiedFigure    = mitk::PlanarRectangle::New();
      }
      if(strcmp((*it1)->GetNameOfClass(), "PlanarFourPointAngle") == 0)
      {
        copiedFigure    = mitk::PlanarFourPointAngle::New();
      }

      copiedFigure->DeepCopy((*it1));
      copiedPlanarFigures.push_back(copiedFigure.GetPointer());
    }
    return copiedPlanarFigures;
  }

  static PlanarFigureList DeserializePlanarFigures( std::string& fileName)
  {
    // Read in the planar figures
    mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New();
    reader->SetFileName( fileName.c_str() );
    reader->Update();

    MITK_TEST_CONDITION_REQUIRED(
        reader->GetSuccess(),
        "Testing if reading was successful");


    // Store them in the list and return it
    PlanarFigureList planarFigures;
    for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i )
    {
      mitk::PlanarFigure* figure = reader->GetOutput( i );
      planarFigures.push_back( figure );
    }

    return planarFigures;
  }

  static PlanarFigureList DeserializePlanarFiguresFromMemoryBuffers( PlanarFigureToMemoryWriterList pfMemoryWriters)
  {
    // Store them in the list and return it
    PlanarFigureList planarFigures;
    bool success = true;
    for ( unsigned int i = 0; i < pfMemoryWriters.size(); ++i )
    {
      // Read in the planar figures
      mitk::PlanarFigureReader::Pointer reader = mitk::PlanarFigureReader::New();
      reader->SetReadFromMemory( true );
      reader->SetMemoryBuffer(pfMemoryWriters[i]->GetMemoryPointer(), pfMemoryWriters[i]->GetMemorySize());
      reader->Update();
      mitk::PlanarFigure* figure = reader->GetOutput( 0 );
      planarFigures.push_back( figure );

      if(!reader->GetSuccess())
        success = false;
    }

    MITK_TEST_CONDITION_REQUIRED(success, "Testing if reading was successful");

    return planarFigures;
  }

  static PlanarFigureList CreatePlanarFigures()
  {
    PlanarFigureList planarFigures;

    // Create PlaneGeometry on which to place the PlanarFigures
    mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
    planeGeometry->InitializeStandardPlane( 100.0, 100.0 );

    // Create a few sample points for PlanarFigure placement
    mitk::Point2D p0; p0[0] = 20.0; p0[1] = 20.0;
    mitk::Point2D p1; p1[0] = 80.0; p1[1] = 80.0;
    mitk::Point2D p2; p2[0] = 90.0; p2[1] = 10.0;
    mitk::Point2D p3; p3[0] = 10.0; p3[1] = 90.0;

    // Create PlanarAngle
    mitk::PlanarAngle::Pointer planarAngle = mitk::PlanarAngle::New();
    planarAngle->SetGeometry2D( planeGeometry );
    planarAngle->PlaceFigure( p0 );
    planarAngle->SetCurrentControlPoint( p1 );
    planarAngle->AddControlPoint( p2 );
    planarFigures.push_back( planarAngle.GetPointer() );

    // Create PlanarCircle
    mitk::PlanarCircle::Pointer planarCircle = mitk::PlanarCircle::New();
    planarCircle->SetGeometry2D( planeGeometry );
    planarCircle->PlaceFigure( p0 );
    planarCircle->SetCurrentControlPoint( p1 );
    planarFigures.push_back( planarCircle.GetPointer() );

    // Create PlanarCross
    mitk::PlanarCross::Pointer planarCross = mitk::PlanarCross::New();
    planarCross->SetSingleLineMode( false );
    planarCross->SetGeometry2D( planeGeometry );
    planarCross->PlaceFigure( p0 );
    planarCross->SetCurrentControlPoint( p1 );
    planarCross->AddControlPoint( p2 );
    planarCross->AddControlPoint( p3 );
    planarFigures.push_back( planarCross.GetPointer() );

    // Create PlanarFourPointAngle
    mitk::PlanarFourPointAngle::Pointer planarFourPointAngle = mitk::PlanarFourPointAngle::New();
    planarFourPointAngle->SetGeometry2D( planeGeometry );
    planarFourPointAngle->PlaceFigure( p0 );
    planarFourPointAngle->SetCurrentControlPoint( p1 );
    planarFourPointAngle->AddControlPoint( p2 );
    planarFourPointAngle->AddControlPoint( p3 );
    planarFigures.push_back( planarFourPointAngle.GetPointer() );

    // Create PlanarLine
    mitk::PlanarLine::Pointer planarLine = mitk::PlanarLine::New();
    planarLine->SetGeometry2D( planeGeometry );
    planarLine->PlaceFigure( p0 );
    planarLine->SetCurrentControlPoint( p1 );
    planarFigures.push_back( planarLine.GetPointer() );

    // Create PlanarPolygon
    mitk::PlanarPolygon::Pointer planarPolygon = mitk::PlanarPolygon::New();
    planarPolygon->SetClosed( false );
    planarPolygon->SetGeometry2D( planeGeometry );
    planarPolygon->PlaceFigure( p0 );
    planarPolygon->SetCurrentControlPoint( p1 );
    planarPolygon->AddControlPoint( p2 );
    planarPolygon->AddControlPoint( p3 );
    planarFigures.push_back( planarPolygon.GetPointer() );

    // Create PlanarSubdivisionPolygon
    mitk::PlanarSubdivisionPolygon::Pointer planarSubdivisionPolygon = mitk::PlanarSubdivisionPolygon::New();
    planarSubdivisionPolygon->SetClosed( false );
    planarSubdivisionPolygon->SetGeometry2D( planeGeometry );
    planarSubdivisionPolygon->PlaceFigure( p0 );
    planarSubdivisionPolygon->SetCurrentControlPoint( p1 );
    planarSubdivisionPolygon->AddControlPoint( p2 );
    planarSubdivisionPolygon->AddControlPoint( p3 );
    planarFigures.push_back( planarSubdivisionPolygon.GetPointer() );

    // Create PlanarRectangle
    mitk::PlanarRectangle::Pointer planarRectangle = mitk::PlanarRectangle::New();
    planarRectangle->SetGeometry2D( planeGeometry );
    planarRectangle->PlaceFigure( p0 );
    planarRectangle->SetCurrentControlPoint( p1 );
    planarFigures.push_back( planarRectangle.GetPointer() );

    //create preciseGeometry which is using float coordinates
    mitk::PlaneGeometry::Pointer preciseGeometry = mitk::PlaneGeometry::New();
    mitk::Vector3D right;
    right[0] = 0.0;
    right[1] = 1.23456;
    right[2] = 0.0;

    mitk::Vector3D down;
    down[0] = 1.23456;
    down[1] = 0.0;
    down[2] = 0.0;

    mitk::Vector3D spacing;
    spacing[0] = 0.0123456;
    spacing[1] = 0.0123456;
    spacing[2] = 1.123456;
    preciseGeometry->InitializeStandardPlane( right, down, &spacing );

//.........这里部分代码省略.........