static void TestMethodsNormalCases()
{
//create and initialize test objects
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
myFilter->CreateOutput();
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 nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
//test method graft
MITK_TEST_OUTPUT(<< "testing Graftoutput()");
myFilter->GraftOutput(nd1);
mitk::NavigationData::Pointer out = myFilter->GetOutput();
MITK_TEST_CONDITION(out.GetPointer() != nd1.GetPointer(), "testing if output is same object as source of graft");
MITK_TEST_CONDITION( mitk::Equal(out->GetPosition(), nd1->GetPosition()) &&
mitk::Equal(out->GetOrientation(), nd1->GetOrientation()) &&
(out->GetCovErrorMatrix() == nd1->GetCovErrorMatrix()) &&
(out->IsDataValid() == nd1->IsDataValid()) &&
mitk::Equal(out->GetTimeStamp(), nd1->GetTimeStamp()), "testing if content of output is equal to input of Graft");
//test method GetParameters()
mitk::PropertyList::ConstPointer list = myFilter->GetParameters();
MITK_TEST_CONDITION(list.IsNotNull(), "testing GetParameters()");
}
static void TestMicroserviceRegister()
{
MyNavigationDataSourceTest::Pointer myFilter = MyNavigationDataSourceTest::New();
myFilter->CreateOutput();
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 nd1 = mitk::NavigationData::New();
nd1->SetPosition(initialPos);
nd1->SetOrientation(initialOri);
nd1->SetPositionAccuracy(initialError);
nd1->SetDataValid(initialValid);
myFilter->RegisterAsMicroservice();
MITK_TEST_CONDITION(myFilter->GetMicroserviceID()!="","Testing if microservice was registered successfully.");
}
/**Documentation
* test for the class "NavigationDataToNavigationDataFilter".
*/
int mitkNavigationDataToNavigationDataFilterTest(int /* argc */, char* /*argv*/[])
{
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);
nd0->SetName("testName");
MITK_TEST_CONDITION(myFilter->GetOutput() == NULL, "testing GetOutput()");
MITK_TEST_CONDITION(myFilter->GetInput() == NULL, "testing GetInput() without SetInput()");
MITK_TEST_CONDITION(myFilter->GetInput(0) == NULL, "testing GetInput(0) without SetInput()");
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");
// check getInput() string input
MITK_TEST_CONDITION(myFilter->GetInput("invalidName") == NULL, "testing GetInput(string) invalid string");
MITK_TEST_CONDITION(myFilter->GetInput("testName") == nd0, "testing GetInput(string) valid string");
// check getInputIndex() string input
bool throwsException = false;
try {
myFilter->GetInputIndex("invalidName");
}
catch(std::invalid_argument e) {
throwsException = true;
}
MITK_TEST_CONDITION_REQUIRED(throwsException, "testing GetInputIndex(string) invalid string");
MITK_TEST_CONDITION(myFilter->GetInputIndex("testName") == 0, "testing GetInputIndex(string) valid string");
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();
}
/**Documentation
* test for the class "NavigationDataReferenceTransformFilter".
*/
int mitkNavigationDataReferenceTransformFilterTest(int /* argc */, char* /*argv*/[])
{
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 ND sources*/
mitk::NavigationData::PositionType sourcePos1,sourcePos2, sourcePos3, targetPos1, targetPos2, targetPos3;
mitk::FillVector3D(sourcePos1, 11.1, 11.1, 11.1);
mitk::FillVector3D(sourcePos2, 22.2, 22.2, 22.2);
mitk::FillVector3D(sourcePos3, 33.3, 33.3, 33.3);
mitk::FillVector3D(targetPos1, -1.1, -2.2, -3.3);
mitk::FillVector3D(targetPos2, -4.4, -5.5, -6.6);
mitk::FillVector3D(targetPos3, -7.7, -8.8, -9.9);
/*create helper objects: orientations of the ND sources*/
mitk::NavigationData::OrientationType sourceOri1(0.1, 0.1, 0.1, 0.1);
mitk::NavigationData::OrientationType sourceOri2(0.2, 0.2, 0.2, 0.2);
mitk::NavigationData::OrientationType sourceOri3(0.3, 0.3, 0.3, 0.3);
mitk::NavigationData::OrientationType targetOri1(0.4, 0.4, 0.4, 0.4);
mitk::NavigationData::OrientationType targetOri2(0.5, 0.5, 0.5, 0.5);
mitk::NavigationData::OrientationType targetOri3(0.6, 0.6, 0.6, 0.6);
/*create helper objects: ND position accurancy and validity bool*/
mitk::ScalarType initialError(0.0);
bool initialValid(true);
/*create helper objects: NDs for the source and target NDs*/
mitk::NavigationData::Pointer snd1 = mitk::NavigationData::New();
snd1->SetPosition(sourcePos1);
snd1->SetOrientation(sourceOri1);
snd1->SetPositionAccuracy(initialError);
snd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd2 = mitk::NavigationData::New();
snd2->SetPosition(sourcePos2);
snd2->SetOrientation(sourceOri2);
snd2->SetPositionAccuracy(initialError);
snd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer snd3 = mitk::NavigationData::New();
snd3->SetPosition(sourcePos3);
snd3->SetOrientation(sourceOri3);
snd3->SetPositionAccuracy(initialError);
snd3->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd1 = mitk::NavigationData::New();
tnd1->SetPosition(targetPos1);
tnd1->SetOrientation(targetOri1);
tnd1->SetPositionAccuracy(initialError);
tnd1->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd2 = mitk::NavigationData::New();
tnd2->SetPosition(targetPos2);
tnd2->SetOrientation(targetOri2);
tnd2->SetPositionAccuracy(initialError);
tnd2->SetDataValid(initialValid);
mitk::NavigationData::Pointer tnd3 = mitk::NavigationData::New();
tnd3->SetPosition(targetPos3);
tnd3->SetOrientation(targetOri3);
tnd3->SetPositionAccuracy(initialError);
tnd3->SetDataValid(initialValid);
std::vector<mitk::NavigationData::Pointer> emptySourceNDs;
std::vector<mitk::NavigationData::Pointer> oneSourceNDs;
oneSourceNDs.push_back(snd1);
std::vector<mitk::NavigationData::Pointer> twoSourceNDs;
twoSourceNDs.push_back(snd1);
twoSourceNDs.push_back(snd2);
std::vector<mitk::NavigationData::Pointer> threeSourceNDs;
threeSourceNDs.push_back(snd1);
threeSourceNDs.push_back(snd2);
threeSourceNDs.push_back(snd3);
std::vector<mitk::NavigationData::Pointer> emptyTargetNDs;
std::vector<mitk::NavigationData::Pointer> oneTargetNDs;
oneTargetNDs.push_back(tnd1);
std::vector<mitk::NavigationData::Pointer> twoTargetNDs;
twoTargetNDs.push_back(tnd1);
twoTargetNDs.push_back(tnd2);
std::vector<mitk::NavigationData::Pointer> threeTargetNDs;
threeTargetNDs.push_back(tnd1);
threeTargetNDs.push_back(tnd2);
threeTargetNDs.push_back(tnd3);
// ------------------ setting no NDs ------------------
myFilter->SetSourceNavigationDatas(emptySourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->IsEmpty() == true, "Testing behaviour if setting no source NDs");
myFilter->SetSourceNavigationDatas(emptyTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->IsEmpty() == true, "Testing behaviour if setting no target NDs");
// ------------------ setting one ND ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source points are generated from one source ND");
myFilter->SetTargetNavigationDatas(oneTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target points are generated from one target ND");
// ------------------ setting two NDs ------------------
myFilter->SetSourceNavigationDatas(twoSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 6, "Testing if 6 source points are generated from two source NDs");
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 6, "Testing if 6 target points are generated from two target NDs");
// ------------------ setting three NDs ------------------
myFilter->SetSourceNavigationDatas(threeSourceNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetSourceLandmarks()->GetSize() == 3, "Testing if 3 source NDs are passed to 3 source points");
myFilter->SetTargetNavigationDatas(threeTargetNDs);
MITK_TEST_CONDITION_REQUIRED(myFilter->GetTargetLandmarks()->GetSize() == 3, "Testing if 3 target NDs are passed to 3 target points");
// ------------------ setting different number of NDs for source and target ------------------
bool firstInitialize = myFilter->InitializeTransform();
myFilter->SetTargetNavigationDatas(twoTargetNDs);
MITK_TEST_CONDITION_REQUIRED((firstInitialize == true && myFilter->InitializeTransform() == false), "Testing if initialization is denied, if different number of source and target NDs are set");
// ------------------ reinit of this filter ------------------
bool sourcePointsSet = myFilter->GetSourceLandmarks()->GetSize() > 0;
bool targetPointsSet = myFilter->GetTargetLandmarks()->GetSize() > 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsSet && targetPointsSet, "Testing if there are source and target landmarks set in the superclass");
myFilter->ReinitFilter();
bool sourcePointsCleared = myFilter->GetSourceLandmarks()->GetSize() == 0;
bool targetPointsCleared = myFilter->GetTargetLandmarks()->GetSize() == 0;
MITK_TEST_CONDITION_REQUIRED(sourcePointsCleared && targetPointsCleared, "Testing if reinit of filter was successful");
// ------------------ testing the point generation ------------------
myFilter->SetSourceNavigationDatas(oneSourceNDs); // set the ND with sourcePos1 and sourceOri1 for that the points will be generated
itk::QuaternionRigidTransform<double>::Pointer quaternionTransform = itk::QuaternionRigidTransform<double>::New();
vnl_quaternion<double> const vnlQuatIn(sourceOri1.x(), sourceOri1.y(), sourceOri1.z(), sourceOri1.r());
quaternionTransform->SetRotation(vnlQuatIn);
mitk::Point3D pointA;
mitk::Point3D pointB;
mitk::Point3D pointC;
//initializing three points with position(0|0|0)
pointA.Fill(0);
pointB.Fill(0);
pointC.Fill(0);
// changing position off all points in order to make them orthogonal
pointA[0] = 1;
pointB[1] = 1;
pointC[2] = 1;
// quaternion transform the points
pointA = quaternionTransform->GetRotationMatrix() * pointA;
pointB = quaternionTransform->GetRotationMatrix() * pointB;
pointC = quaternionTransform->GetRotationMatrix() * pointC;
bool firstPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(0)[0] - pointA[0];
bool firstPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(0)[1] - pointA[1];
bool firstPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(0)[2] - pointA[2];
bool firstPointCorrect = firstPoint0Same && firstPoint1Same && firstPoint2Same;
bool secondPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(1)[0] - pointB[0];
bool secondPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(1)[1] - pointB[1];
bool secondPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(1)[2] - pointB[2];
bool secondPointCorrect = secondPoint0Same && secondPoint1Same && secondPoint2Same;
bool thirdPoint0Same = sourcePos1[0] == myFilter->GetSourceLandmarks()->GetPoint(2)[0] - pointC[0];
bool thirdPoint1Same = sourcePos1[1] == myFilter->GetSourceLandmarks()->GetPoint(2)[1] - pointC[1];
bool thirdPoint2Same = sourcePos1[2] == myFilter->GetSourceLandmarks()->GetPoint(2)[2] - pointC[2];
bool thirdPointCorrect = thirdPoint0Same && thirdPoint1Same && thirdPoint2Same;
//MITK_TEST_CONDITION_REQUIRED(firstPointCorrect && secondPointCorrect && thirdPointCorrect, "Testing if point generation is correct");
// deleting helper objects
myFilter = NULL;
quaternionTransform = NULL;
snd1 = NULL;
snd2 = NULL;
snd3 = NULL;
tnd1 = NULL;
tnd2 = NULL;
tnd3 = NULL;
// always end with this!
MITK_TEST_END();
}
/**Documentation
* test for the class "NavigationDataLandmarkTransformFilter".
*/
int mitkNavigationDataLandmarkTransformFilterTest(int /* argc */, char* /*argv*/[])
{
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););
