mitk: mitkPointSetTest.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkTestingMacros.h"
00019 
00020 
00021 #include <mitkPointSet.h>
00022 #include <mitkVector.h>
00023 #include <mitkPointOperation.h>
00024 #include <mitkInteractionConst.h>
00025 
00026 #include <fstream>
00027 
00028 class mitkPointSetTestClass { public:
00029 
00030 static void TestGetITKPointSet(mitk::PointSet *pointSet)
00031 {
00032   //try to get the itkPointSet
00033   mitk::PointSet::DataType::Pointer itkdata = NULL;
00034   itkdata = pointSet->GetPointSet();
00035   MITK_TEST_CONDITION( itkdata.IsNotNull(), "try to get the itkPointSet from a newly created PointSet" )
00036 }
00037 
00038 static void TestGetSizeIsZero(mitk::PointSet *pointSet)
00039 {
00040   //fresh PointSet has to be empty!
00041   MITK_TEST_CONDITION( pointSet->GetSize() == 0, "check if the PointSet size is 0 " )
00042 }
00043 
00044 static void TestIsEmpty(mitk::PointSet *pointSet) 
00045 {
00046   MITK_TEST_CONDITION(pointSet->IsEmpty(0), "check if the PointSet is empty" )
00047 }
00048 
00049 static void TestCreateOperationAndAddPoint(mitk::PointSet *pointSet) 
00050 { 
00051   int id = 0;
00052   mitk::Point3D point;
00053   point.Fill(1);
00054 
00055   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpINSERT, point, id);
00056   pointSet->ExecuteOperation(doOp);
00057   MITK_TEST_CONDITION( pointSet->GetSize()==1 && pointSet->IndexExists(id), "check if added points exists" )
00058 
00059     delete doOp;
00060 
00061   mitk::Point3D tempPoint;
00062   tempPoint.Fill(0);
00063 
00064   tempPoint = pointSet->GetPoint(id);
00065 
00066   MITK_TEST_CONDITION( point == tempPoint, "check if added point contains real value" )
00067 }
00068 
00069 
00070 static void TestAddSecondPoint(mitk::PointSet *pointSet)
00071 {
00072   //add a point directly
00073   int id=0;
00074   mitk::Point3D point;
00075   mitk::FillVector3D(point, 1.0, 2.0, 3.0);
00076   ++id;
00077   pointSet->GetPointSet()->GetPoints()->InsertElement(id, point);
00078 
00079   MITK_TEST_CONDITION( pointSet->GetSize()==2 ||pointSet->IndexExists(id), "check if added points exists" )
00080 
00081     mitk::Point3D tempPoint;
00082 
00083   tempPoint.Fill(0);
00084   tempPoint = pointSet->GetPoint(id);
00085 
00086   MITK_TEST_CONDITION( point == tempPoint, "check if added point contains real value" )
00087 }
00088 
00089 static void TestIsNotEmpty(mitk::PointSet *pointSet)
00090 {
00091   //PointSet can not be empty!
00092   MITK_TEST_CONDITION( !pointSet->IsEmpty(0), "check if the PointSet is not empty " )
00093 
00094     /* 
00095     std::cout << "check if the PointSet is not empty ";
00096     if (pointSet->IsEmpty(0))
00097     {
00098     std::cout<<"[FAILED]"<<std::endl;
00099     return EXIT_FAILURE;
00100     }
00101     std::cout<<"[PASSED]"<<std::endl;
00102     */
00103 }
00104 
00105 
00106 static void TestSwapPointPositionUpwards(mitk::PointSet *pointSet)
00107 {
00108   //Check SwapPointPosition upwards
00109   mitk::Point3D point;
00110   mitk::Point3D tempPoint;
00111   point = pointSet->GetPoint(1);
00112   pointSet->SwapPointPosition(1, true);
00113   tempPoint = pointSet->GetPoint(0);
00114 
00115   MITK_TEST_CONDITION( point == tempPoint, "check SwapPointPosition upwards" )
00116 
00117     /*
00118     if(point != tempPoint)
00119     {
00120     std::cout<<"[FAILED]"<<std::endl;
00121     return EXIT_FAILURE;
00122     }
00123     std::cout<<"[PASSED]"<<std::endl;
00124     */
00125 }
00126 
00127 static void TestSwapPointPositionUpwardsNotPossible(mitk::PointSet *pointSet)
00128 {
00129   //Check SwapPointPosition upwards not possible
00130   MITK_TEST_CONDITION( pointSet->SwapPointPosition(0, true)==false, "check SwapPointPosition upwards not possible" )
00131 
00132     /*
00133     if(pointSet->SwapPointPosition(0, true))
00134     {
00135     std::cout<<"[FAILED]"<<std::endl;
00136     return EXIT_FAILURE;
00137     }
00138     std::cout<<"[PASSED]"<<std::endl;
00139     */
00140 }
00141 
00142 static void TestSwapPointPositionDownwards(mitk::PointSet *pointSet)
00143 {
00144   //Check SwapPointPosition downwards
00145   mitk::Point3D point;
00146   mitk::Point3D tempPoint;
00147   point = pointSet->GetPoint(0);  
00148   pointSet->SwapPointPosition(0, false);
00149   tempPoint = pointSet->GetPoint(1);
00150 
00151   MITK_TEST_CONDITION( point == tempPoint, "check SwapPointPosition down" )
00152 
00153     /*  
00154     if(point != tempPoint)
00155     {
00156     std::cout<<"[FAILED]"<<std::endl;
00157     return EXIT_FAILURE;
00158     }
00159     std::cout<<"[PASSED]"<<std::endl;
00160     */
00161 }
00162 
00163 static void TestSwapPointPositionDownwardsNotPossible(mitk::PointSet * /*pointSet*/)
00164 {
00165   mitk::PointSet::Pointer pointSet2 = mitk::PointSet::New();
00166 
00167   int id = 0;
00168   mitk::Point3D point;
00169   point.Fill(1);
00170   pointSet2->SetPoint(id, point);
00171 
00172 
00173   //Check SwapPointPosition downwards not possible
00174   MITK_TEST_CONDITION(!pointSet2->SwapPointPosition(id, false), "check SwapPointPosition downwards not possible" )
00175 
00176     /*
00177     if(pointSet->SwapPointPosition(1, false))
00178     {
00179     std::cout<<"[FAILED]"<<std::endl;
00180     return EXIT_FAILURE;
00181     }
00182     std::cout<<"[PASSED]"<<std::endl;
00183     */
00184 }
00185 
00186 static void TestPointOperationOpMove(mitk::PointSet *pointSet)
00187 {
00188   //check opMOVE  ExecuteOperation
00189   int id=1;
00190   mitk::Point3D point1;
00191   mitk::Point3D tempPoint;
00192   point1.Fill(2);
00193   
00194   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVE, point1, id);
00195   pointSet->ExecuteOperation(doOp);
00196   tempPoint = pointSet->GetPoint(id);
00197 
00198   MITK_TEST_CONDITION(tempPoint == point1 , "check PointOperation OpMove " )
00199     delete doOp;
00200   /*
00201   if (tempPoint != point1)
00202   {
00203   std::cout<<"[FAILED]"<<std::endl;
00204   return EXIT_FAILURE;
00205   }
00206   delete doOp;
00207   std::cout<<"[PASSED]"<<std::endl;
00208   */
00209 }
00210 
00211 static void TestPointOperationOpRemove(mitk::PointSet *pointSet)
00212 {
00213   //check OpREMOVE  ExecuteOperation
00214   int id=0;
00215   mitk::Point3D point;
00216   mitk::Point3D tempPoint;
00217 
00218   point = pointSet->GetPoint(id);
00219   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpREMOVE, point, id);
00220   pointSet->ExecuteOperation(doOp);
00221   tempPoint = pointSet->GetPoint(id);
00222 
00223   MITK_TEST_CONDITION(!pointSet->IndexExists(id) , "check PointOperation OpREMOVE " )
00224     delete doOp;
00225   /*
00226   if(pointSet->IndexExists(id))
00227   {
00228   std::cout<<"[FAILED]"<<std::endl;
00229   return EXIT_FAILURE;
00230   }
00231   delete doOp;
00232   std::cout<<"[PASSED]"<<std::endl;
00233   */
00234 }
00235 
00236 static void TestPointOperationOpSelectPoint(mitk::PointSet *pointSet)
00237 {
00238   mitk::Point3D point4;
00239   //check OpSELECTPOINT  ExecuteOperation
00240   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpSELECTPOINT, point4,4);
00241   pointSet->ExecuteOperation(doOp);
00242 
00243   MITK_TEST_CONDITION(pointSet->GetSelectInfo(4) , "check PointOperation OpSELECTPOINT " )
00244     delete doOp;
00245   /*
00246   if (!pointSet->GetSelectInfo(4))
00247   {
00248   std::cout<<"[FAILED]"<<std::endl;
00249   return EXIT_FAILURE;
00250   }
00251   delete doOp;
00252   std::cout<<"[PASSED]"<<std::endl;
00253   */
00254 }
00255 
00256 static void TestGetNumberOfSelected(mitk::PointSet *pointSet)
00257 {
00258   // check GetNumeberOfSelected 
00259   MITK_TEST_CONDITION(pointSet->GetNumberOfSelected() == 1 , "check GetNumeberOfSelected " )
00260     /*
00261     if(pointSet->GetNumberOfSelected() != 1)
00262     {
00263     std::cout<<"[FAILED]"<<std::endl;
00264     return EXIT_FAILURE;
00265     }
00266     std::cout<<"[PASSED]"<<std::endl;
00267     */
00268 }
00269 
00270 static void TestSearchSelectedPoint(mitk::PointSet *pointSet)
00271 {
00272   // check SearchSelectedPoint 
00273   MITK_TEST_CONDITION(pointSet->SearchSelectedPoint() == 4 , "check SearchSelectedPoint " )
00274 
00275     /*
00276     if( pointSet->SearchSelectedPoint() != 4)
00277     {
00278     std::cout<<"[FAILED]"<<std::endl;
00279     return EXIT_FAILURE;
00280     }
00281     std::cout<<"[PASSED]"<<std::endl;
00282     */
00283 }
00284 
00285 static void TestOpDeselectPoint(mitk::PointSet *pointSet)
00286 {
00287   //check OpDESELECTPOINT  ExecuteOperation
00288   mitk::Point3D point4;
00289   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpDESELECTPOINT, point4,4);
00290   pointSet->ExecuteOperation(doOp);
00291 
00292   MITK_TEST_CONDITION(!pointSet->GetSelectInfo(4) , "check PointOperation OpDESELECTPOINT " )
00293     MITK_TEST_CONDITION(pointSet->GetNumberOfSelected() == 0 , "check GetNumeberOfSelected " )
00294     delete doOp;
00295   /*
00296   if (pointSet->GetSelectInfo(4))
00297   {
00298   std::cout<<"[FAILED]"<<std::endl;
00299   return EXIT_FAILURE;
00300   }
00301   delete doOp;
00302   std::cout<<"[PASSED]"<<std::endl;
00303 
00304 
00305   if(pointSet->GetNumberOfSelected() != 0)
00306   {
00307   std::cout<<"[FAILED]"<<std::endl;
00308   return EXIT_FAILURE;
00309   }
00310   std::cout<<"[PASSED]"<<std::endl;
00311   */
00312 }
00313 
00314 static void TestOpMovePointUp(mitk::PointSet *pointSet)
00315 {
00316   //check OpMOVEPOINTUP  ExecuteOperation  
00317   int id = 4;
00318   mitk::Point3D point4;
00319   mitk::Point3D point;
00320   mitk::Point3D tempPoint;
00321 
00322   point = pointSet->GetPoint(id);
00323   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, point4, id);
00324   pointSet->ExecuteOperation(doOp);
00325   tempPoint = pointSet->GetPoint(id-1);
00326 
00327   MITK_TEST_CONDITION(tempPoint == point , "check PointOperation OpMOVEPOINTUP " )
00328     delete doOp;
00329   /*
00330   if (tempPoint != point)
00331   {
00332   std::cout<<"[FAILED]"<<std::endl;
00333   return EXIT_FAILURE;
00334   }
00335   delete doOp;
00336   std::cout<<"[PASSED]"<<std::endl;
00337   */
00338 }
00339 
00340 static void TestOpMovePointDown(mitk::PointSet *pointSet)
00341 {
00342   //check OpMOVEPOINTDown  ExecuteOperation  
00343 
00344   int id = 2;
00345   mitk::Point3D point;
00346   mitk::Point3D point2;
00347   mitk::Point3D tempPoint;
00348 
00349   point = pointSet->GetPoint(id);
00350   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, point2, id);
00351   pointSet->ExecuteOperation(doOp);
00352   tempPoint = pointSet->GetPoint(id+1);
00353 
00354   MITK_TEST_CONDITION(tempPoint == point , "check PointOperation OpMOVEPOINTDOWN " )
00355     delete doOp;
00356   /*
00357   if (tempPoint != point)
00358   {
00359   std::cout<<"[FAILED]"<<std::endl;
00360   return EXIT_FAILURE;
00361   }
00362   std::cout<<"[PASSED]"<<std::endl;
00363   */
00364 }
00365 
00366 static void TestSetSelectInfo(mitk::PointSet *pointSet)
00367 {
00368   //check SetSelectInfo
00369   pointSet->SetSelectInfo(2, true);
00370 
00371   MITK_TEST_CONDITION(pointSet->GetSelectInfo(2) , "check SetSelectInfo" )
00372     /*
00373     if (!pointSet->GetSelectInfo(2))
00374     {
00375     std::cout<<"[FAILED]"<<std::endl;
00376     return EXIT_FAILURE;
00377     }
00378     delete doOp;
00379     std::cout<<"[PASSED]"<<std::endl;
00380     */
00381 }
00382 
00383 static void TestInsertPointWithPointSpecification(mitk::PointSet *pointSet)
00384 {
00385   //check InsertPoint with PointSpecification
00386   mitk::Point3D point5;
00387   mitk::Point3D tempPoint;
00388   point5.Fill(7);
00389 
00390   pointSet->SetPoint(5, point5, mitk::PTEDGE );
00391   tempPoint = pointSet->GetPoint(5);
00392 
00393   MITK_TEST_CONDITION(tempPoint == point5, "check InsertPoint with PointSpecification" )
00394     /*
00395     if (tempPoint != point5)
00396     {
00397     std::cout<<"[FAILED]"<<std::endl;
00398     return EXIT_FAILURE;
00399     }
00400     std::cout<<"[PASSED]"<<std::endl;
00401     */
00402 }
00403 
00404 static void TestGetPointIfExists(mitk::PointSet *pointSet)
00405 {
00406   //check GetPointIfExists
00407   mitk::Point3D point5;
00408   mitk::Point3D tempPoint;
00409   point5.Fill(7);
00410   mitk::PointSet::PointType tmpPoint;
00411 
00412   pointSet->GetPointIfExists(5, &tmpPoint);
00413 
00414   MITK_TEST_CONDITION(tmpPoint == point5, "check GetPointIfExists: " )
00415     /*
00416     if (tmpPoint != point5)
00417     {
00418     std::cout<<"[FAILED]"<<std::endl;
00419     return EXIT_FAILURE;
00420     }
00421     std::cout<<"[PASSED]"<<std::endl;
00422     */
00423 } 
00424 
00425 static void TestCreateHoleInThePointIDs(mitk::PointSet *pointSet)
00426 {
00427   // create a hole in the point IDs
00428   mitk::Point3D point;
00429   mitk::PointSet::PointType p10, p11, p12;
00430   p10.Fill(10.0);
00431   p11.Fill(11.0);
00432   p12.Fill(12.0);
00433   pointSet->InsertPoint(10, p10);
00434   pointSet->InsertPoint(11, p11);
00435   pointSet->InsertPoint(12, p12);
00436 
00437   MITK_TEST_CONDITION((pointSet->IndexExists(10) == true) || (pointSet->IndexExists(11) == true) || (pointSet->IndexExists(12) == true), "add points with id 10, 11, 12: " )
00438 
00439   //check OpREMOVE  ExecuteOperation
00440   int id = 11;
00441   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpREMOVE, point, id);
00442   pointSet->ExecuteOperation(doOp);
00443 
00444   MITK_TEST_CONDITION(!pointSet->IndexExists(id), "remove point id 11: ")
00445 
00446     /*
00447     if(pointSet->IndexExists(id))
00448     {
00449     std::cout<<"[FAILED]"<<std::endl;
00450     return EXIT_FAILURE;
00451     }
00452     delete doOp;
00453     std::cout<<"[PASSED]"<<std::endl;
00454     */
00455 
00456     //mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, p12, 12);
00457     //pointSet->ExecuteOperation(doOp);
00458     delete doOp;
00459 
00460   //check OpMOVEPOINTUP  ExecuteOperation
00461   doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, p12, 12);
00462   pointSet->ExecuteOperation(doOp);
00463   delete doOp;
00464 
00465   mitk::PointSet::PointType newP10 = pointSet->GetPoint(10);
00466   mitk::PointSet::PointType newP12 = pointSet->GetPoint(12);
00467 
00468   MITK_TEST_CONDITION(((newP10 == p12) && (newP12 == p10)) == true, "check PointOperation OpMOVEPOINTUP for point id 12:" )
00469 
00470   //check OpMOVEPOINTDOWN  ExecuteOperation
00471   doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, p10, 10);
00472   pointSet->ExecuteOperation(doOp);
00473   delete doOp;
00474   newP10 = pointSet->GetPoint(10);
00475   newP12 = pointSet->GetPoint(12);
00476 
00477   MITK_TEST_CONDITION(((newP10 == p10) && (newP12 == p12)) == true, "check PointOperation OpMOVEPOINTDOWN for point id 10: ")
00478 }
00479 
00480 
00481 static void TestOpMovePointUpOnFirstPoint(mitk::PointSet *pointSet)
00482 {
00483   //check OpMOVEPOINTUP  on first point ExecuteOperation  
00484 
00485   mitk::PointSet::PointType p1 = pointSet->GetPoint(1);
00486   mitk::PointSet::PointType p2 = pointSet->GetPoint(2);
00487   mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, p1, 1);
00488   pointSet->ExecuteOperation(doOp);
00489   delete doOp;
00490   
00491   mitk::PointSet::PointType newP1 = pointSet->GetPoint(1);
00492   mitk::PointSet::PointType newP2 = pointSet->GetPoint(2);
00493 
00494   MITK_TEST_CONDITION(((newP1 == p1) && (newP2 == p2)) == true, "check PointOperation OpMOVEPOINTUP for point id 1: ")
00495 
00496     /*
00497     if (((newP1 == p1) && (newP2 == p2)) == false)
00498     {
00499     std::cout<<"[FAILED]"<<std::endl;
00500     return EXIT_FAILURE;
00501     }
00502     std::cout<<"[PASSED]"<<std::endl;
00503     */
00504 }
00505 static void TestPointContainerPointDataContainer(mitk::PointSet* ps)
00506 {
00507   mitk::PointSet::PointsContainer* pc = ps->GetPointSet()->GetPoints();
00508   mitk::PointSet::PointDataContainer* pd = ps->GetPointSet()->GetPointData();
00509   MITK_TEST_CONDITION_REQUIRED(pc->Size() == pd->Size(), "PointContainer and PointDataContainer have same size");
00510   mitk::PointSet::PointsContainer::ConstIterator pIt = pc->Begin();
00511   mitk::PointSet::PointDataContainer::ConstIterator dIt = pd->Begin();
00512   bool failed = false;
00513   for (; pIt != pc->End(); ++pIt, ++dIt)
00514     if (pIt->Index() != dIt->Index())
00515     {
00516       failed = true;
00517       break;
00518     }
00519   MITK_TEST_CONDITION(failed == false, "Indices in PointContainer and PointDataContainer are equal");
00520 }
00521 };
00522 
00523 
00524 
00525 
00526 int mitkPointSetTest(int /*argc*/, char* /*argv*/[])
00527 {
00528 
00529   MITK_TEST_BEGIN("PointSet")
00530 
00531     //Create PointSet
00532     mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
00533 
00534   MITK_TEST_CONDITION_REQUIRED(pointSet.IsNotNull(),"Testing instantiation") 
00535 
00536   mitkPointSetTestClass::TestGetITKPointSet(pointSet); 
00537   mitkPointSetTestClass::TestGetSizeIsZero(pointSet);
00538   mitkPointSetTestClass::TestIsEmpty(pointSet);
00539   mitkPointSetTestClass::TestCreateOperationAndAddPoint(pointSet);
00540 
00541   mitk::Point3D point2, point3, point4;
00542   point2.Fill(3);
00543   point3.Fill(4);
00544   point4.Fill(5);
00545   pointSet->InsertPoint(2,point2);
00546   pointSet->InsertPoint(3,point3);
00547   pointSet->InsertPoint(4,point4);
00548 
00549   mitkPointSetTestClass::TestAddSecondPoint(pointSet);
00550   mitkPointSetTestClass::TestIsNotEmpty(pointSet);
00551   mitkPointSetTestClass::TestSwapPointPositionUpwards(pointSet);
00552   mitkPointSetTestClass::TestSwapPointPositionUpwardsNotPossible(pointSet);
00553   mitkPointSetTestClass::TestSwapPointPositionDownwards(pointSet);
00554   mitkPointSetTestClass::TestSwapPointPositionDownwardsNotPossible(pointSet);
00555   mitkPointSetTestClass::TestPointOperationOpMove(pointSet);
00556   mitkPointSetTestClass::TestPointOperationOpRemove(pointSet);
00557   mitkPointSetTestClass::TestPointOperationOpSelectPoint(pointSet);
00558   mitkPointSetTestClass::TestGetNumberOfSelected(pointSet);
00559   mitkPointSetTestClass::TestSearchSelectedPoint(pointSet);
00560   mitkPointSetTestClass::TestOpDeselectPoint(pointSet);
00561   mitkPointSetTestClass::TestOpMovePointUp(pointSet);
00562   mitkPointSetTestClass::TestOpMovePointDown(pointSet);
00563   mitkPointSetTestClass::TestSetSelectInfo(pointSet);
00564   mitkPointSetTestClass::TestInsertPointWithPointSpecification(pointSet);
00565   mitkPointSetTestClass::TestGetPointIfExists(pointSet);
00566   mitkPointSetTestClass::TestCreateHoleInThePointIDs(pointSet);
00567   mitkPointSetTestClass::TestOpMovePointUpOnFirstPoint(pointSet);
00568 
00569   MITK_TEST_OUTPUT(<< "Test InsertPoint(), SetPoint() and SwapPointPosition()");
00570   mitk::PointSet::PointType point;
00571   mitk::FillVector3D(point, 2.2, 3.3, -4.4);
00572   /* call everything that might modify PointContainer and PointDataContainer */
00573   pointSet->InsertPoint(17, point);
00574   pointSet->SetPoint(4, point);
00575   pointSet->SetPoint(7, point);
00576   pointSet->SetPoint(2, point);
00577   pointSet->SwapPointPosition(7, true);
00578   pointSet->SwapPointPosition(3, true);
00579   pointSet->SwapPointPosition(2, false);
00580   mitkPointSetTestClass::TestPointContainerPointDataContainer(pointSet);
00581   
00582   MITK_TEST_OUTPUT(<< "Test OpREMOVE");
00583   mitk::PointOperation op1(mitk::OpREMOVE, mitk::Point3D(), 2); // existing index
00584   pointSet->ExecuteOperation(&op1);
00585   mitk::PointOperation op1b(mitk::OpREMOVE, mitk::Point3D(), 112); // non existing index
00586   pointSet->ExecuteOperation(&op1b);
00587   mitkPointSetTestClass::TestPointContainerPointDataContainer(pointSet);
00588 
00589   MITK_TEST_OUTPUT(<< "Test OpMove");
00590   mitk::PointOperation op2(mitk::OpMOVE, mitk::Point3D(), 4);  // existing index
00591   pointSet->ExecuteOperation(&op2);
00592   mitk::PointOperation op3(mitk::OpMOVE, mitk::Point3D(), 34);  // non existing index
00593   pointSet->ExecuteOperation(&op3);
00594   mitkPointSetTestClass::TestPointContainerPointDataContainer(pointSet);
00595 
00596   MITK_TEST_OUTPUT(<< "Test OpINSERT");
00597   mitk::PointOperation op4(mitk::OpINSERT, mitk::Point3D(), 38);  // non existing index
00598   pointSet->ExecuteOperation(&op4);
00599   mitk::PointOperation op5(mitk::OpINSERT, mitk::Point3D(), 17);  // existing index
00600   pointSet->ExecuteOperation(&op5);  
00601   mitkPointSetTestClass::TestPointContainerPointDataContainer(pointSet);
00602 
00603   MITK_TEST_END();
00604 }