#include <ctype.h>#include <stdio.h>#include <string.h>#include <stdlib.h>#include "mitkLog.h"Go to the source code of this file.
| typedef int(* MainFuncPointer)(int, char *[]) |
Definition at line 44 of file MitkIGTTestDriver.cpp.
| char* lowercase | ( | const char * | string ) |
Definition at line 175 of file MitkIGTTestDriver.cpp.
{
char *new_string, *p;
#ifdef __cplusplus
new_string = static_cast<char *>(malloc(sizeof(char) *
static_cast<size_t>(strlen(string) + 1)));
#else
new_string = (char *)(malloc(sizeof(char) * (size_t)(strlen(string) + 1)));
#endif
if (!new_string)
{
return 0;
}
strcpy(new_string, string);
p = new_string;
while (*p != 0)
{
#ifdef __cplusplus
*p = static_cast<char>(tolower(*p));
#else
*p = (char)(tolower(*p));
#endif
++p;
}
return new_string;
}
| int main | ( | int | ac, |
| char * | av[] | ||
| ) |
Definition at line 205 of file MitkIGTTestDriver.cpp.
References functionMapEntry::func, lowercase(), functionMapEntry::name, mitk::LoggingBackend::Register(), and mitk::LoggingBackend::Unregister().
{
int i, NumTests, testNum, partial_match;
char *arg, *test_name;
int count;
int testToRun = -1;
for(count =0; cmakeGeneratedFunctionMapEntries[count].name != 0; count++)
{
}
NumTests = count;
/* If no test name was given */
/* process command line with user function. */
if (ac < 2)
{
/* Ask for a test. */
printf("Available tests:\n");
for (i =0; i < NumTests; ++i)
{
printf("%3d. %s\n", i, cmakeGeneratedFunctionMapEntries[i].name);
}
printf("To run a test, enter the test number: ");
fflush(stdout);
testNum = 0;
if( scanf("%d", &testNum) != 1 )
{
printf("Couldn't parse that input as a number\n");
return -1;
}
if (testNum >= NumTests)
{
printf("%3d is an invalid test number.\n", testNum);
return -1;
}
testToRun = testNum;
ac--;
av++;
}
partial_match = 0;
arg = 0;
/* If partial match is requested. */
if(testToRun == -1 && ac > 1)
{
partial_match = (strcmp(av[1], "-R") == 0) ? 1 : 0;
}
if (partial_match && ac < 3)
{
printf("-R needs an additional parameter.\n");
return -1;
}
if(testToRun == -1)
{
arg = lowercase(av[1 + partial_match]);
}
for (i =0; i < NumTests && testToRun == -1; ++i)
{
test_name = lowercase(cmakeGeneratedFunctionMapEntries[i].name);
if (partial_match && strstr(test_name, arg) != NULL)
{
testToRun = i;
ac -=2;
av += 2;
}
else if (!partial_match && strcmp(test_name, arg) == 0)
{
testToRun = i;
ac--;
av++;
}
free(test_name);
}
if(arg)
{
free(arg);
}
if(testToRun != -1)
{
int result;
mitk::LoggingBackend::Register(); ;
result = (*cmakeGeneratedFunctionMapEntries[testToRun].func)(ac, av);
mitk::LoggingBackend::Unregister();
return result;
}
/* Nothing was run, display the test names. */
printf("Available tests:\n");
for (i =0; i < NumTests; ++i)
{
printf("%3d. %s\n", i, cmakeGeneratedFunctionMapEntries[i].name);
}
printf("Failed: %s is an invalid test name.\n", av[1]);
return -1;
}
| int mitkCameraVisualizationTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataVisualizationByBaseDataTransformFilter".
Definition at line 32 of file mitkCameraVisualizationTest.cpp.
References mitk::RenderingManager::GetInstance(), mitk::GlobalInteraction::GetInstance(), MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_FOR_EXCEPTION_BEGIN, MITK_TEST_FOR_EXCEPTION_END, mitk::VtkPropRenderer::New(), mitk::NavigationData::New(), and mitk::CameraVisualization::New().
{
MITK_TEST_BEGIN("CameraVisualization")
// let's create an object of our class
mitk::CameraVisualization::Pointer myFilter = mitk::CameraVisualization::New();
// Global interaction must(!) be initialized if used
mitk::GlobalInteraction::GetInstance()->Initialize("global");
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
srand(time(NULL));
// generate a random position for the navigation data
mitk::NavigationData::PositionType position;
position[0] = rand()%1000;
position[1] = rand()%1000;
position[2] = rand()%1000;
// generate a random orientation for the navigation data
mitk::NavigationData::OrientationType orientation;
orientation[0] = (rand()%1000)/1000.0;
orientation[1] = (rand()%1000)/1000.0;
orientation[2] = (rand()%1000)/1000.0;
orientation[3] = (rand()%1000)/1000.0;
// generate a random error for the navigation data
mitk::ScalarType error = rand()%10;
// data valid flag of navigation data
int val = rand()%2;
bool valid(0); // this was uninitialized. how was this test ever meant to work??
if (val==0)
{
valid=false;
}
else if (val==1)
{
valid=true;
}
// set parameters of navigation data
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(position);
nd1->SetOrientation(orientation);
nd1->SetPositionAccuracy(error);
nd1->SetDataValid(valid);
// create renderer
vtkRenderWindow* renderWindow = vtkRenderWindow::New();
mitk::VtkPropRenderer::Pointer renderer = mitk::VtkPropRenderer::New( "TestRenderer",renderWindow, mitk::RenderingManager::GetInstance() );
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "Testing Set-/GetInput() input 1");
// test for exception if renderer not set
MITK_TEST_FOR_EXCEPTION_BEGIN(itk::ExceptionObject)
myFilter->Update();
MITK_TEST_FOR_EXCEPTION_END(itk::ExceptionObject)
// set renderer
myFilter->SetRenderer(renderer);
//Update filter
myFilter->Update();
//Delete renderWindow correctly
renderWindow->Delete();
// always end with this!
MITK_TEST_END();
}
| int mitkClaronInterfaceTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the Class ClaronInterface. For tests with this class, which connects directly to the device via firewire by using the MTC-library we would need the MicronTracker hardware, so only instantiation is tested yet (2009, January, 23rd). As soon as there is a working concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
Definition at line 30 of file mitkClaronInterfaceTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_OUTPUT, and mitk::ClaronInterface::New().
{
MITK_TEST_BEGIN("ClaronInterface")
// let's create an object of our class
mitk::ClaronInterface::Pointer myClaronInterface = mitk::ClaronInterface::New();
myClaronInterface->Initialize("Test","Test");
// first test: did this work?
MITK_TEST_CONDITION_REQUIRED((myClaronInterface.IsNotNull()),"Testing instantiation:")
// if the Microntracker is not installed we could also test the returnValues of the stubs
if (!myClaronInterface->IsMicronTrackerInstalled())
{
MITK_TEST_OUTPUT(<< "In the following stubs are tested, errors are expected and should occur.")
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetAllActiveTools().empty()),"Testing stub of GetAllActiveTools() ");
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetName(0)==NULL),"Testing stub of GetName() ");
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetPosition(0).empty()),"Testing stub of GetPosition() ");
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetQuaternions(0).empty()),"Testing stub of GetQuaternions() ");
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetTipPosition(0).empty()),"Testing stub of GetTipPosition() ");
MITK_TEST_CONDITION_REQUIRED((myClaronInterface->GetTipQuaternions(0).empty()),"Testing stub of GetTipQuaternions() ");
MITK_TEST_CONDITION_REQUIRED(!(myClaronInterface->StartTracking()),"Testing stub of StartTracking() ");
MITK_TEST_CONDITION_REQUIRED(!(myClaronInterface->StopTracking()),"Testing stub of StopTracking() ");
}
// always end with this!
MITK_TEST_END()
}
| int mitkClaronToolTest | ( | int | , |
| char * | [] | ||
| ) |
This function tests the ClaronTool class.
Definition at line 44 of file mitkClaronToolTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, and ClaronToolTestClass::New().
{
// always start with this!
MITK_TEST_BEGIN("ClaronTool")
{
// let's create an object of our class
mitk::ClaronTool::Pointer myClaronTool = ClaronToolTestClass::New().GetPointer();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myClaronTool.IsNotNull(),"Testing instantiation:")
mitk::Point3D pos;
pos[0] = 10;
pos[1] = 20;
pos[2] = 30;
myClaronTool->SetPosition(pos);
mitk::Point3D testPos;
myClaronTool->GetPosition(testPos);
MITK_TEST_CONDITION((testPos==pos),"Testing position update:")
mitk::Quaternion orientation(10,20,30,40);
myClaronTool->SetOrientation(orientation);
mitk::Quaternion testOri;
myClaronTool->GetOrientation(testOri);
MITK_TEST_CONDITION((testOri==orientation),"Testing orientation update:")
std::string name = "//testfilename";
std::string name1 = "/testfilename";
std::string name2 = "testfilename";
MITK_TEST_CONDITION(myClaronTool->LoadFile(name) == true ,"Test LoadFile() with valid windows file name")
MITK_TEST_CONDITION(myClaronTool->LoadFile(name1) == true ,"Test LoadFile() with valid Linux file name")
MITK_TEST_CONDITION(myClaronTool->LoadFile(name2) == false, "Test LoadFile() with invalid file name")
MITK_TEST_CONDITION(myClaronTool->GetCalibrationName() == name2 ,"Test GetCalibrationName() after setting with LoadFile()")
myClaronTool->SetCalibrationName(name);
MITK_TEST_CONDITION(myClaronTool->GetCalibrationName() == name ,"Test GetCalibrationName() after setting with SetCalibrationName()")
myClaronTool->LoadFile(name);
MITK_TEST_CONDITION(myClaronTool->GetFile() == name ,"Testing GetFile() after setting file name with LoadFile()")
}
// always end with this!
MITK_TEST_END()
}
| int mitkClaronTrackingDeviceTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the Class ClaronTrackingDevice. For most tests we would need the MicronTracker hardware, so only a few simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
Definition at line 125 of file mitkClaronTrackingDeviceTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_END, MITK_TEST_OUTPUT, mitkClaronTrackingDeviceTestClass::TestAllMethodsOnSystemsWithoutMicronTracker(), mitkClaronTrackingDeviceTestClass::TestInstantiation(), mitkClaronTrackingDeviceTestClass::TestIsMicronTrackerInstalled(), and mitkClaronTrackingDeviceTestClass::TestToolConfiguration().
{
MITK_TEST_BEGIN("ClaronTrackingDevice");
mitkClaronTrackingDeviceTestClass::TestInstantiation();
mitkClaronTrackingDeviceTestClass::TestToolConfiguration();
/* The following tests don't run under linux environments. This is or could be caused by the fact that the MicronTracker interface
* is developed under windows and not tested under linux yet (26.2.2009). So - in my opinion - the best approach is to first test
* the MicronTracker code under linux (and make the necessary changes of course) and in parallel write the linux tests or make this
* tests runnable under linux.
*/
#ifdef WIN32
if (mitkClaronTrackingDeviceTestClass::TestIsMicronTrackerInstalled())
{
MITK_TEST_OUTPUT(<< "... MicronTracker is installed on your System, so we don't run any further tests. (All tests run on systems without MicronTracker)");
}
else
{
MITK_TEST_OUTPUT(<< ".Test");
mitkClaronTrackingDeviceTestClass::TestAllMethodsOnSystemsWithoutMicronTracker();
}
#endif
MITK_TEST_END();
}| int mitkInternalTrackingToolTest | ( | int | , |
| char * | [] | ||
| ) |
Simple example for a test for the class "InternalTrackingTool".
argc and argv are the command line parameters which were passed to the ADD_TEST command in the CMakeLists.txt file. For the automatic tests, argv is either empty for the simple tests or contains the filename of a test image for the image tests (see CMakeLists.txt).
Definition at line 53 of file mitkInternalTrackingToolTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, and InternalTrackingToolTestClass::New().
{
// always start with this!
MITK_TEST_BEGIN("InternalTrackingTool")
// let's create an object of our class
mitk::InternalTrackingTool::Pointer internalTrackingTool = InternalTrackingToolTestClass::New().GetPointer();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(internalTrackingTool.IsNotNull(),"Testing instantiation");
// test for Enable()
internalTrackingTool->Enable();
MITK_TEST_CONDITION((internalTrackingTool->IsEnabled()==true),"Testing of Enable()");
srand(time(NULL));
// generate a random position to test Set/GetPosition()
mitk::Point3D position;
position[0] = rand()%1000;
position[1] = rand()%1000;
position[2] = rand()%1000;
internalTrackingTool->SetPosition(position);
mitk::Point3D returnedPosition;
returnedPosition.Fill(0);
internalTrackingTool->GetPosition(returnedPosition);
MITK_TEST_CONDITION((position==returnedPosition),"Testing of Set/GetPosition()");
// generate a random orientation to test Set/GetOrientation()
mitk::Quaternion orientation;
orientation[0] = (rand()%1000)/1000.0;
orientation[1] = (rand()%1000)/1000.0;
orientation[2] = (rand()%1000)/1000.0;
orientation[3] = (rand()%1000)/1000.0;
internalTrackingTool->SetOrientation(orientation);
mitk::Quaternion returnedOrientation(0,0,0,0);
internalTrackingTool->GetOrientation(returnedOrientation);
MITK_TEST_CONDITION((orientation==returnedOrientation),"Testing of Set/GetQuaternion()");
// test Set/GetTrackingError()
float trackingError = rand()%2;
internalTrackingTool->SetTrackingError(trackingError);
MITK_TEST_CONDITION((internalTrackingTool->GetTrackingError()==trackingError),"Testing of Set/GetTrackingError()");
// test Set/GetDataValid()
internalTrackingTool->SetDataValid(true);
MITK_TEST_CONDITION((internalTrackingTool->IsDataValid()==true),"Testing of SetDataValid and IsDataValid() for parameter 'true'");
internalTrackingTool->SetDataValid(false);
MITK_TEST_CONDITION((internalTrackingTool->IsDataValid()==false),"Testing of SetDataValid and IsDataValid() for parameter 'false'");
internalTrackingTool->Disable();
MITK_TEST_CONDITION((internalTrackingTool->IsEnabled()==false),"Testing of Disable()");
// write your own tests here and use the macros from mitkTestingMacros.h !!!
// do not write to std::cout and do not return from this function yourself!
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataDisplacementFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataDisplacementFilter".
Definition at line 30 of file mitkNavigationDataDisplacementFilterTest.cpp.
References mitk::NavigationData::GetOrientation(), mitk::NavigationData::GetPosition(), mitk::NavigationData::IsDataValid(), MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::Vector3DProperty::New(), mitk::PropertyList::New(), mitk::NavigationData::New(), and mitk::NavigationDataDisplacementFilter::New().
{
MITK_TEST_BEGIN("NavigationDataDisplacementFilter")
// let's create an object of our class
mitk::NavigationDataDisplacementFilter::Pointer myFilter = mitk::NavigationDataDisplacementFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 0.0, 0.0, 0.0);
mitk::NavigationData::OrientationType initialOri(0.0, 0.0, 0.0, 0.0);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "testing Set-/GetInput()");
/* create filter parameter */
mitk::Vector3D offset;
mitk::FillVector3D(offset, 1.0, 1.0, 1.0);
myFilter->SetOffset(offset);
MITK_TEST_CONDITION(myFilter->GetOffset() == offset, "testing Set-/GetOffset()");
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
output->Update(); // execute filter
MITK_TEST_CONDITION(output->GetPosition() == (initialPos + offset), "Testing offset calculation");
MITK_TEST_CONDITION(output->GetOrientation() == initialOri, "Testing if Orientation remains unchanged");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
/* now test the filter with multiple inputs */
mitk::NavigationData::PositionType initialPos2;
mitk::FillVector3D(initialPos2, -1000.0, 567.89, 0.0);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter = NULL;
myFilter = mitk::NavigationDataDisplacementFilter::New();
myFilter->SetOffset(offset);
myFilter->SetInput(0, nd1);
myFilter->SetInput(1, nd2);
MITK_TEST_CONDITION(((myFilter->GetInput(0) == nd1)
&& (myFilter->GetInput(1) == nd2)), "testing Set-/GetInput(index, data)");
output = myFilter->GetOutput(0);
mitk::NavigationData* output2 = myFilter->GetOutput(1);
output2->Update(); // execute filter pipeline. this should update both outputs!
MITK_TEST_CONDITION(((output != NULL)
&& (output2 != NULL)), "testing GetOutput(index)");
MITK_TEST_CONDITION(output->GetPosition() == (initialPos + offset), "Testing offset calculation for output 0");
MITK_TEST_CONDITION(output2->GetPosition() == (initialPos2 + offset), "Testing offset calculation for output 1");
MITK_TEST_CONDITION(output2->GetOrientation() == initialOri, "Testing if Orientation remains unchanged for output 1");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 1");
/* test if anything changes on second ->Update() */
output->Update(); // nothing should change, since inputs remain unchanged
MITK_TEST_CONDITION((output->GetPosition() == (initialPos + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after second update()");
/* change an input, see if output changes too */
mitk::NavigationData::PositionType pos2;
mitk::FillVector3D(pos2, 123.456, -234.567, 789.987);
nd1->SetPosition(pos2); // nd1 is modified, but nothing should change until pipe gets updated
MITK_TEST_CONDITION((output->GetPosition() == (initialPos + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after input change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after input change, after update()");
/* now, change filter parameter and check if pipeline updates correctly */
mitk::Vector3D offset2;
mitk::FillVector3D(offset2, -1.2, 3.45, -6.789);
myFilter->SetOffset(offset2);
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset))
&&(output2->GetPosition() == (initialPos2 + offset)), "Testing offset calculation after offset parameter change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (pos2 + offset2))
&&(output2->GetPosition() == (initialPos2 + offset2)), "Testing offset calculation after offset parameter , after update()");
/* Now test the PropertyList handling of the GetParameters() and SetParameters() methods */
mitk::PropertyList::ConstPointer p = myFilter->GetParameters();
MITK_TEST_CONDITION(p.IsNotNull(), "Testing GetParameters() has valid return type");
mitk::Vector3D v;
MITK_TEST_CONDITION(p->GetPropertyValue<mitk::Vector3D>("NavigationDataDisplacementFilter_Offset", v) == true, "PropertyList contains correct key?");
MITK_TEST_CONDITION(v == offset2, "Offset Property contains correct value?");
MITK_TEST_CONDITION(p->GetMap()->size() == 1, "PropertyList contains correct number of items?");
mitk::PropertyList::Pointer p2 = mitk::PropertyList::New();
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == offset2, "Offset unchanged on SetParameters() with empty PropertyList?");
p2->SetProperty("NavigationDataDisplacementFilter_WRONGNAME", mitk::Vector3DProperty::New(v)); // fill PropertyList with incorrect parameter
MITK_TEST_CONDITION(myFilter->GetOffset() == offset2, "Offset unchanged on SetParameters() with wrong propertyname?");
mitk::FillVector3D(v, -111.1, 0.0, 111.1);
p2->SetProperty("NavigationDataDisplacementFilter_Offset", mitk::Vector3DProperty::New(v)); // fill PropertyList with correct parameter
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == v, "Offset updated correctly by SetParameters()?");
p2 = mitk::PropertyList::New();
mitk::Vector3D v2;
mitk::FillVector3D(v2, 0.0, 111.1, 0.0);
p2->SetProperty("NavigationDataDisplacementFilter_Offset", mitk::Vector3DProperty::New(v2)); // change parameter in PropertyList
myFilter->SetParameters(p2);
MITK_TEST_CONDITION(myFilter->GetOffset() == v2, "Offset updated correctly by SetParameters()?");
//MITK_TEST_CONDITION(myFilter->GetParameters() == p2, "GetParameters() returns an equal PropertyList as the one set with SetParameters?"); // not possible, since PropertyLists don't have a == operator
v = myFilter->GetOffset();
myFilter->SetParameters(myFilter->GetParameters());
MITK_TEST_CONDITION(myFilter->GetOffset() == v, "Offset unchanged after SetParameters(GetParamters())");
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataLandmarkTransformFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataLandmarkTransformFilter".
Definition at line 29 of file mitkNavigationDataLandmarkTransformFilterTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_FOR_EXCEPTION, mitk::NavigationData::New(), mitk::PointSet::New(), mitk::NavigationDataLandmarkTransformFilter::New(), and QuadProgPP::sqrt().
{
MITK_TEST_BEGIN("NavigationDataLandmarkTransformFilter")
// let's create an object of our class
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/*create helper objects: source and target pointSets for landmark transform*/
mitk::Point3D sPoint1, sPoint2, sPoint3, tPoint1, tPoint2, tPoint3;
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 2.2, 2.2, 2.2);
mitk::FillVector3D(sPoint3, 3.3, 3.3, 3.3);
mitk::FillVector3D(tPoint1, 2.1, 2.1, 2.1);
mitk::FillVector3D(tPoint2, 3.2, 3.2, 3.2);
mitk::FillVector3D(tPoint3, 4.3, 4.3, 4.3);
mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos1,initialPos2, resultPos1,resultPos2;
mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
mitk::FillVector3D(initialPos2, 22.2,22.2, 22.2);
mitk::FillVector3D(resultPos1, 2.1, 2.1, 2.1);
mitk::FillVector3D(resultPos2, 23.2, 23.2, 23.2);
mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter->SetInput(0,nd1);
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() ND1");
mitk::NavigationData* output1 = myFilter->GetOutput(0);
MITK_TEST_CONDITION_REQUIRED(output1 != NULL, "Testing GetOutput() ND1");
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() before setting source points");
myFilter->SetSourceLandmarks(sourcePoints);
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting source points and before setting target points");
mitk::PointSet::Pointer zeroTargetPoints = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(itk::ExceptionObject, myFilter->SetTargetLandmarks(zeroTargetPoints));
MITK_TEST_CONDITION(myFilter->IsInitialized() == false, "Testing IsInitialized() after setting target pointset with insufficient points");
myFilter->SetTargetLandmarks(targetPoints);
MITK_TEST_CONDITION(myFilter->IsInitialized() == true, "Testing IsInitialized() after setting source& target points");
//------------------------landmark transform should be initialized at this point------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed");
//------------------------add another ND------------------------
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2");
mitk::NavigationData* output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2");
//------------------------update output1 but check result2------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed");
//------------------------update ND on slot 1------------------------
mitk::FillVector3D(initialPos2, 222.22, 222.22, 222.22);
mitk::FillVector3D(resultPos2, 223.22, 223.22, 223.22);
nd2->SetPosition(initialPos2);
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2 after updating value");
output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2 after updating value");
//------------------------update output2 and check result2------------------------
output2->Update();
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after updating value");
//------------------------change target PointSet------------------------
mitk::FillVector3D(tPoint1, 3.1, 3.1, 3.1);
mitk::FillVector3D(tPoint2, 4.2, 4.2, 4.2);
mitk::FillVector3D(tPoint3, 5.3, 5.3, 5.3);
mitk::FillVector3D(resultPos1, 3.1 ,3.1 ,3.1);
mitk::FillVector3D(resultPos2, 224.22, 224.22, 224.22);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetTargetLandmarks(targetPoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after targetPointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after targetPointSet changed");
//------------------------change source PointSet------------------------
mitk::FillVector3D(sPoint1, 0.1, 0.1, 0.1);
mitk::FillVector3D(sPoint2, 1.2, 1.2, 1.2);
mitk::FillVector3D(sPoint3, 2.3, 2.3, 2.3);
mitk::FillVector3D(resultPos1, 4.1 ,4.1 ,4.1);
mitk::FillVector3D(resultPos2, 225.22, 225.22, 225.22);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after sourcePointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after sourcePointSet changed");
//--------------------- Test ICP initialization --------------------------
{
mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
mitk::Point3D s1, s2, s3, s4, s5, s6;
mitk::FillVector3D(s1, 1.1, 1.1, 1.1);
mitk::FillVector3D(s2, 2.2, 2.2, 2.2);
mitk::FillVector3D(s3, 3.3, 3.3, 3.3);
mitk::FillVector3D(s4, 4.4, 4.4, 4.4);
mitk::FillVector3D(s5, 5.5, 5.5, 5.5);
mitk::FillVector3D(s6, 6.6, 6.6, 6.6);
sourcePoints->SetPoint(1, s4); // use random source point order
sourcePoints->SetPoint(2, s6);
sourcePoints->SetPoint(3, s3);
sourcePoints->SetPoint(4, s1);
sourcePoints->SetPoint(5, s2);
sourcePoints->SetPoint(6, s5);
mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
mitk::Point3D t1, t2, t3, t4, t5, t6;
mitk::FillVector3D(t1, 2.1, 2.1, 102.1); // ==> targets have offset [1, 1, 101]
mitk::FillVector3D(t2, 3.2, 3.2, 103.2);
mitk::FillVector3D(t3, 4.3, 4.3, 104.3);
mitk::FillVector3D(t4, 5.4, 5.4, 105.4);
mitk::FillVector3D(t5, 6.5, 6.5, 106.5);
mitk::FillVector3D(t6, 7.6, 7.6, 107.6);
targetPoints->SetPoint(1, t1);
targetPoints->SetPoint(2, t2);
targetPoints->SetPoint(3, t3);
targetPoints->SetPoint(4, t4);
targetPoints->SetPoint(5, t5);
targetPoints->SetPoint(6, t6);
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
myFilter->UseICPInitializationOn();
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints); // errors would raise exceptions
// prepare input
mitk::NavigationData::PositionType initialPos1, resultPos1;
mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
mitk::FillVector3D(resultPos1, 2.1, 2.1, 102.1);
mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(0, nd1);
mitk::NavigationData::Pointer output = myFilter->GetOutput(0);
output->Update();
//MITK_TEST_CONDITION(mitk::Equal(output->GetPosition(), resultPos1), "Testing ND1 position correctly transformed after ICP initialization");
}
//------------------------catch exception --> source points < 3------------------------
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter2 = mitk::NavigationDataLandmarkTransformFilter::New();
MITK_TEST_CONDITION_REQUIRED(myFilter2.IsNotNull(),"Testing instantiation for second filter");
mitk::PointSet::Pointer sourcePoints2 = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(std::exception, myFilter2->SetSourceLandmarks(sourcePoints2););
//------------------------catch exception --> target points < 3------------------------
mitk::NavigationDataLandmarkTransformFilter::Pointer myFilter3 = mitk::NavigationDataLandmarkTransformFilter::New();
MITK_TEST_CONDITION_REQUIRED(myFilter3.IsNotNull(),"Testing instantiation for second filter");
mitk::PointSet::Pointer targetPoints2 = mitk::PointSet::New();
MITK_TEST_FOR_EXCEPTION(std::exception, myFilter3->SetTargetLandmarks(targetPoints2););
//------------------------rotate orientation------------------------
myFilter=NULL;
myFilter = mitk::NavigationDataLandmarkTransformFilter::New();
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 1.1, -1.1, 1.1);
mitk::FillVector3D(sPoint3, -1.1, -1.1, 1.1);
mitk::FillVector3D(tPoint1, -1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint2, 1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint3, 1.1, -1.1, 1.1);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints);
//set initial orientation (x y z r)
mitk::NavigationData::OrientationType initialQuat(0.0, 0.0, 0.0, 1.0);
mitk::NavigationData::OrientationType resultQuat(0.0, 0.0, -0.7071, -0.7071);
//set position
mitk::FillVector3D(initialPos1, 2.2, 2.2, 2.2);
mitk::FillVector3D(resultPos1, -2.2, 2.2, 2.2);
nd1->SetOrientation(initialQuat);
nd1->SetPosition(initialPos1);
myFilter->SetInput(0,nd1);
output1 = myFilter->GetOutput(0);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed ");
MITK_TEST_CONDITION(
mitk::Equal(output1->GetOrientation(), resultQuat),
"Testing ND1 orientation correctly transformed ");
//------------------------test FRE calculation------------------------
mitk::PointSet::Pointer refSet = mitk::PointSet::New();
mitk::PointSet::Pointer movSet = mitk::PointSet::New();
mitk::Point3D refPoint;
mitk::Point3D movPoint;
//Point 0
refPoint.Fill(0); refSet->SetPoint(0, refPoint);
movPoint.Fill(1); movSet->SetPoint(0, movPoint);
//Point 1
refPoint[0]=3; refPoint[1]=0; refPoint[2]=0; refSet->SetPoint(1, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=1; movSet->SetPoint(1, movPoint);
//Point 2
refPoint[0]=0; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(2, refPoint);
movPoint[0]=1; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(2, movPoint);
//Point 3
refPoint[0]=3; refPoint[1]=0; refPoint[2]=3; refSet->SetPoint(3, refPoint);
movPoint[0]=2; movPoint[1]=1; movPoint[2]=2; movSet->SetPoint(3, movPoint);
//Point 4
refPoint[0]=0; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(4, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(4, movPoint);
//Point 5
refPoint[0]=3; refPoint[1]=3; refPoint[2]=0; refSet->SetPoint(5, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=1; movSet->SetPoint(5, movPoint);
//Point 6
refPoint[0]=0; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(6, refPoint);
movPoint[0]=1; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(6, movPoint);
//Point 7
refPoint[0]=3; refPoint[1]=3; refPoint[2]=3; refSet->SetPoint(7, refPoint);
movPoint[0]=2; movPoint[1]=2; movPoint[2]=2; movSet->SetPoint(7, movPoint);
mitk::NavigationDataLandmarkTransformFilter::Pointer myFREFilter = mitk::NavigationDataLandmarkTransformFilter::New();
myFREFilter->SetSourceLandmarks(refSet);
myFREFilter->SetTargetLandmarks(movSet);
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetFRE() == (float) sqrt(3.0),"Testing mean error calculation")
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMaxError() == (float) sqrt(3.0),"Testing mean error calculation")
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetMinError() == (float) sqrt(3.0),"Testing mean error calculation")
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetRMSError() == (float) sqrt(3.0),"Testing mean error calculation")
MITK_TEST_CONDITION_REQUIRED(myFREFilter->GetFREStdDev() == (float) 0.0,"Testing mean error calculation")
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataObjectVisualizationFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataObjectVisualizationFilter".
Definition at line 32 of file mitkNavigationDataObjectVisualizationFilterTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_OUTPUT, mitk::Surface::New(), mitk::NavigationData::New(), and mitk::NavigationDataObjectVisualizationFilter::New().
{
MITK_TEST_BEGIN("NavigationDataObjectVisualizationFilter")
// let's create an object of our class
mitk::NavigationDataObjectVisualizationFilter::Pointer myFilter = mitk::NavigationDataObjectVisualizationFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos1, initialPos2;
mitk::FillVector3D(initialPos1, 1.1, 2.2, 3.3);
mitk::FillVector3D(initialPos2, 5.0, 6.0, 7.0);
mitk::NavigationData::OrientationType initialOri1(0.1, 0.2, 0.3, 0.4);
mitk::NavigationData::OrientationType initialOri2(0.5, 0.6, 0.7, 0.8);
mitk::ScalarType initialError1(0.0);
mitk::ScalarType initialError2(5.0);
bool initialValid1(true);
bool initialValid2(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri1);
nd1->SetPositionAccuracy(initialError1);
nd1->SetDataValid(initialValid1);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri2);
nd2->SetPositionAccuracy(initialError2);
nd2->SetDataValid(initialValid2);
myFilter->SetInput(nd1);
myFilter->SetInput(1, nd2);
//testing the input
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "Testing Set-/GetInput() input 1 without index");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() input 1");
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() input 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 0, "Testing GetNumberOfToolRepresentations()");
//testing getting the output
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
MITK_TEST_CONDITION_REQUIRED(output == myFilter->GetOutput(0), "Testing GetOutput() == GetOutput(0)");
MITK_TEST_CONDITION_REQUIRED(output != myFilter->GetOutput(1), "Testing GetOutput() != GetOutput(1)");
// Test setting BaseData
mitk::Surface::Pointer mitkToolData1 = mitk::Surface::New();
mitk::Surface::Pointer mitkToolData2 = mitk::Surface::New();
//dummy for test; will not be set but used to test find
mitk::Surface::Pointer mitkToolDataDummy = mitk::Surface::New();
//and the Dummy NavigationData for this
mitk::NavigationData::PositionType initialPosDummy;
mitk::FillVector3D(initialPosDummy, 8.8, 9.9, 10.10);
mitk::NavigationData::OrientationType initialOriDummy(1.1, 2.2, 3.3, 4.4);
mitk::ScalarType initialErrorDummy(10.0);
bool initialValidDummy(true);
mitk::NavigationData::Pointer ndDummy = mitk::NavigationData::New();
ndDummy->SetPosition(initialPosDummy);
ndDummy->SetOrientation(initialOriDummy);
ndDummy->SetPositionAccuracy(initialErrorDummy);
ndDummy->SetDataValid(initialValidDummy);
//now we have ndDummy and mitkToolDataDummy to test with
//setting nodes
myFilter->SetRepresentationObject(0, mitkToolData1);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData1, "Testing SetRepresentationObject()/GetRepresentationObject() node 1");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 1, "Testing GetNumberOfToolRepresentations() after adding first tool");
myFilter->SetRepresentationObject(1, mitkToolData2);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData2, "Testing SetRepresentationObject() node 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() after adding second tool");
//getting nodes
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData1, "Testing GetRepresentationObject() node 1");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData2, "Testing GetRepresentationObject() node 2");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(111) == NULL, "Testing GetRepresentationObject() with out of range parameter");
//Process
myFilter->Update();
//now check it there are data connected to the nodes with the according orientation and offsets
mitk::AffineTransform3D::Pointer affineTransform1 = mitkToolData1->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offset1 = affineTransform1->GetOffset();
MITK_TEST_CONDITION(offset1.Get_vnl_vector()==initialPos1.Get_vnl_vector(), "Testing Offset position 1");
mitk::AffineTransform3D::Pointer affineTransform2 = mitkToolData2->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offset2 = affineTransform2->GetOffset();
MITK_TEST_CONDITION(offset2.Get_vnl_vector()==initialPos2.Get_vnl_vector(), "Testing Offset position 2");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1 = affineTransform1->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n initOrient1="<<initialOri1<<" affineTransform1->GetVnlMatrix():\n "<< m1);
mitk::AffineTransform3D::MatrixType::InternalMatrixType m2 = affineTransform2->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n initOrient2=" << initialOri2 << " affineTransform2->GetVnlMatrix():\n " << m2);
//messing with SetRepresentationObject
//setting nodes
myFilter->SetRepresentationObject(0, mitkToolData2);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData2, "Twisting mitkToolData by using SetRepresentationObject() NavigationData 1 with ToolData 2");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() == 1");
myFilter->SetRepresentationObject(1, mitkToolData1);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData1, "Twisting mitkToolData by using SetRepresentationObject() NavigationData 2 with ToolData 1");
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 2, "Testing GetNumberOfToolRepresentations() == 2");
//getting nodes
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == mitkToolData2, "Testing switched BaseData of NavigationData 1 ");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) == mitkToolData1, "Testing switched BaseData NavigationData 2");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(1) != mitkToolDataDummy, "Testing GetRepresentationObject() != Dummy node");
//processing update through pipeline
myFilter->Update();
//now check it there are data connected to the nodes with the according orientation and offsets
mitk::AffineTransform3D::Pointer affineTransform1Second = mitkToolData1->GetGeometry()->GetIndexToWorldTransform();
MITK_TEST_CONDITION(affineTransform1 == affineTransform1Second, "Testing affineTransform1 after second update");
mitk::AffineTransform3D::OutputVectorType offset1Second = affineTransform1->GetOffset();
MITK_TEST_CONDITION(offset1 == offset1Second, "Testing offset1 after second update");
MITK_TEST_CONDITION(offset1Second.Get_vnl_vector()==offset1.Get_vnl_vector(), "Testing offset1 equals first update");
mitk::AffineTransform3D::Pointer affineTransform2Second = mitkToolData2->GetGeometry()->GetIndexToWorldTransform();
MITK_TEST_CONDITION(affineTransform2 == affineTransform2Second, "Testing affineTransform2 after second update");
mitk::AffineTransform3D::OutputVectorType offset2Second = affineTransform2->GetOffset();
MITK_TEST_CONDITION(offset2 == offset2Second, "Testing offset2 after second update");
MITK_TEST_CONDITION(offset2Second.Get_vnl_vector()==offset2.Get_vnl_vector(), "Testing offset2 equals first update");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1Second= affineTransform1Second->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( <<"\n after second update initOrient1="<<initialOri1<<" affineTransform1->GetVnlMatrix():\n "<< m1Second);
mitk::AffineTransform3D::MatrixType::InternalMatrixType m2Second= affineTransform2Second->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n after second update initOrient2="<<initialOri2<<" affineTransform2->GetVnlMatrix():\n "<< m2Second);
//testing adding a third input
myFilter->SetInput(2,ndDummy);
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 3, "Adding new input and testing GetNumberOfInputs == 3");
MITK_TEST_CONDITION(myFilter->GetNumberOfOutputs() == 3, "testing GetNumberOfOutputs == 3");
MITK_TEST_CONDITION(myFilter->GetInput(2) == ndDummy, "Testing Input == newly added input");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOutput(2) != NULL, "Testing GetOutput(2) != NULL");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOutput(2) != myFilter->GetOutput(1), "Testing GetOutput(2) != GetOutput(1)");
myFilter->SetRepresentationObject(2, mitkToolDataDummy);
MITK_TEST_CONDITION(myFilter->GetNumberOfToolRepresentations() == 3, "Testing GetNumberOfToolRepresentations() after adding latest tool");
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(2) == mitkToolDataDummy, "Testing Set-/GetRepresentationObject() equals was set");
//last time processing update through pipeline
myFilter->Update();
//now check for the new values
mitk::AffineTransform3D::Pointer affineTransformDummy = mitkToolDataDummy->GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::OutputVectorType offsetDummy = affineTransformDummy->GetOffset();
MITK_TEST_CONDITION(offsetDummy.Get_vnl_vector()==initialPosDummy.Get_vnl_vector(), "Testing Offset latest added tool");
mitk::AffineTransform3D::MatrixType::InternalMatrixType m1Latest= affineTransformDummy->GetMatrix().GetVnlMatrix();
MITK_TEST_OUTPUT( << "\n latest initOrient="<<initialOriDummy<<" latest affineTransform->GetVnlMatrix():\n "<< m1Latest);
mitk::Surface::Pointer anotherSurface = mitk::Surface::New();
myFilter->SetRepresentationObject(0, anotherSurface);
MITK_TEST_CONDITION(myFilter->GetRepresentationObject(0) == anotherSurface, "Overwriting BaseData index 0");
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataRecorderTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataRecorder".
Definition at line 29 of file mitkNavigationDataRecorderTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::NavigationData::New(), and mitk::NavigationDataRecorder::New().
{
MITK_TEST_BEGIN("NavigationDataRecorder");
std::string tmp = "";
std::ostringstream* stream = new std::ostringstream( std::ostringstream::trunc );
stream->setf( std::ios::fixed, std::ios::floatfield );
// let's create an object of our class
mitk::NavigationDataRecorder::Pointer recorder = mitk::NavigationDataRecorder::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(recorder.IsNotNull(), "Testing instantiation");
MITK_TEST_CONDITION(recorder->GetInputs().size() == 0, "testing initial number of inputs");
MITK_TEST_CONDITION(recorder->GetOutputs().size() == 0, "testing initial number of outputs");
mitk::NavigationData::Pointer naviData = mitk::NavigationData::New();
recorder->AddNavigationData( naviData );
//recorder->SetFileName("e:/test");
//recorder->SetRecordingMode( mitk::NavigationDataRecorder::NormalFile );
recorder->StartRecording( stream );
for ( unsigned int i=0; i<5; i++ )
{
mitk::Point3D pnt;
pnt[0] = i + 1;
pnt[1] = i + 1/2;
pnt[2] = i +1*3;
naviData->SetPosition(pnt);
//naviData->Modified();
recorder->Update();
//Sleep(80 + i*10);
}
recorder->StopRecording();
std::string str = stream->str();
int pos = str.find( "ToolCount=" );
std::string sub = stream->str().substr(pos+11, 1);
MITK_TEST_CONDITION( sub.compare("1") == 0, "check if number of inputs is correct by stringstream");
pos = str.find( "X=" );
sub = stream->str().substr(pos+3, 1);
MITK_TEST_CONDITION( sub.compare("1") == 0, "check if the X coordinate is correct");
pos = str.find( "Y=" );
sub = stream->str().substr(pos+3, 1);
MITK_TEST_CONDITION( sub.compare("0") == 0, "check if the Y coordinate is correct");
pos = str.find( "Z=" );
sub = stream->str().substr(pos+3, 1);
MITK_TEST_CONDITION( sub.compare("3") == 0, "check if the Z coordinate is correct");
recorder->SetFileName("blablabla");
const char* string = recorder->GetFileName();
MITK_TEST_CONDITION( strcmp(string, "blablabla") == 0, "check if set- and getName-methods work");
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataReferenceTransformFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataReferenceTransformFilter".
Definition at line 29 of file mitkNavigationDataReferenceTransformFilterTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::PointSet::New(), mitk::NavigationData::New(), and mitk::NavigationDataReferenceTransformFilter::New().
{
MITK_TEST_BEGIN("NavigationDataReferenceTransformFilter")
// let's create an object of our class
mitk::NavigationDataReferenceTransformFilter::Pointer myFilter = mitk::NavigationDataReferenceTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/*create helper objects: positions of the input sources*/
mitk::NavigationData::PositionType initialPos1,initialPos2, initialPos3, initialPos4;
mitk::FillVector3D(initialPos1, 11.1, 11.1, 11.1);
mitk::FillVector3D(initialPos2, 22.2, 22.2, 22.2);
mitk::FillVector3D(initialPos3, 33.3, 33.3, 33.3);
mitk::FillVector3D(initialPos4, 44.4, 44.4, 44.4);
/*create helper objects: orientations of the input sources*/
mitk::NavigationData::OrientationType initialOri1(0.1, 0.1, 0.1, 0.1);
mitk::NavigationData::OrientationType initialOri2(0.2, 0.2, 0.2, 0.2);
mitk::NavigationData::OrientationType initialOri3(0.3, 0.3, 0.3, 0.3);
mitk::NavigationData::OrientationType initialOri4(0.4, 0.4, 0.4, 0.4);
/*create helper objects: ND position accurancy and validity bool*/
mitk::ScalarType initialError(0.0);
bool initialValid(true);
/*create helper objects: NDs for the inputs*/
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri1);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri2);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer nd3 = mitk::NavigationData::New();
nd3->SetPosition(initialPos3);
nd3->SetOrientation(initialOri3);
nd3->SetPositionAccuracy(initialError);
nd3->SetDataValid(initialValid);
mitk::NavigationData::Pointer nd4 = mitk::NavigationData::New();
nd4->SetPosition(initialPos4);
nd4->SetOrientation(initialOri4);
nd4->SetPositionAccuracy(initialError);
nd4->SetDataValid(initialValid);
/* testing input setter */
myFilter->SetInput(0,nd1);
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd1, "Testing Set-/GetInput() ND1");
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND1");
myFilter->SetInput(2,nd3);
MITK_TEST_CONDITION(myFilter->GetInput(2) == nd3, "Testing Set-/GetInput() ND1");
myFilter->SetInput(3,nd4);
MITK_TEST_CONDITION(myFilter->GetInput(3) == nd4, "Testing Set-/GetInput() ND1");
/* testing output getter */
mitk::NavigationData* output1 = myFilter->GetOutput(0);
MITK_TEST_CONDITION_REQUIRED(output1 != NULL, "Testing GetOutput() ND1");
mitk::NavigationData* output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2");
mitk::NavigationData* output3 = myFilter->GetOutput(2);
MITK_TEST_CONDITION_REQUIRED(output3 != NULL, "Testing GetOutput() ND3");
mitk::NavigationData* output4 = myFilter->GetOutput(3);
MITK_TEST_CONDITION_REQUIRED(output4 != NULL, "Testing GetOutput() ND4");
/* testing IsInitialized() before setting/generating any points */
MITK_TEST_CONDITION_REQUIRED(myFilter->IsInitialized() == false, "Testing IsInitialized() before setting source points");
/* trying to generate source landmarks with empty referenceID vector */
myFilter->GenerateSourceLandmarks();
/* create helper objects: reference input IDs vector */
std::vector<int>* refIDs = new std::vector<int>();
int refInpt = 0;
refIDs->push_back(refInpt);
myFilter->SetReferenceInputIndexes(refIDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOneSourceRegistration() == true,"Testing switch from OneSourceRegistration false to true" );
MITK_TEST_CONDITION(myFilter->GetReferenceInputIndexes().at(0) == refInpt, "Testing single value of ReferenceInputIndexes");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetReferenceInputIndexes().size()==1, "Testing size of ReferenceInputIndexes");
myFilter->GenerateSourceLandmarks();
MITK_TEST_CONDITION(myFilter->GetSourcePoints().size()==3 && myFilter->GetTargetPoints().size()==0, "Testing different SourcePoints and TargePoints sizes");
/* testing IsInitialized() before setting target points */
MITK_TEST_CONDITION_REQUIRED(myFilter->IsInitialized() == false, "Testing IsInitialized() before setting target points");
myFilter->GenerateTargetLandmarks();
/* testing IsInitialized() after source and target points are set */
MITK_TEST_CONDITION_REQUIRED(myFilter->IsInitialized() == true, "Testing IsInitialized() after target and source points are set");
mitk::NavigationData::PositionType spos1 = myFilter->GetSourcePoints().at(0);
mitk::NavigationData::PositionType spos2 = myFilter->GetSourcePoints().at(1);
mitk::NavigationData::PositionType spos3 = myFilter->GetSourcePoints().at(2);
mitk::NavigationData::PositionType::RealType distance1 = spos1.EuclideanDistanceTo(spos2);
mitk::NavigationData::PositionType::RealType distance2 = spos1.EuclideanDistanceTo(spos3);
MITK_TEST_CONDITION(mitk::Equal(distance1, distance2), "Testing distance between landmark Point and virtual landmark Points");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetReferencePoints().size() == 0, "Testing ReferencePoints size before initialization");
MITK_TEST_CONDITION_REQUIRED(myFilter->InitializeReferenceLandmarks() == true, "Testing performing InitializeReferenceLandmarks()");
MITK_TEST_CONDITION_REQUIRED(myFilter->GetReferencePoints().size() == myFilter->GetSourcePoints().size(), "Testing ReferencePoints size after initialization");
mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType::Pointer quatTransform = mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType::New();
mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType::Pointer inverseQuatTransform = mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType::New();
mitk::NavigationDataReferenceTransformFilter::QuaternionTransformType::VnlQuaternionType doubleOrientation(initialOri1.x(), initialOri1.y(),initialOri1.z(),initialOri1.r());
quatTransform->SetRotation(doubleOrientation);
quatTransform->SetOffset(initialPos1.GetVectorFromOrigin());
quatTransform->Modified();
quatTransform->GetInverse(inverseQuatTransform);
for(unsigned int i = 0; i < myFilter->GetReferencePoints().size(); ++i)
{
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(myFilter->GetReferencePoints().at(i), inverseQuatTransform->TransformPoint(myFilter->GetSourcePoints().at(i))), "Testing inverse quaternion transform of SourcePoints");
}
/* create helper object: moved reference input ND */
mitk::NavigationData::PositionType newPos1;
mitk::FillVector3D(newPos1, 1.1, -16.1, 21.1);
mitk::NavigationData::OrientationType newOrientation(0.1, 0.2, 0.3, 0.4);
mitk::NavigationData::Pointer newnd1 = mitk::NavigationData::New();
newnd1->SetPosition(newPos1);
newnd1->SetOrientation(newOrientation);
newnd1->SetPositionAccuracy(initialError);
newnd1->SetDataValid(initialValid);
doubleOrientation[0] = newOrientation.x();
doubleOrientation[1] = newOrientation.y();
doubleOrientation[2] = newOrientation.z();
doubleOrientation[3] = newOrientation.r();
quatTransform->SetRotation(doubleOrientation);
quatTransform->SetOffset(newPos1.GetVectorFromOrigin());
quatTransform->Modified();
myFilter->SetInput(0,newnd1);
output1->Update();
for(unsigned int i = 0; i < myFilter->GetReferencePoints().size(); ++i)
{
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(quatTransform->TransformPoint(myFilter->GetReferencePoints().at(i)), myFilter->GetSourcePoints().at(i)), "Testing quaternion transform of ReferencePoints ") ;
}
// testing landmark point generation with 3 reference inputs */
/* filling reference input IDs vector */
refIDs->clear();
refIDs->push_back(0);
refIDs->push_back(1);
refIDs->push_back(2);
myFilter->SetReferenceInputIndexes(refIDs);
bool oneSourceReg = myFilter->GetOneSourceRegistration();
bool refReg = myFilter->GetReferenceRegistration();
MITK_TEST_CONDITION_REQUIRED(oneSourceReg == false && refReg == true,"Testing reference registration bool flags after switching from one reference input to three reference inputs" );
MITK_TEST_CONDITION_REQUIRED(myFilter->GetReferenceInputIndexes().size()==3, "Testing size of ReferenceInputIndexes");
myFilter->GenerateSourceLandmarks();
myFilter->GenerateTargetLandmarks();
MITK_TEST_CONDITION_REQUIRED(myFilter->IsInitialized() == true, "Testing IsInitialized() 3 after reference input source and target points are set");
mitk::Point3D sPoint1, sPoint2, sPoint3, tPoint1, tPoint2, tPoint3;
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 2.2, 2.2, 2.2);
mitk::FillVector3D(sPoint3, 3.3, 3.3, 3.3);
mitk::FillVector3D(tPoint1, 2.1, 2.1, 2.1);
mitk::FillVector3D(tPoint2, 3.2, 3.2, 3.2);
mitk::FillVector3D(tPoint3, 4.3, 4.3, 4.3);
mitk::PointSet::Pointer sourcePoints = mitk::PointSet::New();
mitk::PointSet::Pointer targetPoints = mitk::PointSet::New();
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType resultPos1, resultPos2;
mitk::FillVector3D(initialPos1, 1.1, 1.1, 1.1);
mitk::FillVector3D(initialPos2, 22.2,22.2, 22.2);
mitk::FillVector3D(resultPos1, 2.1, 2.1, 2.1);
mitk::FillVector3D(resultPos2, 23.2, 23.2, 23.2);
mitk::NavigationData::OrientationType initialOri(0.1, 0.1, 0.1, 0.1);
nd1->SetPosition(initialPos1);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter->SetInput(0,nd1);
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetOneSourceRegistration() == false,"Testing switch from OneSourceRegistration true to false" );
//------------------------landmark transform should be initialized at this point------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed");
//------------------------add another ND------------------------
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2");
output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2");
//------------------------update output1 but check result2------------------------
output1->Update();
MITK_TEST_CONDITION_REQUIRED(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed");
//------------------------update ND on slot 1------------------------
mitk::FillVector3D(initialPos2, 222.22, 222.22, 222.22);
mitk::FillVector3D(resultPos2, 223.22, 223.22, 223.22);
nd2->SetPosition(initialPos2);
myFilter->SetInput(1,nd2);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd2, "Testing Set-/GetInput() ND2 after updating value");
output2 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput() ND2 after updating value");
//------------------------update output2 and check result2------------------------
output2->Update();
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after updating value");
//------------------------change target PointSet------------------------
mitk::FillVector3D(tPoint1, 3.1, 3.1, 3.1);
mitk::FillVector3D(tPoint2, 4.2, 4.2, 4.2);
mitk::FillVector3D(tPoint3, 5.3, 5.3, 5.3);
mitk::FillVector3D(resultPos1, 3.1 ,3.1 ,3.1);
mitk::FillVector3D(resultPos2, 224.22, 224.22, 224.22);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetTargetLandmarks(targetPoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after targetPointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after targetPointSet changed");
//------------------------change source PointSet------------------------
mitk::FillVector3D(sPoint1, 0.1, 0.1, 0.1);
mitk::FillVector3D(sPoint2, 1.2, 1.2, 1.2);
mitk::FillVector3D(sPoint3, 2.3, 2.3, 2.3);
mitk::FillVector3D(resultPos1, 4.1 ,4.1 ,4.1);
mitk::FillVector3D(resultPos2, 225.22, 225.22, 225.22);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed after sourcePointSet changed");
MITK_TEST_CONDITION(
mitk::Equal(output2->GetPosition(), resultPos2),
"Testing ND2 position correctly transformed after sourcePointSet changed");
//------------------------rotate orientation------------------------
myFilter=NULL;
myFilter = mitk::NavigationDataReferenceTransformFilter::New();
mitk::FillVector3D(sPoint1, 1.1, 1.1, 1.1);
mitk::FillVector3D(sPoint2, 1.1, -1.1, 1.1);
mitk::FillVector3D(sPoint3, -1.1, -1.1, 1.1);
mitk::FillVector3D(tPoint1, -1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint2, 1.1, 1.1, 1.1);
mitk::FillVector3D(tPoint3, 1.1, -1.1, 1.1);
sourcePoints->SetPoint(0,sPoint1);
sourcePoints->SetPoint(1,sPoint2);
sourcePoints->SetPoint(2,sPoint3);
targetPoints->SetPoint(0,tPoint1);
targetPoints->SetPoint(1,tPoint2);
targetPoints->SetPoint(2,tPoint3);
myFilter->SetSourceLandmarks(sourcePoints);
myFilter->SetTargetLandmarks(targetPoints);
//set initial orientation (x y z r)
mitk::NavigationData::OrientationType initialQuat(0.0, 0.0, 0.0, 1.0);
mitk::NavigationData::OrientationType resultQuat(0.0, 0.0, -0.7071, -0.7071);
//set position
mitk::FillVector3D(initialPos1, 2.2, 2.2, 2.2);
mitk::FillVector3D(resultPos1, -2.2, 2.2, 2.2);
nd1->SetOrientation(initialQuat);
nd1->SetPosition(initialPos1);
myFilter->SetInput(0,nd1);
output1 = myFilter->GetOutput(0);
output1->Update();
MITK_TEST_CONDITION(
mitk::Equal(output1->GetPosition(), resultPos1),
"Testing ND1 position correctly transformed ");
MITK_TEST_CONDITION(
mitk::Equal(output1->GetOrientation(), resultQuat),
"Testing ND1 orientation correctly transformed ");
delete refIDs;
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataSequentialPlayerTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataRecorder".
Definition at line 83 of file mitkNavigationDataSequentialPlayerTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, player(), qTool0Snapshot0, qTool1Snapshot1, runLoop(), tTool0Snapshot1(), tTool1Snapshot2(), and XML_STRING.
{
MITK_TEST_BEGIN("NavigationDataSequentialPlayer");
// create test values valid for the xml data above
tTool0Snapshot1[0] = -336.65;
tTool0Snapshot1[1] = 138.5;
tTool0Snapshot1[2]= -2061.07;
tTool1Snapshot2[0] = -56.93;
tTool1Snapshot2[1] = 233.79;
tTool1Snapshot2[2]= -2042.6;
vnl_vector_fixed<mitk::ScalarType,4> qVec;
qVec[0] = 0.0085;
qVec[1] = -0.0576;
qVec[2]= -0.0022;
qVec[3]= 0.9982;
qTool0Snapshot0 = mitk::Quaternion(qVec);
qVec[0] = 0.4683;
qVec[1] = 0.0188;
qVec[2]= -0.8805;
qVec[3]= 0.0696;
qTool1Snapshot1 = mitk::Quaternion(qVec);
player
->SetXMLString(XML_STRING);
MITK_TEST_CONDITION_REQUIRED(player->GetNumberOfSnapshots() == 3,
"player->GetNumberOfSnapshots() == 3");
player
->SetRepeat(true);
runLoop();
// repeat is on should work a second time
runLoop();
// now test the go to snapshot function
player->GoToSnapshot(3);
mitk::NavigationData::Pointer nd1 = player->GetOutput(1);
MITK_TEST_CONDITION(tTool1Snapshot2 == nd1->GetPosition().GetVnlVector(),
"tTool1Snapshot2 == nd1->GetPosition().GetVnlVector()");
player->GoToSnapshot(1);
mitk::NavigationData::Pointer nd0 = player->GetOutput(0);
MITK_TEST_CONDITION(qTool0Snapshot0.as_vector() == nd0->GetOrientation().as_vector(),
"qTool0Snapshot0.as_vector() == nd0->GetOrientation().as_vector()");
player->GoToSnapshot(3);
// and a third time
runLoop();
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the Class mitk::NavigationData. For most tests we would need the MicronTracker hardware, so only a few simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
Definition at line 32 of file mitkNavigationDataTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_END, and mitk::NavigationData::New().
{
MITK_TEST_BEGIN("NavigationData");
// Test instantiation of NavigationData
mitk::NavigationData::Pointer nd = mitk::NavigationData::New();
MITK_TEST_CONDITION(nd.IsNotNull(),"Test instatiation");
mitk::NavigationData::PositionType p;
mitk::FillVector3D(p, 44.4, 55.5, 66.66);
nd->SetPosition(p);
MITK_TEST_CONDITION(nd->GetPosition() == p, "Set-/GetPosition()");
mitk::NavigationData::OrientationType o(1.0, 2.0, 3.0, 4.0);
nd->SetOrientation(o);
MITK_TEST_CONDITION(nd->GetOrientation() == o, "Set-/GetOrientation()");
nd->SetDataValid(true);
MITK_TEST_CONDITION(nd->IsDataValid() == true, "Set-/IsDataValid()");
nd->SetTimeStamp(100.111);
MITK_TEST_CONDITION(mitk::Equal(nd->GetTimeStamp(), 100.111), "Set-/GetTimeStamp()");
nd->SetHasPosition(false);
MITK_TEST_CONDITION(nd->GetHasPosition() == false, "Set-/GetHasPosition()");
nd->SetHasOrientation(false);
MITK_TEST_CONDITION(nd->GetHasOrientation() == false, "Set-/GetHasOrientation()");
mitk::NavigationData::CovarianceMatrixType m;
m.Fill(17.17);
m(2, 2) = 1000.01;
nd->SetCovErrorMatrix(m);
MITK_TEST_CONDITION(nd->GetCovErrorMatrix() == m, "Set-/GetCovErrorMatrix()");
nd->SetName("my NavigationData");
MITK_TEST_CONDITION(std::string(nd->GetName()) == "my NavigationData", "Set-/GetName()");
nd->SetPositionAccuracy(100.0);
mitk::NavigationData::CovarianceMatrixType result = nd->GetCovErrorMatrix();
MITK_TEST_CONDITION(mitk::Equal(result(0, 0), 10000.0)
&& mitk::Equal(result(1, 1), 10000.0)
&& mitk::Equal(result(2, 2), 10000.0), "SetPositionAccuracy()");
nd->SetOrientationAccuracy(10.0);
mitk::NavigationData::CovarianceMatrixType result2 = nd->GetCovErrorMatrix();
MITK_TEST_CONDITION(mitk::Equal(result2(3, 3), 100.0)
&& mitk::Equal(result2(4, 4), 100.0)
&& mitk::Equal(result2(5, 5), 100.0), "SetOrientationAccuracy()");
mitk::NavigationData::Pointer graftedCopy = mitk::NavigationData::New();
graftedCopy->Graft(nd);
bool graftIsEqual = (nd->GetPosition() == graftedCopy->GetPosition())
&& (nd->GetOrientation() == graftedCopy->GetOrientation())
&& (nd->IsDataValid() == graftedCopy->IsDataValid())
&& mitk::Equal(nd->GetTimeStamp(), graftedCopy->GetTimeStamp())
&& (nd->GetHasPosition() == graftedCopy->GetHasPosition())
&& (nd->GetHasOrientation() == graftedCopy->GetHasOrientation())
&& (nd->GetCovErrorMatrix() == graftedCopy->GetCovErrorMatrix())
&& (std::string(nd->GetName()) == graftedCopy->GetName());
MITK_TEST_CONDITION(graftIsEqual, "Graft() produces equal NavigationData object");
MITK_TEST_END();
}
| int mitkNavigationDataToMessageFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataToMessageFilter".
Definition at line 78 of file mitkNavigationDataToMessageFilterTest.cpp.
References MessageReceiverClass::m_MessagesReceived, MessageReceiverClass::m_ReceivedData, MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_OUTPUT, mitk::NavigationData::New(), mitk::NavigationDataToMessageFilter::New(), MessageReceiverClass::OnDataValidChanged(), MessageReceiverClass::OnErrorChanged(), MessageReceiverClass::OnOrientationChanged(), MessageReceiverClass::OnPositionChanged(), and MessageReceiverClass::OnTimeStampChanged().
{
MITK_TEST_BEGIN("NavigationDataToMessageFilter");
/* first tests with one input */
{
// let's create an object of our class
mitk::NavigationDataToMessageFilter::Pointer myFilter = mitk::NavigationDataToMessageFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(1.0, 2.0, 3.0, 4.0);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(11.111);
nd1->SetTimeStamp(64.46);
nd1->SetDataValid(true);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "testing Set-/GetInput()");
mitk::NavigationData* output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
/* register message receiver */
MessageReceiverClass answers(1);
myFilter->AddPositionChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::PositionType, unsigned int>(&answers, &MessageReceiverClass::OnPositionChanged));
myFilter->AddOrientationChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::OrientationType, unsigned int>(&answers, &MessageReceiverClass::OnOrientationChanged));
myFilter->AddErrorChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::CovarianceMatrixType, unsigned int>(&answers, &MessageReceiverClass::OnErrorChanged));
myFilter->AddTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
myFilter->AddDataValidChangedListener(mitk::MessageDelegate2<MessageReceiverClass, bool, unsigned int>(&answers, &MessageReceiverClass::OnDataValidChanged));
output->Update(); // execute filter
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetOrientation(), nd1->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->GetCovErrorMatrix() == nd1->GetCovErrorMatrix(), "Testing ErrorChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 5, "Correct number of messages send?");
/* change one input parameter */
nd1->SetDataValid(false);
output->Update(); // re-execute filter
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 6, "only necessary messages send?"); // only datavalid message re-send
/* changing two input parameters */
mitk::FillVector3D(initialPos, 11.0, 21.0, 31.0);
nd1->SetPosition(initialPos); // change only one parameter
nd1->SetTimeStamp(55.55); // change only one parameter
output->Update(); // re-execute filter
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 8, "only necessary messages send?"); // only 2 new messages send
/* try to add a second input */
//MITK_TEST_OUTPUT_NO_ENDL( << "Exception on adding second input? --> ");
//mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
//MITK_TEST_FOR_EXCEPTION(std::invalid_argument, myFilter->SetInput(1, nd2));
}
/* now test with multiple inputs */
{
MITK_TEST_OUTPUT( << "Now, perform tests with multiple inputs");
mitk::NavigationDataToMessageFilter::Pointer myFilter = mitk::NavigationDataToMessageFilter::New();
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 1.0, 1.0);
mitk::NavigationData::OrientationType initialOri(1.0, 1.0, 1.0, 1.0);
mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
nd0->SetPosition(initialPos);
nd0->SetOrientation(initialOri);
nd0->SetPositionAccuracy(11.111);
nd0->SetTimeStamp(64.46);
nd0->SetDataValid(true);
mitk::FillVector3D(initialPos, 2.0, 2.0, 2.0);
mitk::NavigationData::OrientationType initialOri2(1.0, 1.0, 1.0, 1.0);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri2);
nd1->SetPositionAccuracy(22.222);
nd1->SetTimeStamp(222.2);
nd1->SetDataValid(true);
myFilter->SetInput(0, nd0);
myFilter->SetInput(1, nd1);
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0)");
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd1, "testing Set-/GetInput(1)");
mitk::NavigationData* output0 = myFilter->GetOutput(0);
mitk::NavigationData* output1 = myFilter->GetOutput(1);
MITK_TEST_CONDITION_REQUIRED(output0 != NULL, "Testing GetOutput(0)");
MITK_TEST_CONDITION_REQUIRED(output1 != NULL, "Testing GetOutput(1)");
/* register message receiver */
MessageReceiverClass answers(2);
myFilter->AddPositionChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::PositionType, unsigned int>(&answers, &MessageReceiverClass::OnPositionChanged));
myFilter->AddOrientationChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::OrientationType, unsigned int>(&answers, &MessageReceiverClass::OnOrientationChanged));
myFilter->AddErrorChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::CovarianceMatrixType, unsigned int>(&answers, &MessageReceiverClass::OnErrorChanged));
myFilter->AddTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
myFilter->AddDataValidChangedListener(mitk::MessageDelegate2<MessageReceiverClass, bool, unsigned int>(&answers, &MessageReceiverClass::OnDataValidChanged));
output0->Update(); // execute filter. This should send messages for both inputs
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetPosition(), nd0->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetOrientation(), nd0->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->GetCovErrorMatrix() == nd0->GetCovErrorMatrix(), "Testing ErrorChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[0]->GetTimeStamp(), nd0->GetTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetPosition(), nd1->GetPosition()), "Testing PositionChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetOrientation(), nd1->GetOrientation()), "Testing OrientationChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->GetCovErrorMatrix() == nd1->GetCovErrorMatrix(), "Testing ErrorChanged message");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing TimeStampChanged message");
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->IsDataValid() == nd1->IsDataValid(), "Testing PositionChanged message");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 10, "Correct number of messages send?");
MITK_TEST_OUTPUT( << "answers.m_MessagesReceived = " << answers.m_MessagesReceived);
/* change one input parameter */
nd0->SetDataValid(false);
output0->Update(); // re-execute filter
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message for input 0");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 11, "only necessary messages send?"); // only datavalid message for input 0 re-send
/* remove one listener and check that message is not send */
myFilter->RemoveTimeStampChangedListener(mitk::MessageDelegate2<MessageReceiverClass, mitk::NavigationData::TimeStampType, unsigned int>(&answers, &MessageReceiverClass::OnTimeStampChanged));
mitk::NavigationData::TimeStampType oldValue = nd1->GetTimeStamp();
nd1->SetTimeStamp(999.9);
myFilter->Update();
MITK_TEST_CONDITION( ! mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), nd1->GetTimeStamp()), "Testing if TimeStamp message is _not_ send after RemoveListener (!= new value)");
MITK_TEST_CONDITION( mitk::Equal(answers.m_ReceivedData[1]->GetTimeStamp(), oldValue), "Testing if TimeStamp message is _not_ send after RemoveListener (== old value)");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 11, "no new messages send?"); // no new message send?
/* other messages are still send? */
nd1->SetDataValid(false);
myFilter->Update();
MITK_TEST_CONDITION( answers.m_ReceivedData[1]->IsDataValid() == nd1->IsDataValid(), "Other messages still send? ->Testing PositionChanged message for input 1 again");
MITK_TEST_CONDITION( answers.m_MessagesReceived == 12, "only necessary messages send?"); // only DataValid message for input 1 re-send
/* check if other output still has its old value */
MITK_TEST_CONDITION( answers.m_ReceivedData[0]->IsDataValid() == nd0->IsDataValid(), "Testing PositionChanged message for input 0");
}
// The end
MITK_TEST_END();
}
| int mitkNavigationDataToNavigationDataFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataToNavigationDataFilter".
Definition at line 36 of file mitkNavigationDataToNavigationDataFilterTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::NavigationData::New(), and NavigationDataToNavigationDataFilterTestClass::New().
{
MITK_TEST_BEGIN("NavigationDataToNavigationDataFilter")
// let's create an object of our class
mitk::NavigationDataToNavigationDataFilter::Pointer myFilter = NavigationDataToNavigationDataFilterTestClass::New().GetPointer(); // create testing subclass, but treat it like the real NavigationDataToNavigationDataFilter
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos;
mitk::FillVector3D(initialPos, 1.0, 2.0, 3.0);
mitk::NavigationData::OrientationType initialOri(0.1, 0.2, 0.3, 0.4);
mitk::ScalarType initialError(22.22);
bool initialValid(true);
mitk::NavigationData::Pointer nd0 = mitk::NavigationData::New();
nd0->SetPosition(initialPos);
nd0->SetOrientation(initialOri);
nd0->SetPositionAccuracy(initialError);
nd0->SetDataValid(initialValid);
MITK_TEST_CONDITION(myFilter->GetOutput() == NULL, "testing GetOutput()");
myFilter->SetInput(nd0);
MITK_TEST_CONDITION(myFilter->GetInput() == nd0, "testing Set-/GetInput()");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0)");
MITK_TEST_CONDITION(myFilter->GetOutput() != NULL, "testing GetOutput() after SetInput()");
MITK_TEST_CONDITION(myFilter->GetOutput(0) != NULL, "testing GetOutput() after SetInput()");
MITK_TEST_CONDITION(myFilter->GetOutput(0) != nd0, "testing GetOutput() different object than input");
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->Graft(nd0);
nd1->SetDataValid(false);
myFilter->SetInput(1, nd1);
MITK_TEST_CONDITION(myFilter->GetInput(1) == nd1, "testing Set-/GetInput(1)");
MITK_TEST_CONDITION(myFilter->GetInput(0) == nd0, "testing Set-/GetInput(0) again");
MITK_TEST_CONDITION(myFilter->GetOutput(1) != NULL, "testing GetOutput() after SetInput()");
MITK_TEST_CONDITION(myFilter->GetOutput(0) != myFilter->GetOutput(1), "testing GetOutput(0) different object than GetOutput(1)");
myFilter->SetInput(10, nd1);
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 11, "testing SetInput(10) produces 11 outputs");
MITK_TEST_CONDITION(myFilter->GetInput(10) == nd1, "testing Set-/GetInput(10)");
myFilter->SetInput(10, NULL);
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 10, "testing SetInput(10, NULL) removes output with index 10");
myFilter->SetInput(1, NULL);
MITK_TEST_CONDITION(myFilter->GetNumberOfInputs() == 10, "testing SetInput(1, NULL) does not change number of outputs");
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataToPointSetFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Definition at line 173 of file mitkNavigationDataToPointSetFilterTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::NavigationDataToPointSetFilter::New(), mitkNavigationDataToPointSetFilterTestClass::TestMode3D(), and mitkNavigationDataToPointSetFilterTestClass::TestMode4D().
{
// always start with this!
MITK_TEST_BEGIN("NavigationDataToPointSetFilter");
// let's create an object of our class
mitk::NavigationDataToPointSetFilter::Pointer myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myNavigationDataToPointSetFilter.IsNotNull(),"Testing instantiation");
// write your own tests here and use the macros from mitkTestingMacros.h !!!
// do not write to std::cout and do not return from this function yourself!
mitkNavigationDataToPointSetFilterTestClass::TestMode3D(myNavigationDataToPointSetFilter);
myNavigationDataToPointSetFilter = mitk::NavigationDataToPointSetFilter::New();
mitkNavigationDataToPointSetFilterTestClass::TestMode4D(myNavigationDataToPointSetFilter);
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationDataTransformFilterTest | ( | int | , |
| char * | [] | ||
| ) |
Definition at line 35 of file mitkNavigationDataTransformFilterTest.cpp.
References mitk::NavigationData::GetOrientation(), mitk::NavigationData::GetPosition(), mitk::NavigationData::IsDataValid(), MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_FOR_EXCEPTION, mitk::NavigationData::New(), and mitk::NavigationDataTransformFilter::New().
{
MITK_TEST_BEGIN("NavigationDataTransformFilter")
// let's create an object of our class
mitk::NavigationDataTransformFilter::Pointer myFilter = mitk::NavigationDataTransformFilter::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter.IsNotNull(),"Testing instantiation");
/* create helper objects: navigation data with position as origin, zero quaternion, zero error and data valid */
mitk::NavigationData::PositionType initialPos, resultPos;
mitk::FillVector3D(initialPos, 1.1, 2.2, 3.3);
mitk::FillVector3D(resultPos, 5.0, 5.0,5.0);
mitk::NavigationData::OrientationType initialOri(0.0, 0.0, -0.7071, 0.7071);
mitk::ScalarType initialError(0.0);
bool initialValid(true);
mitk::NavigationData::Pointer nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->SetInput(nd1);
MITK_TEST_CONDITION(myFilter->GetInput() == nd1, "Testing Set-/GetInput()");
mitk::NavigationData* output = myFilter->GetOutput(0);
/*test case no transform set*/
MITK_TEST_FOR_EXCEPTION(std::exception, output->Update(););
/* test transformation */
mitk::NavigationDataTransformFilter::TransformType::Pointer transform = mitk::NavigationDataTransformFilter::TransformType::New();
VectorType translationVector;
translationVector[0] = 3.9;
translationVector[1] = 2.8;
translationVector[2] = 1.7;
/* test translation */
transform->Translate(translationVector);
myFilter->SetRigid3DTransform(transform);
output = myFilter->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output != NULL, "Testing GetOutput()");
output->Update(); // execute filter
MITK_TEST_CONDITION(output->GetPosition() == resultPos, "Testing if translation was calculated correct");
MITK_TEST_CONDITION( mitk::Equal(output->GetOrientation(),initialOri),"Testing if Orientation remains unchanged ");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
// test rotation
mitk::NavigationDataTransformFilter::Pointer myFilter2 = mitk::NavigationDataTransformFilter::New();
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myFilter2.IsNotNull(),"Testing instantiation");
mitk::FillVector3D(initialPos, 1.1, 1.1, 1.1);
mitk::FillVector3D(resultPos, 1.1, -1.1, 1.1);
mitk::NavigationData::OrientationType resultOri(0.0, 0.0, -0.7071, 0.7071);
initialOri[0] = 0;
initialOri[1] = 0;
initialOri[2] = 0;
initialOri[3] = 1;
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
myFilter2->SetInput(nd1);
itk::Matrix<mitk::ScalarType,3,3> rotMatrix;
rotMatrix[0][0] = 0;
rotMatrix[0][1] = 1;
rotMatrix[0][2] = 0;
rotMatrix[1][0] = -1;
rotMatrix[1][1] = 0;
rotMatrix[1][2] = 0;
rotMatrix[2][0] = 0;
rotMatrix[2][1] = 0;
rotMatrix[2][2] = 1;
mitk::NavigationDataTransformFilter::TransformType::Pointer transform2 = mitk::NavigationDataTransformFilter::TransformType::New();
transform2->SetRotationMatrix(rotMatrix);
myFilter2->SetRigid3DTransform(transform2);
mitk::NavigationData* output2 = myFilter2->GetOutput();
MITK_TEST_CONDITION_REQUIRED(output2 != NULL, "Testing GetOutput()");
output2->Update(); // execute filter
MITK_TEST_CONDITION(output2->GetPosition() == resultPos, "Testing if position after rotation is correctly calculated");
MITK_TEST_CONDITION( mitk::Equal(output2->GetOrientation(), resultOri),"Testing if orientation after rotation is correctly caclculated ");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged");
//-----------------------------------------------------------------------------------------------------------
/* now test the filter with multiple inputs */
mitk::NavigationData::PositionType initialPos2, resultPos2;
mitk::FillVector3D(initialPos, 1.1, 2.2, 3.3);
mitk::FillVector3D(initialPos2, -1000.0, 567.89, 0.0);
mitk::FillVector3D(resultPos, 2.2,-1.1, 3.3);
mitk::FillVector3D(resultPos2, 567.89, 1000, 0.0);
mitk::NavigationData::OrientationType initialOri2(0.5,0.5,0.5,0.5);
mitk::NavigationData::OrientationType resultOri2(0.7071,0.0,0.0,0.7071);
mitk::NavigationData::Pointer nd2 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
nd2->SetPosition(initialPos2);
nd2->SetOrientation(initialOri2);
nd2->SetPositionAccuracy(initialError);
nd2->SetDataValid(initialValid);
myFilter = NULL;
myFilter = mitk::NavigationDataTransformFilter::New();
myFilter->SetRigid3DTransform(transform2);
myFilter->SetInput(0, nd1);
myFilter->SetInput(1, nd2);
MITK_TEST_CONDITION(((myFilter->GetInput(0) == nd1)
&& (myFilter->GetInput(1) == nd2)), "Testing Set-/GetInput(index, data)");
output = NULL;
output2 = NULL;
output = myFilter->GetOutput(0);
output2 = myFilter->GetOutput(1);
output2->Update(); // execute filter pipeline. this should update both outputs!
MITK_TEST_CONDITION_REQUIRED(((output != NULL) && (output2 != NULL)), "Testing GetOutput(index)");
MITK_TEST_CONDITION(output->GetPosition() == resultPos, "Testing if position rotation was calculated correct [output 0]");
MITK_TEST_CONDITION(mitk::Equal(output->GetOrientation(), resultOri),"Testing if orientation rotation was calculated correct [output 0]");
MITK_TEST_CONDITION(output->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 0");
MITK_TEST_CONDITION(output2->GetPosition() == resultPos2, "Testing if rotation was calculated correct [output 1]");
MITK_TEST_CONDITION(mitk::Equal(output2->GetOrientation(), resultOri2),"Testing if orientation rotation was calculated correct [output 1]");
MITK_TEST_CONDITION(output2->IsDataValid() == initialValid, "Testing if DataValid remains unchanged for output 1");
//
// /* test if anything changes on second ->Update() */
output->Update(); // nothing should change, since inputs remain unchanged
MITK_TEST_CONDITION((output->GetPosition() == (resultPos)) && (output2->GetPosition() == (resultPos2)), "Testing translation calculation after second update()");
/* change an input, see if output changes too */
mitk::NavigationData::PositionType pos3, resultPos3;
mitk::FillVector3D(pos3, 123.456, -234.567, 789.987);
mitk::FillVector3D(resultPos3, -234.567, -123.456, 789.987);
nd1->SetPosition(pos3); // nd1 is modified, but nothing should change until pipe gets updated
MITK_TEST_CONDITION((output->GetPosition() == (resultPos))
&&(output2->GetPosition() == (resultPos2)), "Testing transfomr calculation after input change, before update()");
output->Update(); // update pipeline. should recalculate positions, because input has changed
MITK_TEST_CONDITION((output->GetPosition() == (resultPos3)) && (output2->GetPosition() == (resultPos2)), "Testing transform calculation after input change, after update()");
// always end with this!
MITK_TEST_END();
}
| int mitkNavigationToolReaderAndWriterTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the TrackingVolume class.
Definition at line 124 of file mitkNavigationToolReaderAndWriterTest.cpp.
References mitkNavigationToolReaderAndWriterTestClass::CleanUp(), MITK_TEST_BEGIN, MITK_TEST_END, mitkNavigationToolReaderAndWriterTestClass::TestInstantiation(), and mitkNavigationToolReaderAndWriterTestClass::TestWrite().
{
MITK_TEST_BEGIN("NavigationToolWriter")
mitkNavigationToolReaderAndWriterTestClass::TestInstantiation();
mitkNavigationToolReaderAndWriterTestClass::TestWrite();
//mitkNavigationToolReaderAndWriterTestClass::TestRead();
mitkNavigationToolReaderAndWriterTestClass::CleanUp();
MITK_TEST_END()
}
| int mitkNavigationToolStorageSerializerAndDeserializerTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the TrackingVolume class.
Definition at line 33 of file mitkNavigationToolStorageSerializerAndDeserializerTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_END, and NavigationToolStorageSerializerAndDeserializerTestClass::TestInstantiation().
{
MITK_TEST_BEGIN("NavigationToolStorageSerializerAndDeserializer")
NavigationToolStorageSerializerAndDeserializerTestClass::TestInstantiation();
MITK_TEST_END()
}
| int mitkNavigationToolStorageTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the TrackingVolume class.
Definition at line 114 of file mitkNavigationToolStorageTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_END, mitkNavigationToolStorageTestClass::TestAddAndDelete(), mitkNavigationToolStorageTestClass::TestAddAndDelete100Tools(), mitkNavigationToolStorageTestClass::TestGetTool(), and mitkNavigationToolStorageTestClass::TestInstantiation().
{
MITK_TEST_BEGIN("NavigationToolStorage")
mitkNavigationToolStorageTestClass::TestInstantiation();
mitkNavigationToolStorageTestClass::TestAddAndDelete();
mitkNavigationToolStorageTestClass::TestAddAndDelete100Tools();
mitkNavigationToolStorageTestClass::TestGetTool();
MITK_TEST_END()
}
| int mitkNavigationToolTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the TrackingVolume class.
Definition at line 68 of file mitkNavigationToolTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_END, mitkNavigationToolTestClass::TestGetterAndSetter(), and mitkNavigationToolTestClass::TestInstantiation().
{
MITK_TEST_BEGIN("NavigationTool")
mitkNavigationToolTestClass::TestInstantiation();
mitkNavigationToolTestClass::TestGetterAndSetter();
MITK_TEST_END()
}
| int mitkNDIPassiveToolTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation Test for mitk::NDIPassiveTool
Definition at line 51 of file mitkNDIPassiveToolTest.cpp.
References mitk::NDIPassiveTool::ButtonBox, mitk::NDIPassiveTool::Dynamic, mitk::StandardFileLocations::GetInstance(), MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, NDIPassiveToolTestClass::New(), and mitk::NDIPassiveTool::Static.
{
// always start with this!
MITK_TEST_BEGIN("NDIPassiveTool");
// let's create an object of our class
mitk::NDIPassiveTool::Pointer myNDIPassiveTool = NDIPassiveToolTestClass::New().GetPointer();
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myNDIPassiveTool.IsNotNull(),"Testing instantiation");
myNDIPassiveTool->SetTrackingPriority(mitk::NDIPassiveTool::Dynamic);
MITK_TEST_CONDITION(myNDIPassiveTool->GetTrackingPriority()==mitk::NDIPassiveTool::Dynamic,"Testing Set/GetTrackingPriority() with 'Dynamic'");
myNDIPassiveTool->SetTrackingPriority(mitk::NDIPassiveTool::ButtonBox);
MITK_TEST_CONDITION(myNDIPassiveTool->GetTrackingPriority()==mitk::NDIPassiveTool::ButtonBox,"Testing Set/GetTrackingPriority() with 'ButtonBox'");
myNDIPassiveTool->SetTrackingPriority(mitk::NDIPassiveTool::Static);
MITK_TEST_CONDITION(myNDIPassiveTool->GetTrackingPriority()==mitk::NDIPassiveTool::Static,"Testing Set/GetTrackingPriority() with 'Static'");
std::string file = mitk::StandardFileLocations::GetInstance()->FindFile("SROMFile.rom", "Modules/IGT/Testing/Data");
const char *name = file.c_str();
const char *name2 = "";
MITK_TEST_CONDITION(myNDIPassiveTool->LoadSROMFile(name) == true ,"Test LoadSROMFile() with valid file")
const unsigned char *temp = myNDIPassiveTool->GetSROMData();
unsigned int templen = myNDIPassiveTool->GetSROMDataLength();
MITK_TEST_CONDITION(myNDIPassiveTool->LoadSROMFile(name2) == false ,"Test LoadSROMFile() without file")
MITK_TEST_CONDITION(myNDIPassiveTool->GetSROMData()== temp, "Test GetSROMData() returns same after failed load")
MITK_TEST_CONDITION(myNDIPassiveTool->GetSROMDataLength()== templen,"Test GetSROMDataLength() returns same after failed load")
// always end with this!
MITK_TEST_END();
}
| int mitkNDIProtocolTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation Test for mitk::NDIProtocol
Definition at line 47 of file mitkNDIProtocolTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, and NDIProtocolTestClass::New().
{
// always start with this!
MITK_TEST_BEGIN("NDIProtocolTest");
// let's create an object of our class
mitk::NDIProtocol::Pointer myNDIProtocol = NDIProtocolTestClass::New().GetPointer();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myNDIProtocol.IsNotNull(),"Testing instantiation");
//COMM(mitk::SerialCommunication::BaudRate baudRate , mitk::SerialCommunication::DataBits dataBits, mitk::SerialCommunication::Parity parity, mitk::SerialCommunication::StopBits stopBits, mitk::SerialCommunication::HardwareHandshake hardwareHandshake)
//No testing possible, hardware required
//All other methods
//No testing possible, hardware required
// always end with this!
MITK_TEST_END();
}
| int mitkNDITrackingDeviceTest | ( | int | , |
| char * | [] | ||
| ) |
Definition at line 28 of file mitkNDITrackingDeviceTest.cpp.
References mitk::StandardFileLocations::GetInstance(), mitk::HybridTracking, mitk::MarkerTracking3D, MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, mitk::NDITrackingDevice::New(), mitk::TrackingDevice::Setup, and mitk::ToolTracking5D.
{
// always start with this!
MITK_TEST_BEGIN("NDITrackingDevice");
// let's create an object of our class
mitk::NDITrackingDevice::Pointer myNDITrackingDevice = mitk::NDITrackingDevice::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(myNDITrackingDevice.IsNotNull(),"Testing instantiation\n");
MITK_TEST_CONDITION_REQUIRED(myNDITrackingDevice->GetState() == mitk::TrackingDevice::Setup ,"Checking tracking device state == setup.\n");
//OpenConnection
//MITK_TEST_CONDITION( (!myNDITrackingDevice->OpenConnection()), "Testing behavior of method OpenConnection() (Errors should occur because Tracking Device is not activated).");
// <-- this test is dangerous. It implies that no tracking device is connected to the dartclient pc, which could be wrong.
//CloseConnection
MITK_TEST_CONDITION( (myNDITrackingDevice->CloseConnection()), "Testing behavior of method CloseConnection().");
//StartTracking
MITK_TEST_CONDITION( (!myNDITrackingDevice->StartTracking()), "Testing behavior of method StartTracking().");
//Beep(unsigned char count)
MITK_TEST_CONDITION( (myNDITrackingDevice->Beep(3)== false), "Testing behavior of method Beep(). No Tracking device initialized!");
//AddTool( const char* toolName, const char* fileName, TrackingPriority p /*= NDIPassiveTool::Dynamic*/ )
std::string file = mitk::StandardFileLocations::GetInstance()->FindFile("SROMFile.rom", "Modules/IGT/Testing/Data");
const char *name = file.c_str();
MITK_TEST_CONDITION( (myNDITrackingDevice->AddTool("Tool0", name))!=NULL, "Testing AddTool() for tool 0.");
//GetToolCount()
MITK_TEST_CONDITION( (myNDITrackingDevice->GetToolCount())==1, "Testing GetToolCount() for one tool.");
//GetTool(unsigned int toolNumber)
MITK_TEST_CONDITION( (myNDITrackingDevice->GetTool(0))!=NULL, "Testing GetTool() for tool 0.");
mitk::TrackingTool::Pointer testtool = myNDITrackingDevice->GetTool(0);
//UpdateTool(mitk::TrackingTool* tool)
MITK_TEST_CONDITION( (!myNDITrackingDevice->UpdateTool(testtool)), "Testing behavior of method UpdateTool().\n");
//RemoveTool(mitk::TrackingTool* tool)
MITK_TEST_CONDITION( (myNDITrackingDevice->RemoveTool(testtool)), "Testing RemoveTool()for tool 0.");
//SetOperationMode(OperationMode mode)
MITK_TEST_CONDITION( (myNDITrackingDevice->SetOperationMode( mitk::MarkerTracking3D )== true ), "Testing behavior of method SetOperationMode().\n");
//GetOperationMode()
myNDITrackingDevice->SetOperationMode(mitk::MarkerTracking3D);
MITK_TEST_CONDITION( (myNDITrackingDevice->GetOperationMode()==2),"" );
myNDITrackingDevice->SetOperationMode(mitk::ToolTracking5D);
MITK_TEST_CONDITION( (myNDITrackingDevice->GetOperationMode()==1),"" );
myNDITrackingDevice->SetOperationMode(mitk::HybridTracking);
MITK_TEST_CONDITION( (myNDITrackingDevice->GetOperationMode()==3), "Testing behavior of method GetOperationMode().\n");
//GetMarkerPositions(MarkerPointContainerType* markerpositions)
mitk::MarkerPointContainerType* markerpositions = new mitk::MarkerPointContainerType();
MITK_TEST_CONDITION( (!myNDITrackingDevice->GetMarkerPositions(markerpositions)), "Testing behavior of method GetMarkerPositions().\n");
delete markerpositions;
// always end with this!
MITK_TEST_END();
}| int mitkTimeStampTest | ( | int | , |
| char * | [] | ||
| ) |
test for the class "mitkTimeStamp"
Definition at line 31 of file mitkTimeStampTest.cpp.
References mitk::TimeStamp::GetInstance(), MITK_TEST_BEGIN, MITK_TEST_CONDITION_REQUIRED, and MITK_TEST_END.
{
MITK_TEST_BEGIN("TimeStamp")
// let's create an object of our class
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(mitk::TimeStamp::GetInstance() != (0), "Testing GetInstance() of Singleton" );
itk::Object::Pointer tester = itk::Object::New();
itk::Object::Pointer tester2 = itk::Object::New();
//start-tracking sets the reference-time, timestamps are relative to this time
mitk::TimeStamp::GetInstance()->Start(tester);
std::cout << "first device has started tracking\n";
//sleeps for 20 ms
#if defined (WIN32) || defined (_WIN32)
Sleep(20);
#else
usleep(20000);
#endif
std::cout << "supposed to have waited 20ms \n";
double time_elapsed, relative_time_elapsed;
//gets time elapsed since start
time_elapsed = mitk::TimeStamp::GetInstance()->GetElapsed();
std::cout << "have actually waited : " << time_elapsed << "ms \n";
//elapsed time is not allowed to be too far from 20 ms (+-10ms)-> debugging "destroys" the correct value of course
MITK_TEST_CONDITION_REQUIRED((time_elapsed-20) > -10 , "Testing if elapsed time is correct (-10)");
//MITK_TEST_CONDITION_REQUIRED((time_elapsed-20) < 10 , "Testing if elapsed time is correct (+10)");
//second "device" starts tracking
mitk::TimeStamp::GetInstance()->Start(tester2);
std::cout << "second device has started\n";
//first device stops
mitk::TimeStamp::GetInstance()->Stop(tester);
std::cout << "first device has stopped tracking\n";
time_elapsed = mitk::TimeStamp::GetInstance()->GetElapsed();
relative_time_elapsed = mitk::TimeStamp::GetInstance()->GetElapsed(tester2);
std::cout << "time elapsed supposed to be greater than 20 ms\n";
std::cout << time_elapsed << " actually elapsed\n";
std::cout << "relative time elapsed supposed to be smaller than absolute time elapsed : \n";
std::cout << relative_time_elapsed << " actually elapsed\n";
//relative timespan must be smaller than absolute timespan
MITK_TEST_CONDITION_REQUIRED( time_elapsed > relative_time_elapsed , " testing if relative timespan is shorter than absolute timespan");
//timestamp still has to be valid (tester2 still tracking), and has to be larger than 20ms
//MITK_TEST_CONDITION_REQUIRED( time_elapsed > 15 , "testing if second device is still keeping the TimeStamp \"alive\"");
mitk::TimeStamp::GetInstance()->Stop(tester2);
std::cout << " second device has stopped tracking\n";
time_elapsed = mitk::TimeStamp::GetInstance()->GetElapsed();
//when all devices have stopped, -1 has to be returned
MITK_TEST_CONDITION_REQUIRED( time_elapsed == -1 , "testing if -1 is returned after all devices have stopped");
// always end with this!
MITK_TEST_END();
}
| int mitkTrackingDeviceSourceTest | ( | int | , |
| char * | [] | ||
| ) |
Documentation test for the class "NavigationDataSource".
Definition at line 28 of file mitkTrackingDeviceSourceTest.cpp.
References mitk::NavigationData::GetPosition(), MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_FAILED_MSG, MITK_TEST_FOR_EXCEPTION, mitk::VirtualTrackingDevice::New(), mitk::TrackingDeviceSource::New(), mitk::TrackingDevice::Ready, mitk::TrackingDevice::Setup, and mitk::TrackingDevice::Tracking.
{
MITK_TEST_BEGIN("TrackingDeviceSource");
// let's create an object of our class
mitk::TrackingDeviceSource::Pointer mySource = mitk::TrackingDeviceSource::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(mySource.IsNotNull(), "Testing instantiation");
mySource->SetTrackingDevice(NULL);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == NULL, "Testing Set/GetTrackingDevice(NULL)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 0, "Testing GetNumberOfOutputs with NULL td");
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, mySource->Connect());
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, mySource->StartTracking());
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == tracker.GetPointer(), "Testing Set/GetTrackingDevice(tracker)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 0, "Testing GetNumberOfOutputs with no tool tracker");
tracker = mitk::VirtualTrackingDevice::New();
mitk::ReferenceCountWatcher::Pointer watch = new mitk::ReferenceCountWatcher(tracker);
tracker->AddTool("T0");
tracker->AddTool("T1");
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(mySource->GetTrackingDevice() == tracker.GetPointer(), "Testing Set/GetTrackingDevice(tracker2)");
MITK_TEST_CONDITION(mySource->GetNumberOfOutputs() == 2, "Testing GetNumberOfOutputs with 2 tools tracker");
MITK_TEST_CONDITION(mySource->IsConnected() == false, "Testing IsConnected()");
mySource->Connect();
MITK_TEST_CONDITION(mySource->IsConnected() == true, "Testing Connect()/IsConnected()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Ready, "Testing Connect()/IsConnected() 2");
mySource->Disconnect();
MITK_TEST_CONDITION(mySource->IsConnected() == false, "Testing Disconnect()/IsConnected()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Setup, "Testing Disconnect()/IsConnected() 2");
mySource->Connect();
mySource->StartTracking();
MITK_TEST_CONDITION(mySource->IsConnected() == true, "Testing StartTracking()/IsConnected()");
MITK_TEST_CONDITION(mySource->IsTracking() == true, "Testing StartTracking()/IsTracking()");
MITK_TEST_CONDITION(tracker->GetState() == mitk::TrackingDevice::Tracking, "Testing StartTracking()/IsTracking() 2");
unsigned long modTime = mySource->GetMTime();
mySource->UpdateOutputInformation();
MITK_TEST_CONDITION(mySource->GetMTime() != modTime, "Testing if UpdateOutputInformation() modifies the object");
mitk::NavigationData* nd0 = mySource->GetOutput(0);
nd0->Update();
mitk::NavigationData::PositionType pos = nd0->GetPosition();
itksys::SystemTools::Delay(500); // allow the tracking thread to advance the tool position
nd0->Update();
MITK_TEST_CONDITION(mitk::Equal(nd0->GetPosition(), pos) == false, "Testing if output changes on each update");
mitk::NavigationData* nd1 = mySource->GetOutput(1);
MITK_TEST_CONDITION(nd0 != nd1, "Testing if outputs are different");
MITK_TEST_CONDITION(mitk::Equal(nd0->GetPosition(), nd1->GetPosition()) == false, "Testing if output contents are different");
mySource->StopTracking();
mySource->Disconnect();
tracker = mitk::VirtualTrackingDevice::New();
mySource->SetTrackingDevice(tracker);
MITK_TEST_CONDITION(watch->GetReferenceCount() == 0, "Testing if reference to previous tracker object is released");
watch = NULL;
MITK_TEST_FOR_EXCEPTION(std::runtime_error, mySource->StartTracking()); // new tracker, needs Connect() before StartTracking()
mySource->Connect();
mySource->StartTracking();
// itksys::SystemTools::Delay(800); // wait for tracking thread to start properly //DEBUG ONLY --> race condition. will the thread start before the object is destroyed? --> maybe hold a smartpointer?
try
{
mySource = NULL; // delete source
tracker = NULL; // delete tracker --> both should not result in any exceptions or deadlocks
}
catch (...)
{
MITK_TEST_FAILED_MSG(<< "exception during destruction of source or tracker!");
}
// always end with this!
MITK_TEST_END();
}
| int mitkTrackingDeviceTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the Class TrackingDevice. For most tests we would need the MicronTracker hardware, so only a few simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
Definition at line 49 of file mitkTrackingDeviceTest.cpp.
References mitk::AscensionMicroBird, mitk::ClaronMicron, mitk::IntuitiveDaVinci, MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_END, mitk::NDIAurora, mitk::NDIPolaris, TrackingDeviceTestClass::New(), mitk::TrackingDevice::Ready, mitk::TrackingDevice::Setup, mitk::TrackingSystemNotSpecified, and mitk::VirtualTracker.
{
MITK_TEST_BEGIN("TrackingDevice");
// Test instantiation of TrackingDevice
TrackingDeviceTestClass::Pointer trackingDeviceTestClass = TrackingDeviceTestClass::New();
MITK_TEST_CONDITION(trackingDeviceTestClass.IsNotNull(),"Test instatiation");
// Test method GetErrorMessage()
MITK_TEST_CONDITION(trackingDeviceTestClass->GetErrorMessage()==std::string(""),"Error message should be empty");
// Test method GetState()
MITK_TEST_CONDITION(trackingDeviceTestClass->GetState()==mitk::TrackingDevice::Setup,"Mode should be initialized to SETUP");
// Test method SetType()
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::TrackingSystemNotSpecified,"Type should be initialized to 'not specified'");
trackingDeviceTestClass->SetType( mitk::NDIAurora );
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::NDIAurora,"Type should be NDIAurora, as it has just been set");
trackingDeviceTestClass->SetType( mitk::NDIPolaris );
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::NDIPolaris,"Type should be NDIPolaris, as it has just been set");
trackingDeviceTestClass->SetType( mitk::ClaronMicron );
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::ClaronMicron,"Type should be ClaronMicron, as it has just been set");
trackingDeviceTestClass->SetType( mitk::AscensionMicroBird );
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::AscensionMicroBird,"Type should be AscensionMicroBird, as it has just been set");
trackingDeviceTestClass->SetType( mitk::VirtualTracker);
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::VirtualTracker,"Type should be VirtualTracker, as it has just been set");
trackingDeviceTestClass->SetType( mitk::IntuitiveDaVinci );
MITK_TEST_CONDITION(trackingDeviceTestClass->GetType()==mitk::IntuitiveDaVinci,"Type should be IntuitiveDaVinci, as it has just been set");
// Test method StopTracking()
trackingDeviceTestClass->StartTracking();
trackingDeviceTestClass->StopTracking();
MITK_TEST_CONDITION(trackingDeviceTestClass->GetState()== mitk::TrackingDevice::Ready,"Type should be NDIAurora, as it has just been set");
MITK_TEST_END();
}
| int mitkTrackingToolTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the Class TrackingDevice. For most tests we would need the MicronTracker hardware, so only a few simple tests, which can run without the hardware are implemented yet (2009, January, 23rd). As soon as there is a working concept to test the tracking classes which are very close to the hardware on all systems more tests are needed here.
Definition at line 51 of file mitkTrackingToolTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_END, and TrackingToolTestClass::New().
{
MITK_TEST_BEGIN("TrackingTool");
// Test instantiation of TrackingTool
TrackingToolTestClass::Pointer trackingToolTestClass = TrackingToolTestClass::New();
MITK_TEST_CONDITION(trackingToolTestClass.IsNotNull(),"Test instatiation");
// Test method GetToolName()
MITK_TEST_CONDITION(!strcmp(trackingToolTestClass->GetToolName(),""),"Tool name should be empty");
// Test method GetErrorMessage()
MITK_TEST_CONDITION(!strcmp(trackingToolTestClass->GetErrorMessage(),""),"Error message should be empty");
MITK_TEST_END();
}
| int mitkTrackingVolumeTest | ( | int | , |
| char * | [] | ||
| ) |
This function is testing the TrackingVolume class.
Definition at line 98 of file mitkTrackingVolumeTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_END, mitkTrackingVolumeTestClass::TestClaronTrackingVolume(), mitkTrackingVolumeTestClass::TestInstantiation(), mitkTrackingVolumeTestClass::TestIntuitiveDaVinciTrackingVolume(), mitkTrackingVolumeTestClass::TestManualVolume(), mitkTrackingVolumeTestClass::TestNDIAuroraTrackingVolume(), and mitkTrackingVolumeTestClass::TestNDIPolarisTrackingVolume().
{
MITK_TEST_BEGIN("TrackingVolume")
mitkTrackingVolumeTestClass::TestInstantiation();
mitkTrackingVolumeTestClass::TestClaronTrackingVolume();
mitkTrackingVolumeTestClass::TestNDIAuroraTrackingVolume();
mitkTrackingVolumeTestClass::TestNDIPolarisTrackingVolume();
mitkTrackingVolumeTestClass::TestIntuitiveDaVinciTrackingVolume();
//mitkTrackingVolumeTestClass::TestIsInside(); Activate this code when method isInside() is implemented!
mitkTrackingVolumeTestClass::TestManualVolume();
MITK_TEST_END()
}
| int mitkVirtualTrackingDeviceTest | ( | int | , |
| char * | [] | ||
| ) |
Definition at line 25 of file mitkVirtualTrackingDeviceTest.cpp.
References MITK_TEST_BEGIN, MITK_TEST_CONDITION, MITK_TEST_CONDITION_REQUIRED, MITK_TEST_END, MITK_TEST_FOR_EXCEPTION, mitk::VirtualTrackingDevice::New(), and mitk::TrackingDevice::Setup.
{
// always start with this!
MITK_TEST_BEGIN("VirtualTrackingDevice");
// let's create an object of our class
mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
// first test: did this work?
// using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
// it makes no sense to continue without an object.
MITK_TEST_CONDITION_REQUIRED(tracker.IsNotNull(),"Testing instantiation\n");
MITK_TEST_CONDITION_REQUIRED(tracker->GetState() == mitk::TrackingDevice::Setup ,"Checking tracking device state == setup.\n");
//CloseConnection
MITK_TEST_CONDITION( (tracker->CloseConnection()), "Testing behavior of method CloseConnection().");
//StartTracking
MITK_TEST_CONDITION( tracker->StartTracking() == false, "Testing behavior of method StartTracking().");
tracker->SetRefreshRate(43);
MITK_TEST_CONDITION( tracker->GetRefreshRate() == 43, "Testing Set-/GetRefreshRate()");
MITK_TEST_CONDITION( tracker->GetToolCount() == 0, "Testing GetToolCount() before AddTool()");
MITK_TEST_CONDITION( tracker->AddTool("Tool0"), "Testing AddTool() for tool 0.");
MITK_TEST_CONDITION( tracker->GetToolCount() == 1, "Testing GetToolCount() after AddTool()");
mitk::TrackingTool::Pointer tool = tracker->GetTool(0);
MITK_TEST_CONDITION_REQUIRED( tool.IsNotNull(), "Testing GetTool() for tool 0.");
MITK_TEST_CONDITION( tracker->GetToolByName("Tool0") == tool.GetPointer(), "Testing GetTool() equals GetToolByName() for tool 0.");
mitk::ScalarType bounds[6] = {0.0, 10.0, 1.0, 20.0, 3.0, 30.0};
tracker->SetBounds(bounds);
MITK_TEST_CONDITION( tracker->GetBounds()[0] == bounds[0]
&& tracker->GetBounds()[1] == bounds[1]
&& tracker->GetBounds()[2] == bounds[2]
&& tracker->GetBounds()[3] == bounds[3]
&& tracker->GetBounds()[4] == bounds[4]
&& tracker->GetBounds()[5] == bounds[5]
, "Testing Set-/GetBounds()");
MITK_TEST_CONDITION( tracker->AddTool("Tool1"), "Testing AddTool() for tool 1.");
MITK_TEST_CONDITION( tracker->GetToolCount() == 2, "Testing GetToolCount() after AddTool()");
tracker->SetToolSpeed(0, 0.1); // no exception expected
tracker->SetToolSpeed(1, 0.1); // no exception expected
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, tracker->SetToolSpeed(2, 0.1)); // exception expected
mitk::ScalarType lengthBefore = tracker->GetSplineChordLength(0); // no exception expected
MITK_TEST_FOR_EXCEPTION(std::invalid_argument, tracker->GetSplineChordLength(2)); // exception expected
MITK_TEST_CONDITION( tracker->OpenConnection() == true, "Testing OpenConnection().");
MITK_TEST_CONDITION( tracker->GetSplineChordLength(0) == lengthBefore, "Testing GetSplineChordLength() after initalization");
//StartTracking
mitk::Point3D posBefore0;
tool->GetPosition(posBefore0);
mitk::Point3D posBefore1;
tracker->GetToolByName("Tool1")->GetPosition(posBefore1);
mitk::Point3D posAfter0;
tool->GetPosition(posAfter0);
MITK_TEST_CONDITION( mitk::Equal(posBefore0, posAfter0) == true, "Testing if position value is constant before StartTracking()");
MITK_TEST_CONDITION( tracker->StartTracking() == true, "Testing behavior of method StartTracking().");
itksys::SystemTools::Delay(500); // wait for tracking thread to start generating positions
tool->GetPosition(posAfter0);
MITK_TEST_CONDITION( mitk::Equal(posBefore0, posAfter0) == false, "Testing if tracking is producing new position values in tool 0.");
mitk::Point3D posAfter1;
tracker->GetToolByName("Tool1")->GetPosition(posAfter1);
MITK_TEST_CONDITION( mitk::Equal(posBefore1, posAfter1) == false, "Testing if tracking is producing new position values in tool 1.");
// add tool while tracking is in progress
tracker->AddTool("while Running");
tracker->GetToolByName("while Running")->GetPosition(posBefore0);
itksys::SystemTools::Delay(100); // wait for tracking thread to start generating positions
tracker->GetToolByName("while Running")->GetPosition(posAfter0);
MITK_TEST_CONDITION( mitk::Equal(posBefore0, posAfter0) == false, "Testing if tracking is producing new position values for 'while running' tool.");
// always end with this!
MITK_TEST_END();
}
Definition at line 51 of file MitkIGTTestDriver.cpp.
1.7.2