static bool CompareImages(mitk::Image::Pointer mitkImage, cv::Mat openCVImage)
{
float equal = true;
if (static_cast<int>(mitkImage->GetDimension(0)) != openCVImage.cols || static_cast<int>(mitkImage->GetDimension(1)) != openCVImage.rows)
{
equal = false;
}
mitk::ImagePixelReadAccessor<float,2> imageAcces(mitkImage, mitkImage->GetSliceData(0));
for(int i=0; i<openCVImage.cols; i++)
{
for(int j=0; j<openCVImage.rows; j++)
{
itk::Index<2> currentIndex;
currentIndex[0] = i;
currentIndex[1] = j;
float mitkImageValue = imageAcces.GetPixelByIndex(currentIndex);
float openCVImageValue = openCVImage.at<float>(j,i);
if (!mitk::Equal(mitkImageValue,openCVImageValue))
{
equal = false;
}
}
}
return equal;
}
/**
* @brief mitkKinectReconstructionTest Testing method for the Kinect reconstruction mode. Specially meant for Kinect.
* This tests loads a special data set from MITK-Data and compares it to a reference surface.
* This test has no dependency to the mitkKinectModule, although it is thematically connected to it.
*/
int mitkKinectReconstructionTest(int argc , char* argv[])
{
MITK_TEST_BEGIN("mitkKinectReconstructionTest");
MITK_TEST_CONDITION_REQUIRED(argc > 2, "Testing if enough arguments are set.");
std::string calibrationFilePath(argv[1]);
std::string kinectImagePath(argv[2]);
mitk::ToFDistanceImageToSurfaceFilter::Pointer distToSurf = mitk::ToFDistanceImageToSurfaceFilter::New();
mitk::CameraIntrinsics::Pointer intrinsics = mitk::CameraIntrinsics::New();
//load our personal kinect calibration
intrinsics->FromXMLFile(calibrationFilePath);
MITK_TEST_CONDITION_REQUIRED(intrinsics.IsNotNull(), "Testing if a calibration file could be loaded.");
distToSurf->SetCameraIntrinsics(intrinsics);
distToSurf->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
//load a data set
mitk::Image::Pointer kinectImage = mitk::IOUtil::LoadImage(kinectImagePath);
MITK_TEST_CONDITION_REQUIRED(kinectImage.IsNotNull(), "Testing if a kinect image could be loaded.");
distToSurf->SetInput(kinectImage);
distToSurf->Update();
mitk::Surface::Pointer resultOfFilter = distToSurf->GetOutput();
MITK_TEST_CONDITION_REQUIRED(resultOfFilter.IsNotNull(), "Testing if any output was generated.");
mitk::PointSet::Pointer resultPointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(resultOfFilter->GetVtkPolyData());
// generate ground truth data
mitk::PointSet::Pointer groundTruthPointSet = mitk::PointSet::New();
mitk::ToFProcessingCommon::ToFPoint2D focalLength;
focalLength[0] = intrinsics->GetFocalLengthX();
focalLength[1] = intrinsics->GetFocalLengthY();
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = intrinsics->GetPrincipalPointX();
principalPoint[1] = intrinsics->GetPrincipalPointY();
int xDimension = (int)kinectImage->GetDimension(0);
int yDimension = (int)kinectImage->GetDimension(1);
int pointCount = 0;
mitk::ImagePixelReadAccessor<float,2> imageAcces(kinectImage, kinectImage->GetSliceData(0));
for (int j=0; j<yDimension; j++)
{
for (int i=0; i<xDimension; i++)
{
itk::Index<2> pixel;
pixel[0] = i;
pixel[1] = j;
mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(pixel);
mitk::Point3D currentPoint;
currentPoint = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(i,j,distance,focalLength[0],focalLength[1],principalPoint[0],principalPoint[1]);
if (distance>mitk::eps)
{
groundTruthPointSet->InsertPoint( pointCount, currentPoint );
pointCount++;
}
}
}
MITK_TEST_CONDITION_REQUIRED( mitk::ToFTestingCommon::PointSetsEqual(resultPointSet,groundTruthPointSet),
"Testing if point sets are equal (with a small epsilon).");
MITK_TEST_END();
}
