diff --git a/Modules/ToFHardware/Testing/mitkToFOpenCVImageGrabberTest.cpp b/Modules/ToFHardware/Testing/mitkToFOpenCVImageGrabberTest.cpp
index 4de1245eb9..ae0467a08e 100644
--- a/Modules/ToFHardware/Testing/mitkToFOpenCVImageGrabberTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFOpenCVImageGrabberTest.cpp
@@ -1,100 +1,100 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFOpenCVImageGrabber.h>
#include <mitkImageDataItem.h>
#include <mitkPicFileReader.h>
#include <mitkToFCameraMITKPlayerDevice.h>
#include <mitkToFConfig.h>
#include <mitkImagePixelReadAccessor.h>
static bool CompareImages(mitk::Image::Pointer mitkImage, cv::Mat openCVImage)
{
float equal = true;
if ((mitkImage->GetDimension(0)!=openCVImage.cols)||(mitkImage->GetDimension(1)!=openCVImage.rows))
{
equal = false;
}
- mitk::ImagePixelReadAccessor<mitk::ScalarType,2> imageAcces(mitkImage, mitkImage->GetSliceData(0));
+ mitk::ImagePixelReadAccessor<float,2> imageAcces(mitkImage, mitkImage->GetSliceData(0));
for (unsigned int i=0; i<openCVImage.cols; i++)
{
for (unsigned 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;
}
/**Documentation
* test for the class "ToFOpenCVImageGrabber".
*/
int mitkToFOpenCVImageGrabberTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFOpenCVImageGrabber");
std::string dirName = MITK_TOF_DATA_DIR;
mitk::ToFImageGrabber::Pointer tofImageGrabber = mitk::ToFImageGrabber::New();
tofImageGrabber->SetCameraDevice(mitk::ToFCameraMITKPlayerDevice::New());
std::string distanceFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_DistanceImage.pic";
tofImageGrabber->SetProperty("DistanceImageFileName",mitk::StringProperty::New(distanceFileName));
std::string amplitudeFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_AmplitudeImage.pic";
tofImageGrabber->SetProperty("AmplitudeImageFileName",mitk::StringProperty::New(amplitudeFileName));
std::string intensityFileName = dirName + "/PMDCamCube2_MF0_IT0_1Images_IntensityImage.pic";
tofImageGrabber->SetProperty("IntensityImageFileName",mitk::StringProperty::New(intensityFileName));
mitk::PicFileReader::Pointer mitkFileReader = mitk::PicFileReader::New();
mitkFileReader->SetFileName(distanceFileName);
mitkFileReader->Update();
mitk::Image::Pointer image = mitkFileReader->GetOutput();
mitk::ToFOpenCVImageGrabber::Pointer tofOpenCVImageGrabber = mitk::ToFOpenCVImageGrabber::New();
tofOpenCVImageGrabber->SetToFImageGrabber(tofImageGrabber);
MITK_TEST_CONDITION_REQUIRED(tofImageGrabber==tofOpenCVImageGrabber->GetToFImageGrabber(),"Test Set/GetToFImageGrabber()");
MITK_TEST_OUTPUT(<<"Call StartCapturing()");
tofOpenCVImageGrabber->StartCapturing();
cv::Mat cvImage = tofOpenCVImageGrabber->GetImage();
MITK_TEST_CONDITION_REQUIRED(CompareImages(image,cvImage),"Test distance image");
mitkFileReader->SetFileName(amplitudeFileName);
mitkFileReader->Update();
image = mitkFileReader->GetOutput();
tofOpenCVImageGrabber->SetImageType(1);
cvImage = tofOpenCVImageGrabber->GetImage();
MITK_TEST_CONDITION_REQUIRED(CompareImages(image,cvImage),"Test amplitude image");
mitkFileReader->SetFileName(intensityFileName);
mitkFileReader->Update();
image = mitkFileReader->GetOutput();
tofOpenCVImageGrabber->SetImageType(2);
cvImage = tofOpenCVImageGrabber->GetImage();
MITK_TEST_CONDITION_REQUIRED(CompareImages(image,cvImage),"Test intensity image");
MITK_TEST_OUTPUT(<<"Call StopCapturing()");
tofOpenCVImageGrabber->StopCapturing();
MITK_TEST_END();
}
diff --git a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
index 7edac5e3b8..a698d5851d 100644
--- a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToPointSetFilterTest.cpp
@@ -1,309 +1,309 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFDistanceImageToPointSetFilter.h>
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkImage.h>
#include <mitkPointSet.h>
#include <mitkSurface.h>
#include <mitkToFProcessingCommon.h>
#include <mitkToFTestingCommon.h>
#include <mitkVector.h>
#include <mitkImagePixelReadAccessor.h>
#include <itkImage.h>
#include <itkImageRegionIterator.h>
#include <vtkPolyData.h>
/**Documentation
* test for the class "ToFDistanceImageToPointSetFilter".
*/
mitk::PointSet::Pointer CreateTestPointSet()
{
mitk::PointSet::Pointer subSet = mitk::PointSet::New();
mitk::Point3D point;
point[0] = 10;
point[1] = 20;
point[2] = 0;
subSet->InsertPoint(0,point);
point[0] = 100;
point[1] = 150;
point[2] = 0;
subSet->InsertPoint(1,point);
point[0] = 110;
point[1] = 30;
point[2] = 0;
subSet->InsertPoint(2,point);
point[0] = 40;
point[1] = 200;
point[2] = 0;
subSet->InsertPoint(3,point);
return subSet;
}
// Create image with pixelValue in every pixel except for the pixels in subSet, which get successively the values of distances
-inline static mitk::Image::Pointer CreateTestImageWithPointSet(mitk::ScalarType pixelValue, unsigned int dimX, unsigned int dimY, mitk::PointSet::Pointer subSet)
+inline static mitk::Image::Pointer CreateTestImageWithPointSet(float pixelValue, unsigned int dimX, unsigned int dimY, mitk::PointSet::Pointer subSet)
{
- typedef itk::Image<mitk::ScalarType,2> ItkImageType2D;
+ typedef itk::Image<float,2> ItkImageType2D;
typedef itk::ImageRegionIterator<ItkImageType2D> ItkImageRegionIteratorType2D;
ItkImageType2D::Pointer image = ItkImageType2D::New();
ItkImageType2D::IndexType start;
start[0] = 0;
start[1] = 0;
ItkImageType2D::SizeType size;
size[0] = dimX;
size[1] = dimY;
ItkImageType2D::RegionType region;
region.SetSize(size);
region.SetIndex( start);
ItkImageType2D::SpacingType spacing;
spacing[0] = 1.0;
spacing[1] = 1.0;
image->SetRegions( region );
image->SetSpacing ( spacing );
image->Allocate();
//Obtaining image data from ToF camera//
//Correlate inten values to PixelIndex//
ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion());
imageIterator.GoToBegin();
while (!imageIterator.IsAtEnd())
{
imageIterator.Set(pixelValue);
++imageIterator;
}
// distances varying from pixelValue
- std::vector<mitk::ScalarType> distances;
+ std::vector<float> distances;
distances.push_back(50);
distances.push_back(500);
distances.push_back(2050);
distances.push_back(300);
// set the pixel values for the subset
for(int i=0; i<subSet->GetSize(); i++)
{
mitk::Point3D point = subSet->GetPoint(i);
ItkImageType2D::IndexType index;
index[0] = point[0];
index[1] = point[1];
- mitk::ScalarType distance = distances.at(i);
+ float distance = distances.at(i);
image->SetPixel(index,distance);
}
mitk::Image::Pointer mitkImage = mitk::Image::New();
mitk::CastToMitkImage(image,mitkImage);
return mitkImage;
}
int mitkToFDistanceImageToPointSetFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFDistanceImageToPointSetFilter");
mitk::ToFDistanceImageToPointSetFilter::Pointer filter = mitk::ToFDistanceImageToPointSetFilter::New();
//create test sub set
MITK_INFO<<"Create test pointset";
mitk::PointSet::Pointer subSet = CreateTestPointSet();
//create test image
unsigned int dimX = 204;
unsigned int dimY = 204;
MITK_INFO<<"Create test image";
mitk::Image::Pointer image = CreateTestImageWithPointSet(1000.0f,dimX,dimY,subSet);
//initialize intrinsic parameters
//initialize intrinsic parameters with some arbitrary values
mitk::ToFProcessingCommon::ToFPoint2D interPixelDistance;
interPixelDistance[0] = 0.04564;
interPixelDistance[1] = 0.0451564;
mitk::ToFProcessingCommon::ToFScalarType focalLengthX = 295.78960;
mitk::ToFProcessingCommon::ToFScalarType focalLengthY = 296.348535;
mitk::ToFProcessingCommon::ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
mitk::ToFProcessingCommon::ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = 103.576546;
principalPoint[1] = 100.1532;
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
// test SetCameraIntrinsics()
filter->SetCameraIntrinsics(cameraIntrinsics);
MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
mitk::ToFProcessingCommon::ToFPoint2D pp;
pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
// test SetInterPixelDistance()
filter->SetInterPixelDistance(interPixelDistance);
mitk::ToFProcessingCommon::ToFPoint2D ipD = filter->GetInterPixelDistance();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
// test SetReconstructionMode()
filter->SetReconstructionMode(false);
MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == false,"Testing Set/GetReconstructionMode()");
// test Set/GetInput()
filter->SetInput(image);
MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
// test filter without subset (without using the interpixeldistance)
MITK_INFO<<"Test filter without subset without using the interpixeldistance";
filter->SetReconstructionMode(true);
mitk::PointSet::Pointer expectedResult = mitk::PointSet::New();
unsigned int counter = 0;
- mitk::ImagePixelReadAccessor<mitk::ScalarType,2> imageAcces(image, image->GetSliceData(0));
+ mitk::ImagePixelReadAccessor<float,2> imageAcces(image, image->GetSliceData(0));
for (unsigned int j=0; j<dimY; j++)
{
for (unsigned int i=0; i<dimX; i++)
{
itk::Index<2> index;
index[0] = i;
index[1] = j;
- mitk::ScalarType distance = imageAcces.GetPixelByIndex(index);
+ float distance = imageAcces.GetPixelByIndex(index);
mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
expectedResult->InsertPoint(counter,coordinate);
counter++;
}
}
filter->Update();
mitk::PointSet::Pointer result = filter->GetOutput();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
// compare filter result with ToFDistanceImageToSurfaceFilter
MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
mitk::ToFDistanceImageToSurfaceFilter::Pointer surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
surfaceFilter->SetInput(image);
surfaceFilter->SetInterPixelDistance(interPixelDistance);
surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
surface->Update();
// create point set from surface
mitk::PointSet::Pointer pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
//compare pointset against ground truth
MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
// test filter without subset (with using the interpixeldistance)
MITK_INFO<<"Test filter without subset with using the interpixeldistance";
filter->Modified();
filter->SetReconstructionMode(false);
expectedResult = mitk::PointSet::New();
counter = 0;
for (unsigned int j=0; j<dimY; j++)
{
for (unsigned int i=0; i<dimX; i++)
{
itk::Index<2> index;
index[0] = i;
index[1] = j;
- mitk::ScalarType distance = imageAcces.GetPixelByIndex(index);
+ float distance = imageAcces.GetPixelByIndex(index);
mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
expectedResult->InsertPoint(counter,coordinate);
counter++;
}
}
filter->Update();
result = filter->GetOutput();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
// compare filter result with ToFDistanceImageToSurfaceFilter
MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
surfaceFilter->SetInput(image);
surfaceFilter->SetInterPixelDistance(interPixelDistance);
surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
MITK_TEST_CONDITION_REQUIRED(surfaceFilter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
surface = surfaceFilter->GetOutput();
surface->Update();
// create point set from surface
pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
//compare against ground truth
MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
// test filter with subset (without using the interpixeldistance)
MITK_INFO<<"Test filter with subset without using the interpixeldistance";
filter = mitk::ToFDistanceImageToPointSetFilter::New();
filter->SetInput(image);
filter->SetInterPixelDistance(interPixelDistance);
filter->SetCameraIntrinsics(cameraIntrinsics);
filter->SetReconstructionMode(true);
expectedResult = mitk::PointSet::New();
counter = 0;
for(int i=0; i<subSet->GetSize(); i++)
{
mitk::Point3D point = subSet->GetPoint(i);
itk::Index<2> index;
index[0] = point[0];
index[1] = point[1];
- mitk::ScalarType distance = imageAcces.GetPixelByIndex(index);
+ float distance = imageAcces.GetPixelByIndex(index);
mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(point[0],point[1],
distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
expectedResult->InsertPoint(counter,coordinate);
counter++;
}
filter->SetSubset(subSet);
filter->Modified();
filter->Update();
result = filter->GetOutput();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
// test filter with subset (with using the interpixeldistance)
MITK_INFO<<"Test filter with subset with using the interpixeldistance";
filter = mitk::ToFDistanceImageToPointSetFilter::New();
filter->SetInput(image);
filter->SetInterPixelDistance(interPixelDistance);
filter->SetCameraIntrinsics(cameraIntrinsics);
filter->SetReconstructionMode(false);
expectedResult = mitk::PointSet::New();
counter = 0;
for(int i=0; i<subSet->GetSize(); i++)
{
mitk::Point3D point = subSet->GetPoint(i);
itk::Index<2> index;
index[0] = point[0];
index[1] = point[1];
- mitk::ScalarType distance = imageAcces.GetPixelByIndex(index);
+ float distance = imageAcces.GetPixelByIndex(index);
mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(point[0],point[1],
distance,focalLength,interPixelDistance,principalPoint);
expectedResult->InsertPoint(counter,coordinate);
counter++;
}
filter->SetSubset(subSet);
filter->Modified();
filter->Update();
result = filter->GetOutput();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
MITK_TEST_END();
}
diff --git a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
index 2d56b24d90..3971189dd9 100644
--- a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
@@ -1,392 +1,392 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkImage.h>
#include <mitkImagePixelReadAccessor.h>
#include <mitkImageGenerator.h>
#include <mitkSurface.h>
#include <mitkToFProcessingCommon.h>
#include <mitkVector.h>
#include <mitkToFTestingCommon.h>
#include <mitkIOUtil.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
/**
* @brief Test for the class "ToFDistanceImageToSurfaceFilter".
*/
typedef mitk::ToFProcessingCommon::ToFPoint2D ToFPoint2D;
typedef mitk::ToFProcessingCommon::ToFPoint3D ToFPoint3D;
typedef mitk::ToFProcessingCommon::ToFScalarType ToFScalarType;
int mitkToFDistanceImageToSurfaceFilterTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFDistanceImageToSurfaceFilter");
mitk::ToFDistanceImageToSurfaceFilter::Pointer filter = mitk::ToFDistanceImageToSurfaceFilter::New();
// create test image
unsigned int dimX =204;
unsigned int dimY =204;
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(dimX,dimY);
//initialize intrinsic parameters with some arbitrary values
ToFScalarType focalLengthX = 295.78960;
ToFScalarType focalLengthY = 296.348535;
ToFPoint2D focalLengthXY;
focalLengthXY[0]=focalLengthX;
focalLengthXY[1]=focalLengthY;
ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
ToFPoint2D principalPoint;
principalPoint[0] = 103.576546;
principalPoint[1] = 100.1532;
mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
// test SetCameraIntrinsics()
filter->SetCameraIntrinsics(cameraIntrinsics);
MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
ToFPoint2D pp;
pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
// test SetInterPixelDistance()
ToFPoint2D interPixelDistance;
interPixelDistance[0] = 0.04564;
interPixelDistance[1] = 0.0451564;
filter->SetInterPixelDistance(interPixelDistance);
ToFPoint2D ipD = filter->GetInterPixelDistance();
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
// test SetReconstructionMode()
filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
// test Set/GetInput()
filter->SetInput(image);
MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
// test filter without subset (without interpixeldistance)
MITK_INFO<<"Test filter with subset without interpixeldistance ";
filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
vtkSmartPointer<vtkPoints> expectedResult = vtkSmartPointer<vtkPoints>::New();
expectedResult->SetDataTypeToDouble();
unsigned int counter = 0;
double* point = new double[3];
// MITK_INFO<<"Test";
// MITK_INFO<<"focal: "<<focalLength;
// MITK_INFO<<"inter: "<<interPixelDistance;
// MITK_INFO<<"prinicipal: "<<principalPoint;
for (unsigned int j=0; j<dimX; j++)
{
for (unsigned int i=0; i<dimY; i++)
{
itk::Index<2> index = {{ i, j }};
float distance = 0.0;
try
{
mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
distance = readAccess.GetPixelByIndex(index);
}
catch(mitk::Exception& e)
{
MITK_ERROR << "Image read exception!" << e.what();
}
ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
// if ((i==0)&&(j==0))
// {
// MITK_INFO<<"Distance test: "<<distance;
// MITK_INFO<<"coordinate test: "<<coordinate;
// }
point[0] = coordinate[0];
point[1] = coordinate[1];
point[2] = coordinate[2];
unsigned int pointID = index[0] + index[1]*dimY;
//MITK_INFO<<"id: "<<pointID;
//MITK_INFO<<"counter: "<<counter;
if (distance!=0)
{
expectedResult->InsertPoint(pointID,point);
}
counter++;
}
}
filter->Update();
mitk::Surface::Pointer resultSurface = filter->GetOutput();
vtkSmartPointer<vtkPoints> result = vtkSmartPointer<vtkPoints>::New();
result->SetDataTypeToDouble();
result = resultSurface->GetVtkPolyData()->GetPoints();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
bool pointSetsEqual = true;
for (unsigned int i=0; i<expectedResult->GetNumberOfPoints(); i++)
{
double* expected = expectedResult->GetPoint(i);
double* res = result->GetPoint(i);
ToFPoint3D expectedPoint;
expectedPoint[0] = expected[0];
expectedPoint[1] = expected[1];
expectedPoint[2] = expected[2];
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
if (!mitk::Equal(expectedPoint,resultPoint))
{
// MITK_INFO << i;
pointSetsEqual = false;
}
}
MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
// test filter without subset (with interpixeldistance)
MITK_INFO<<"Test filter with subset with interpixeldistance ";
filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
// calculate focal length considering inter pixel distance
ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
expectedResult = vtkSmartPointer<vtkPoints>::New();
expectedResult->SetDataTypeToDouble();
counter = 0;
point = new double[3];
// MITK_INFO<<"Test";
// MITK_INFO<<"focal: "<<focalLength;
// MITK_INFO<<"inter: "<<interPixelDistance;
// MITK_INFO<<"prinicipal: "<<principalPoint;
for (unsigned int j=0; j<dimX; j++)
{
for (unsigned int i=0; i<dimY; i++)
{
itk::Index<2> index = {{ i, j }};
float distance = 0.0;
try
{
mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
distance = readAccess.GetPixelByIndex(index);
}
catch(mitk::Exception& e)
{
MITK_ERROR << "Image read exception!" << e.what();
}
ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
// if ((i==0)&&(j==0))
// {
// MITK_INFO<<"Distance test: "<<distance;
// MITK_INFO<<"coordinate test: "<<coordinate;
// }
point[0] = coordinate[0];
point[1] = coordinate[1];
point[2] = coordinate[2];
unsigned int pointID = index[0] + index[1]*dimY;
//MITK_INFO<<"id: "<<pointID;
//MITK_INFO<<"counter: "<<counter;
if (distance!=0)
{
expectedResult->InsertPoint(pointID,point);
}
counter++;
}
}
filter->Modified();
filter->Update();
resultSurface = filter->GetOutput();
result = vtkSmartPointer<vtkPoints>::New();
result->SetDataTypeToDouble();
result = resultSurface->GetVtkPolyData()->GetPoints();
MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
pointSetsEqual = true;
for (unsigned int i=0; i<expectedResult->GetNumberOfPoints(); i++)
{
double* expected = expectedResult->GetPoint(i);
double* res = result->GetPoint(i);
ToFPoint3D expectedPoint;
expectedPoint[0] = expected[0];
expectedPoint[1] = expected[1];
expectedPoint[2] = expected[2];
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
if (!mitk::Equal(expectedPoint,resultPoint))
{
// MITK_INFO << i;
MITK_INFO<<"expected: "<<expectedPoint;
MITK_INFO<<"result: "<<resultPoint;
pointSetsEqual = false;
}
}
MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
//Backwardtransformation test without interpixeldistance
bool backwardTransformationsPointsEqual = true;
for (unsigned int i=0; i<expectedResult->GetNumberOfPoints(); i++)
{
double* expected = expectedResult->GetPoint(i);
double* res = result->GetPoint(i);
ToFPoint3D expectedPoint;
expectedPoint[0] = expected[0];
expectedPoint[1] = expected[1];
expectedPoint[2] = expected[2];
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
ToFPoint3D expectedPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinates(expectedPoint,focalLengthXY,principalPoint);
ToFPoint3D resultPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
if (!mitk::Equal(expectedPointBackward,resultPointBackward))
{
// MITK_INFO << i;
// MITK_INFO<<"expected: "<<expectedPoint;
// MITK_INFO<<"result: "<<resultPoint;
backwardTransformationsPointsEqual = false;
}
}
MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation without interpixeldistance");
//Backwardtransformation test with interpixeldistance
backwardTransformationsPointsEqual = true;
for (unsigned int i=0; i<expectedResult->GetNumberOfPoints(); i++)
{
double* expected = expectedResult->GetPoint(i);
double* res = result->GetPoint(i);
ToFPoint3D expectedPoint;
expectedPoint[0] = expected[0];
expectedPoint[1] = expected[1];
expectedPoint[2] = expected[2];
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
ToFPoint3D expectedPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(expectedPoint,focalLength,interPixelDistance,principalPoint);
ToFPoint3D resultPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
if (!mitk::Equal(expectedPointBackward,resultPointBackward))
{
// MITK_INFO << i;
// MITK_INFO<<"expected: "<<expectedPoint;
// MITK_INFO<<"result: "<<resultPoint;
backwardTransformationsPointsEqual = false;
}
}
MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation with interpixeldistance");
//Backwardtransformation test compare to original input without interpixeldistance
bool compareToInput = true;
for (unsigned int i=0; i<result->GetNumberOfPoints(); i++)
{
double* res = result->GetPoint(i);
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
ToFPoint3D resultPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
itk::Index<2> index = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
float distanceBackward = 0.0;
try
{
mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
distanceBackward = readAccess.GetPixelByIndex(index);
}
catch(mitk::Exception& e)
{
MITK_ERROR << "Image read exception!" << e.what();
}
- if (!mitk::Equal(distanceBackward,resultPointBackward[2]))
+ if (!mitk::Equal(distanceBackward,(float) resultPointBackward[2]))
{
-// MITK_INFO<<"expected: "<< image->GetPixelValueByIndex(pixelIndex);
-// MITK_INFO<<"result: "<< resultPoint;
+ MITK_INFO<<"expected: " << resultPointBackward[2];
+ MITK_INFO<<"result: "<< distanceBackward;
compareToInput = false;
}
}
MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image without interpixeldistance");
//Backwardtransformation test compare to original input with interpixeldistance
compareToInput = true;
for (unsigned int i=0; i<result->GetNumberOfPoints(); i++)
{
double* res = result->GetPoint(i);
ToFPoint3D resultPoint;
resultPoint[0] = res[0];
resultPoint[1] = res[1];
resultPoint[2] = res[2];
ToFPoint3D resultPointBackward =
mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
itk::Index<2> pixelIndex = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
float distanceBackward = 0.0;
try
{
mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
distanceBackward = readAccess.GetPixelByIndex(pixelIndex);
}
catch(mitk::Exception& e)
{
MITK_ERROR << "Image read exception!" << e.what();
}
- if (!mitk::Equal(distanceBackward,resultPointBackward[2]))
+ if (!mitk::Equal(distanceBackward, (float) resultPointBackward[2]))
{
// MITK_INFO<<"expected: "<< image->GetPixelValueByIndex(pixelIndex);
// MITK_INFO<<"result: "<< resultPoint;
compareToInput = false;
}
}
MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image with interpixeldistance");
//clean up
delete point;
// expectedResult->Delete();
MITK_TEST_END();
}
diff --git a/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp b/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
index 152194cf14..c7c914d4b1 100644
--- a/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFProcessingCommonTest.cpp
@@ -1,91 +1,91 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTestingMacros.h>
#include <mitkToFProcessingCommon.h>
#include <mitkLogMacros.h>
/**Documentation
* test for the class "ToFProcessingCommon".
*/
int mitkToFProcessingCommonTest(int /* argc */, char* /*argv*/[])
{
MITK_TEST_BEGIN("ToFProcessingCommon");
unsigned int i = 10;
unsigned int j = 50;
- mitk::ScalarType distance = 1000;
- mitk::ScalarType focalLength = 10;
+ float distance = 1000;
+ float focalLength = 10;
mitk::Point2D focalLength_XY;
focalLength_XY[0] = 200;
focalLength_XY[1] = 200;
mitk::Point2D interPixelDistance;
interPixelDistance[0] = 0.05;
interPixelDistance[1] = 0.05;
mitk::Point2D principalPoint;
principalPoint[0] = 100;
principalPoint[1] = 100;
// expected coordinate
mitk::ToFProcessingCommon::ToFPoint3D expectedCoordinate;
expectedCoordinate[0] = -400.0988;
expectedCoordinate[1] = -222.2771;
expectedCoordinate[2] = 889.1084;
// resulting coordinate without using the interpixeldistance
mitk::ToFProcessingCommon::ToFPoint3D resultingCoordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLength_XY,principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedCoordinate,resultingCoordinate,1e-3),"Testing IndexToCartesianCoordinates()");
// resulting coordinate with using the interpixeldistance
mitk::ToFProcessingCommon::ToFPoint3D resultingCoordinateInterpix = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedCoordinate,resultingCoordinateInterpix,1e-3),"Testing IndexToCartesianCoordinatesWithInterpixdist()");
// expected index
mitk::ToFProcessingCommon::ToFPoint3D expectedIndex;
expectedIndex[0] = i;
expectedIndex[1] = j;
expectedIndex[2] = 1000;
mitk::ToFProcessingCommon::ToFPoint3D resultingIndex = mitk::ToFProcessingCommon::CartesianToIndexCoordinates(expectedCoordinate,focalLength_XY,principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,resultingIndex,1e-3),"Testing CartesianToIndexCoordinates()");
mitk::ToFProcessingCommon::ToFPoint3D resultingIndexInterpix = mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(expectedCoordinate,focalLength,interPixelDistance,principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,resultingIndexInterpix,1e-3),"Testing CartesianToIndexCoordinatesWithInterpixdist()");
//########## Kinect Reconstruction #############
mitk::ToFProcessingCommon::ToFPoint3D expectedKinectCoordinate;
expectedKinectCoordinate[0] = -450.0;
expectedKinectCoordinate[1] = -250.0;
expectedKinectCoordinate[2] = 1000.0;
mitk::Index3D index;
index[0] = i;
index[1] = j;
index[2] = 0;
mitk::ToFProcessingCommon::ToFPoint3D kinectReconstructionResult = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(index,distance, focalLength_XY,principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedKinectCoordinate,kinectReconstructionResult),"Compare the expected result with the result of reconstruction from KinectIndexToCartesianCoordinates()");
mitk::ToFProcessingCommon::ToFPoint3D kinectReconstructionResultBackward = mitk::ToFProcessingCommon::CartesianToKinectIndexCoordinates(kinectReconstructionResult, focalLength_XY, principalPoint);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedIndex,kinectReconstructionResultBackward),"Transform everything back to distance image and compare it to the original input");
mitk::Point2D continuousIndex;
continuousIndex[0] = i;
continuousIndex[1] = j;
mitk::ToFProcessingCommon::ToFPoint3D continuousKinectReconstructionResult = mitk::ToFProcessingCommon::ContinuousKinectIndexToCartesianCoordinates(continuousIndex,distance, focalLength_XY[0], focalLength_XY[1], principalPoint[0], principalPoint[1]);
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(expectedKinectCoordinate,continuousKinectReconstructionResult),"Compare the expected result with the result of reconstruction from ContinuousKinectIndexToCartesianCoordinates(). Since the index is not continuous, the result has to be the same like for KinectIndexToCartesianCoordinates().");
//########## End Kinect Reconstruction #############
MITK_TEST_END();
}
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
index aa6f4ab8c6..dd2ea7853e 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
@@ -1,211 +1,211 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkToFDistanceImageToPointSetFilter.h"
#include "mitkImageDataItem.h"
#include "mitkPointSet.h"
#include <mitkImagePixelReadAccessor.h>
#include "mitkToFProcessingCommon.h"
mitk::ToFDistanceImageToPointSetFilter::ToFDistanceImageToPointSetFilter()
: m_Subset(NULL), m_CameraIntrinsics(), m_InterPixelDistance()
{
m_InterPixelDistance.Fill(0.045);
m_CameraIntrinsics = mitk::CameraIntrinsics::New();
m_CameraIntrinsics->SetFocalLength(5.9421434211923247e+02,5.9104053696870778e+02);
m_CameraIntrinsics->SetPrincipalPoint(3.3930780975300314e+02,2.4273913761751615e+02);
m_CameraIntrinsics->SetDistorsionCoeffs(-0.36874385358645773f,-0.14339503290129013,0.0033210108720361795,-0.004277703352074105);
m_ReconstructionMode = true;
}
mitk::ToFDistanceImageToPointSetFilter::~ToFDistanceImageToPointSetFilter()
{
}
void mitk::ToFDistanceImageToPointSetFilter::SetInput(const mitk::Image* distanceImage )
{
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToPointSetFilter::SetInput( unsigned int idx,const mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
{
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
}
else
{
this->ProcessObject::SetNthInput(idx, const_cast<mitk::Image*>(distanceImage)); // Process object is not const-correct so the const_cast is required here
this->CreateOutputsForAllInputs();
}
}
mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFDistanceImageToPointSetFilter::SetSubset(std::vector<mitk::Index3D> subset)
{
// check if points of PointSet are inside the input image
mitk::Image::Pointer input = this->GetInput();
unsigned int xDim = input->GetDimension(0);
unsigned int yDim = input->GetDimension(1);
bool pointSetValid = true;
for (unsigned int i=0; i<subset.size(); i++)
{
mitk::Index3D currentIndex = subset.at(i);
if (currentIndex[0]<0||currentIndex[0]>xDim||currentIndex[1]<0||currentIndex[1]>yDim)
{
pointSetValid = false;
}
}
if (pointSetValid)
{
m_Subset = subset;
}
else
{
MITK_ERROR<<"One or more indizes are located outside the image domain";
}
}
void mitk::ToFDistanceImageToPointSetFilter::SetSubset( mitk::PointSet::Pointer pointSet)
{
std::vector<mitk::Index3D> subset;
for (int i=0; i<pointSet->GetSize(); i++)
{
mitk::Point3D currentPoint = pointSet->GetPoint(i);
mitk::Index3D currentIndex;
currentIndex[0] = currentPoint[0];
currentIndex[1] = currentPoint[1];
currentIndex[2] = currentPoint[2];
subset.push_back(currentIndex);
}
this->SetSubset(subset);
}
void mitk::ToFDistanceImageToPointSetFilter::GenerateData()
{
//calculate world coordinates
mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
if (m_ReconstructionMode)
{
focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
}
else
focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
mitk::PointSet::Pointer output = this->GetOutput();
assert(output);
mitk::Image::Pointer input = this->GetInput();
assert(input);
//compute subset of points if input PointSet is defined
if (m_Subset.size()!=0)
{
- mitk::ImagePixelReadAccessor<mitk::ScalarType,2> imageAcces(input, input->GetSliceData(0));
+ mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->GetSliceData(0));
for (unsigned int i=0; i<m_Subset.size(); i++)
{
mitk::Index3D currentIndex = m_Subset.at(i);
itk::Index<2> index2D;
index2D[0] = currentIndex[0];
index2D[1] = currentIndex[1];
mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(index2D);
mitk::Point3D currentPoint;
if (m_ReconstructionMode)
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(currentIndex,distance,focalLengthInPixelUnits,principalPoint);
else
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(currentIndex,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
output->InsertPoint(i,currentPoint);
}
}
else //compute PointSet holding cartesian coordinates for every image point
{
int xDimension = (int)input->GetDimension(0);
int yDimension = (int)input->GetDimension(1);
int pointCount = 0;
- mitk::ImagePixelReadAccessor<mitk::ScalarType,2> imageAcces(input, input->GetSliceData(0));
+ mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->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;
if (m_ReconstructionMode)
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthInPixelUnits,principalPoint);
else
currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
if (distance>mitk::eps)
{
output->InsertPoint( pointCount, currentPoint );
pointCount++;
}
}
}
}
}
void mitk::ToFDistanceImageToPointSetFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFDistanceImageToPointSetFilter::GenerateOutputInformation()
{
this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ToFDistanceImageToPointSetFilter::SetReconstructionMode(bool withoutInterpixdist)
{
this->m_ReconstructionMode = withoutInterpixdist;
}
bool mitk::ToFDistanceImageToPointSetFilter::GetReconstructionMode()
{
return (this->m_ReconstructionMode);
}
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
index 7b5e48ca80..46cdc6b870 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
@@ -1,345 +1,345 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkInstantiateAccessFunctions.h>
#include <mitkSurface.h>
#include "mitkImageReadAccessor.h"
#include <itkImage.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPointData.h>
#include <vtkFloatArray.h>
#include <vtkSmartPointer.h>
#include <vtkIdList.h>
#include <math.h>
#include <vtkMath.h>
mitk::ToFDistanceImageToSurfaceFilter::ToFDistanceImageToSurfaceFilter() :
m_IplScalarImage(NULL), m_CameraIntrinsics(), m_TextureImageWidth(0), m_TextureImageHeight(0), m_InterPixelDistance(), m_TextureIndex(0),
m_GenerateTriangularMesh(true), m_TriangulationThreshold(0.0)
{
m_InterPixelDistance.Fill(0.045);
m_CameraIntrinsics = mitk::CameraIntrinsics::New();
m_CameraIntrinsics->SetFocalLength(273.138946533,273.485900879);
m_CameraIntrinsics->SetPrincipalPoint(107.867935181,98.3807373047);
m_CameraIntrinsics->SetDistorsionCoeffs(-0.486690014601f,0.553943634033f,0.00222016777843f,-0.00300851115026f);
m_ReconstructionMode = WithInterPixelDistance;
}
mitk::ToFDistanceImageToSurfaceFilter::~ToFDistanceImageToSurfaceFilter()
{
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
{
this->SetCameraIntrinsics(cameraIntrinsics);
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx, Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
{
this->SetCameraIntrinsics(cameraIntrinsics);
this->SetInput(idx,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( mitk::Image* distanceImage )
{
this->SetInput(0,distanceImage);
}
void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx, mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
else
this->ProcessObject::SetNthInput(idx, distanceImage); // Process object is not const-correct so the const_cast is required here
this->CreateOutputsForAllInputs();
}
mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
{
mitkThrow() << "No input given for ToFDistanceImageToSurfaceFilter";
}
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFDistanceImageToSurfaceFilter::GenerateData()
{
mitk::Surface::Pointer output = this->GetOutput();
assert(output);
mitk::Image::Pointer input = this->GetInput();
assert(input);
// mesh points
int xDimension = input->GetDimension(0);
int yDimension = input->GetDimension(1);
unsigned int size = xDimension*yDimension; //size of the image-array
std::vector<bool> isPointValid;
isPointValid.resize(size);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->SetDataTypeToDouble();
vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkFloatArray> scalarArray = vtkSmartPointer<vtkFloatArray>::New();
vtkSmartPointer<vtkFloatArray> textureCoords = vtkSmartPointer<vtkFloatArray>::New();
textureCoords->SetNumberOfComponents(2);
textureCoords->Allocate(size);
//Make a vtkIdList to save the ID's of the polyData corresponding to the image
//pixel ID's. See below for more documentation.
m_VertexIdList = vtkSmartPointer<vtkIdList>::New();
//Allocate the object once else it would automatically allocate new memory
//for every vertex and perform a copy which is expensive.
m_VertexIdList->Allocate(size);
m_VertexIdList->SetNumberOfIds(size);
for(unsigned int i = 0; i < size; ++i)
{
m_VertexIdList->SetId(i, 0);
}
- ScalarType* scalarFloatData = NULL;
+ float* scalarFloatData = NULL;
if (this->m_IplScalarImage) // if scalar image is defined use it for texturing
{
- scalarFloatData = (ScalarType*)this->m_IplScalarImage->imageData;
+ scalarFloatData = (float*)this->m_IplScalarImage->imageData;
}
else if (this->GetInput(m_TextureIndex)) // otherwise use intensity image (input(2))
{
ImageReadAccessor inputAcc(this->GetInput(m_TextureIndex));
- scalarFloatData = (ScalarType*)inputAcc.GetData();
+ scalarFloatData = (float*)inputAcc.GetData();
}
ImageReadAccessor inputAcc(input, input->GetSliceData(0,0,0));
- ScalarType* inputFloatData = (ScalarType*)inputAcc.GetData();
+ float* inputFloatData = (float*)inputAcc.GetData();
//calculate world coordinates
mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
if((m_ReconstructionMode == WithOutInterPixelDistance) || (m_ReconstructionMode == Kinect))
{
focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
}
else if( m_ReconstructionMode == WithInterPixelDistance)
{
//convert focallength from pixel to mm
focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
}
mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
mitk::Point3D origin = input->GetGeometry()->GetOrigin();
for (int j=0; j<yDimension; j++)
{
for (int i=0; i<xDimension; i++)
{
unsigned int pixelID = i+j*xDimension;
mitk::ToFProcessingCommon::ToFScalarType distance = (double)inputFloatData[pixelID];
mitk::ToFProcessingCommon::ToFPoint3D cartesianCoordinates;
switch (m_ReconstructionMode)
{
case WithOutInterPixelDistance:
{
cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i+origin[0],j+origin[1],distance,focalLengthInPixelUnits,principalPoint);
break;
}
case WithInterPixelDistance:
{
cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i+origin[0],j+origin[1],distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
break;
}
case Kinect:
{
cartesianCoordinates = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(i+origin[0],j+origin[1],distance,focalLengthInPixelUnits,principalPoint);
break;
}
default:
{
MITK_ERROR << "Incorrect reconstruction mode!";
}
}
- //Epsilon here, because we may have small ScalarType values like 0.00000001 which in fact represents 0.
+ //Epsilon here, because we may have small float values like 0.00000001 which in fact represents 0.
if (distance<=mitk::eps)
{
isPointValid[pixelID] = false;
}
else
{
isPointValid[pixelID] = true;
//VTK would insert empty points into the polydata if we use
//points->InsertPoint(pixelID, cartesianCoordinates.GetDataPointer()).
//If we use points->InsertNextPoint(...) instead, the ID's do not
//correspond to the image pixel ID's. Thus, we have to save them
//in the vertexIdList.
m_VertexIdList->SetId(pixelID, points->InsertNextPoint(cartesianCoordinates.GetDataPointer()));
if (m_GenerateTriangularMesh)
{
if((i >= 1) && (j >= 1))
{
//This little piece of art explains the ID's:
//
// P(x_1y_1)---P(xy_1)
// | |
// | |
// | |
// P(x_1y)-----P(xy)
//
//We can only start triangulation if we are at vertex (1,1),
//because we need the other 3 vertices near this one.
//To go one pixel line back in the image array, we have to
//subtract 1x xDimension.
vtkIdType xy = pixelID;
vtkIdType x_1y = pixelID-1;
vtkIdType xy_1 = pixelID-xDimension;
vtkIdType x_1y_1 = xy_1-1;
//Find the corresponding vertex ID's in the saved vertexIdList:
vtkIdType xyV = m_VertexIdList->GetId(xy);
vtkIdType x_1yV = m_VertexIdList->GetId(x_1y);
vtkIdType xy_1V = m_VertexIdList->GetId(xy_1);
vtkIdType x_1y_1V = m_VertexIdList->GetId(x_1y_1);
if (isPointValid[xy]&&isPointValid[x_1y]&&isPointValid[x_1y_1]&&isPointValid[xy_1]) // check if points of cell are valid
{
double pointXY[3], pointX_1Y[3], pointXY_1[3], pointX_1Y_1[3];
points->GetPoint(xyV, pointXY);
points->GetPoint(x_1yV, pointX_1Y);
points->GetPoint(xy_1V, pointXY_1);
points->GetPoint(x_1y_1V, pointX_1Y_1);
if( (mitk::Equal(m_TriangulationThreshold, 0.0)) || ((vtkMath::Distance2BetweenPoints(pointXY, pointX_1Y) <= m_TriangulationThreshold)
&& (vtkMath::Distance2BetweenPoints(pointXY, pointXY_1) <= m_TriangulationThreshold)
&& (vtkMath::Distance2BetweenPoints(pointX_1Y, pointX_1Y_1) <= m_TriangulationThreshold)
&& (vtkMath::Distance2BetweenPoints(pointXY_1, pointX_1Y_1) <= m_TriangulationThreshold)))
{
polys->InsertNextCell(3);
polys->InsertCellPoint(x_1yV);
polys->InsertCellPoint(xyV);
polys->InsertCellPoint(x_1y_1V);
polys->InsertNextCell(3);
polys->InsertCellPoint(x_1y_1V);
polys->InsertCellPoint(xyV);
polys->InsertCellPoint(xy_1V);
}
else
{
//We dont want triangulation, but we want to keep the vertex
vertices->InsertNextCell(1);
vertices->InsertCellPoint(xyV);
}
}
//Scalar values are necessary for mapping colors/texture onto the surface
if (scalarFloatData)
{
scalarArray->InsertTuple1(m_VertexIdList->GetId(pixelID), scalarFloatData[pixelID]);
}
//These Texture Coordinates will map color pixel and vertices 1:1 (e.g. for Kinect).
- ScalarType xNorm = (((ScalarType)i)/xDimension);// correct video texture scale for kinect
- ScalarType yNorm = ((ScalarType)j)/yDimension; //don't flip. we don't need to flip.
+ float xNorm = (((float)i)/xDimension);// correct video texture scale for kinect
+ float yNorm = ((float)j)/yDimension; //don't flip. we don't need to flip.
textureCoords->InsertTuple2(m_VertexIdList->GetId(pixelID), xNorm, yNorm);
}
}
else
{
//We dont want triangulation, we only want vertices
vertices->InsertNextCell(1);
vertices->InsertCellPoint(m_VertexIdList->GetId(pixelID));
}
}
}
}
vtkSmartPointer<vtkPolyData> mesh = vtkSmartPointer<vtkPolyData>::New();
mesh->SetPoints(points);
mesh->SetPolys(polys);
mesh->SetVerts(vertices);
//Pass the scalars to the polydata (if they were set).
if (scalarArray->GetNumberOfTuples()>0)
{
mesh->GetPointData()->SetScalars(scalarArray);
}
//Pass the TextureCoords to the polydata anyway (to save them).
mesh->GetPointData()->SetTCoords(textureCoords);
output->SetVtkPolyData(mesh);
}
void mitk::ToFDistanceImageToSurfaceFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFDistanceImageToSurfaceFilter::GenerateOutputInformation()
{
this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ToFDistanceImageToSurfaceFilter::SetScalarImage(IplImage* iplScalarImage)
{
this->m_IplScalarImage = iplScalarImage;
this->Modified();
}
IplImage* mitk::ToFDistanceImageToSurfaceFilter::GetScalarImage()
{
return this->m_IplScalarImage;
}
void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageWidth(int width)
{
this->m_TextureImageWidth = width;
}
void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageHeight(int height)
{
this->m_TextureImageHeight = height;
}
void mitk::ToFDistanceImageToSurfaceFilter::SetTriangulationThreshold(double triangulationThreshold)
{
//vtkMath::Distance2BetweenPoints returns the squared distance between two points and
//hence we square m_TriangulationThreshold in order to save run-time.
this->m_TriangulationThreshold = triangulationThreshold*triangulationThreshold;
}