MITK-IGT
IGT Extension of MITK
Loading...
Searching...
No Matches
mitkToFDistanceImageToPointSetFilterTest.cpp
Go to the documentation of this file.
1/*============================================================================
2
3The Medical Imaging Interaction Toolkit (MITK)
4
5Copyright (c) German Cancer Research Center (DKFZ)
6All rights reserved.
7
8Use of this source code is governed by a 3-clause BSD license that can be
9found in the LICENSE file.
10
11============================================================================*/
12
13#include <mitkTestingMacros.h>
14#include <mitkToFDistanceImageToPointSetFilter.h>
15#include <mitkToFDistanceImageToSurfaceFilter.h>
16
17#include <mitkImage.h>
18#include <mitkImageCast.h>
19#include <mitkPointSet.h>
20#include <mitkSurface.h>
21#include <mitkToFProcessingCommon.h>
22#include <mitkToFTestingCommon.h>
23#include <mitkNumericTypes.h>
24#include <mitkImagePixelReadAccessor.h>
25
26#include <itkImage.h>
27#include <itkImageRegionIterator.h>
28
29#include <vtkPolyData.h>
30
34mitk::PointSet::Pointer CreateTestPointSet()
35{
36 mitk::PointSet::Pointer subSet = mitk::PointSet::New();
37 mitk::Point3D point;
38 point[0] = 10;
39 point[1] = 20;
40 point[2] = 0;
41 subSet->InsertPoint(0,point);
42 point[0] = 100;
43 point[1] = 150;
44 point[2] = 0;
45 subSet->InsertPoint(1,point);
46 point[0] = 110;
47 point[1] = 30;
48 point[2] = 0;
49 subSet->InsertPoint(2,point);
50 point[0] = 40;
51 point[1] = 200;
52 point[2] = 0;
53 subSet->InsertPoint(3,point);
54 return subSet;
55}
56
57std::vector<itk::Index<3> > CreateVectorPointSet()
58{
59 std::vector<itk::Index<3> > subSet = std::vector<itk::Index<3> >();
60 itk::Index<3> point;
61 point[0] = 10;
62 point[1] = 20;
63 point[2] = 0;
64 subSet.push_back(point);
65 point[0] = 100;
66 point[1] = 150;
67 point[2] = 0;
68 subSet.push_back(point);
69 point[0] = 110;
70 point[1] = 30;
71 point[2] = 0;
72 subSet.push_back(point);
73 point[0] = 40;
74 point[1] = 200;
75 point[2] = 0;
76 subSet.push_back(point);
77 return subSet;
78}
79
80// Create image with pixelValue in every pixel except for the pixels in subSet, which get successively the values of distances
81inline static mitk::Image::Pointer CreateTestImageWithPointSet(float pixelValue, unsigned int dimX, unsigned int dimY, mitk::PointSet::Pointer subSet)
82{
83 typedef itk::Image<float,2> ItkImageType2D;
84 typedef itk::ImageRegionIterator<ItkImageType2D> ItkImageRegionIteratorType2D;
85
86 ItkImageType2D::Pointer image = ItkImageType2D::New();
87 ItkImageType2D::IndexType start;
88 start[0] = 0;
89 start[1] = 0;
90 ItkImageType2D::SizeType size;
91 size[0] = dimX;
92 size[1] = dimY;
93 ItkImageType2D::RegionType region;
94 region.SetSize(size);
95 region.SetIndex( start);
96 ItkImageType2D::SpacingType spacing;
97 spacing[0] = 1.0;
98 spacing[1] = 1.0;
99
100 image->SetRegions( region );
101 image->SetSpacing ( spacing );
102 image->Allocate();
103
104 //Obtaining image data from ToF camera//
105
106 //Correlate inten values to PixelIndex//
107 ItkImageRegionIteratorType2D imageIterator(image,image->GetLargestPossibleRegion());
108 imageIterator.GoToBegin();
109
110 while (!imageIterator.IsAtEnd())
111 {
112 imageIterator.Set(pixelValue);
113 ++imageIterator;
114 }
115 // distances varying from pixelValue
116 std::vector<float> distances;
117 distances.push_back(50);
118 distances.push_back(500);
119 distances.push_back(2050);
120 distances.push_back(300);
121 // set the pixel values for the subset
122 for(int i=0; i<subSet->GetSize(); i++)
123 {
124 mitk::Point3D point = subSet->GetPoint(i);
125 ItkImageType2D::IndexType index;
126 index[0] = point[0];
127 index[1] = point[1];
128 float distance = distances.at(i);
129 image->SetPixel(index,distance);
130 }
131 mitk::Image::Pointer mitkImage = mitk::Image::New();
132 mitk::CastToMitkImage(image,mitkImage);
133 return mitkImage;
134}
135
136int mitkToFDistanceImageToPointSetFilterTest(int /* argc */, char* /*argv*/[])
137{
138 MITK_TEST_BEGIN("ToFDistanceImageToPointSetFilter");
139
140 mitk::ToFDistanceImageToPointSetFilter::Pointer filter = mitk::ToFDistanceImageToPointSetFilter::New();
141 //create test sub set
142 MITK_INFO<<"Create test pointset";
143 mitk::PointSet::Pointer subSet = CreateTestPointSet();
144 //create test image
145 unsigned int dimX = 204;
146 unsigned int dimY = 204;
147 MITK_INFO<<"Create test image";
148 mitk::Image::Pointer image = CreateTestImageWithPointSet(1000.0f,dimX,dimY,subSet);
149 //initialize intrinsic parameters
150 //initialize intrinsic parameters with some arbitrary values
151 mitk::ToFProcessingCommon::ToFPoint2D interPixelDistance;
152 interPixelDistance[0] = 0.04564;
153 interPixelDistance[1] = 0.0451564;
154
155 mitk::ToFProcessingCommon::ToFScalarType focalLengthX = 295.78960;
156 mitk::ToFProcessingCommon::ToFScalarType focalLengthY = 296.348535;
157
158 mitk::ToFProcessingCommon::ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
159 mitk::ToFProcessingCommon::ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
160
161 mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
162 principalPoint[0] = 103.576546;
163 principalPoint[1] = 100.1532;
164
165 mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
166 cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
167 cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
168 cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
169
170 // test SetCameraIntrinsics()
171 filter->SetCameraIntrinsics(cameraIntrinsics);
172 MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
173 mitk::ToFProcessingCommon::ToFPoint2D pp;
174 pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
175 pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
176 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
177
178 // test SetInterPixelDistance()
179 filter->SetInterPixelDistance(interPixelDistance);
180 mitk::ToFProcessingCommon::ToFPoint2D ipD = filter->GetInterPixelDistance();
181 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
182
183 // test SetReconstructionMode()
184 filter->SetReconstructionMode(false);
185 MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == false,"Testing Set/GetReconstructionMode()");
186
187 // test Set/GetInput()
188 filter->SetInput(image);
189 MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
190
191
192 // test filter without subset (without using the interpixeldistance)
193 MITK_INFO<<"Test filter without subset without using the interpixeldistance";
194 filter->SetReconstructionMode(true);
195 mitk::PointSet::Pointer expectedResult = mitk::PointSet::New();
196 unsigned int counter = 0;
197 mitk::ImagePixelReadAccessor<float,2> imageAcces(image, image->GetSliceData(0));
198 for (unsigned int j=0; j<dimY; j++)
199 {
200 for (unsigned int i=0; i<dimX; i++)
201 {
202 itk::Index<2> index;
203 index[0] = i;
204 index[1] = j;
205 float distance = imageAcces.GetPixelByIndex(index);
206 mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
207 expectedResult->InsertPoint(counter,coordinate);
208 counter++;
209 }
210 }
211 filter->Update();
212 mitk::PointSet::Pointer result = filter->GetOutput();
213 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
214 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
215
216 // compare filter result with ToFDistanceImageToSurfaceFilter
217 MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
218 mitk::ToFDistanceImageToSurfaceFilter::Pointer surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
219 surfaceFilter->SetInput(image);
220 surfaceFilter->SetInterPixelDistance(interPixelDistance);
221 surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
222 surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
223 MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
224 mitk::Surface::Pointer surface = surfaceFilter->GetOutput();
225 surface->Update();
226 // create point set from surface
227 mitk::PointSet::Pointer pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
228 //compare pointset against ground truth
229 MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
230 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
231
232 // test filter without subset (with using the interpixeldistance)
233 MITK_INFO<<"Test filter without subset with using the interpixeldistance";
234 filter->Modified();
235 filter->SetReconstructionMode(false);
236 expectedResult = mitk::PointSet::New();
237 counter = 0;
238 for (unsigned int j=0; j<dimY; j++)
239 {
240 for (unsigned int i=0; i<dimX; i++)
241 {
242 itk::Index<2> index;
243 index[0] = i;
244 index[1] = j;
245 float distance = imageAcces.GetPixelByIndex(index);
246 mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
247 expectedResult->InsertPoint(counter,coordinate);
248 counter++;
249 }
250 }
251 filter->Update();
252 result = filter->GetOutput();
253 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
254 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter without subset");
255
256 // compare filter result with ToFDistanceImageToSurfaceFilter
257 MITK_INFO<<"Compare filter result with ToFDistanceImageToSurfaceFilter";
258 surfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
259 surfaceFilter->SetInput(image);
260 surfaceFilter->SetInterPixelDistance(interPixelDistance);
261 surfaceFilter->SetCameraIntrinsics(cameraIntrinsics);
262 surfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
263 MITK_TEST_CONDITION_REQUIRED(surfaceFilter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
264 surface = surfaceFilter->GetOutput();
265 surface->Update();
266 // create point set from surface
267 pointSet = mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet(surface->GetVtkPolyData());
268 //compare against ground truth
269 MITK_TEST_CONDITION_REQUIRED((pointSet->GetSize()==result->GetSize()),"Test if point set size is equal");
270 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(pointSet,result),"Compare with surface points");
271
272
273 // test filter with subset (without using the interpixeldistance)
274 MITK_INFO<<"Test filter with subset without using the interpixeldistance";
275 filter = mitk::ToFDistanceImageToPointSetFilter::New();
276 filter->SetInput(image);
277 filter->SetInterPixelDistance(interPixelDistance);
278 filter->SetCameraIntrinsics(cameraIntrinsics);
279 filter->SetReconstructionMode(true);
280 expectedResult = mitk::PointSet::New();
281 counter = 0;
282 for(int i=0; i<subSet->GetSize(); i++)
283 {
284 mitk::Point3D point = subSet->GetPoint(i);
285 itk::Index<2> index;
286 index[0] = point[0];
287 index[1] = point[1];
288 float distance = imageAcces.GetPixelByIndex(index);
289 mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(point[0],point[1],
290 distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
291 expectedResult->InsertPoint(counter,coordinate);
292 counter++;
293 }
294 filter->SetSubset(subSet);
295 filter->Modified();
296 filter->Update();
297 result = filter->GetOutput();
298 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
299 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
300
301
302 // test filter with subset (with using the interpixeldistance)
303 MITK_INFO<<"Test filter with subset with using the interpixeldistance";
304 filter = mitk::ToFDistanceImageToPointSetFilter::New();
305 filter->SetInput(image);
306 filter->SetInterPixelDistance(interPixelDistance);
307 filter->SetCameraIntrinsics(cameraIntrinsics);
308 filter->SetReconstructionMode(false);
309 expectedResult = mitk::PointSet::New();
310 counter = 0;
311 for(int i=0; i<subSet->GetSize(); i++)
312 {
313 mitk::Point3D point = subSet->GetPoint(i);
314 itk::Index<2> index;
315 index[0] = point[0];
316 index[1] = point[1];
317 float distance = imageAcces.GetPixelByIndex(index);
318 mitk::Point3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(point[0],point[1],
319 distance,focalLength,interPixelDistance,principalPoint);
320 expectedResult->InsertPoint(counter,coordinate);
321 counter++;
322 }
323 filter->SetSubset(subSet);
324 filter->Modified();
325 filter->Update();
326 result = filter->GetOutput();
327 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetSize()==result->GetSize()),"Test if point set size is equal");
328 MITK_TEST_CONDITION_REQUIRED(mitk::ToFTestingCommon::PointSetsEqual(expectedResult,result),"Testing filter with subset");
329
330 // Test case to reproduce and check fix of bug 13933.
331 std::vector<itk::Index<3> > vecSubset = CreateVectorPointSet();
332 filter = mitk::ToFDistanceImageToPointSetFilter::New();
333 try
334 {
335 filter->SetSubset(vecSubset);
336 }
337 catch (...)
338 {
339 MITK_TEST_CONDITION_REQUIRED(false, "Caught an exception while setting point subset!");
340 }
341
342 MITK_TEST_END();
343}
mitk::ToFProcessingCommon::IndexToCartesianCoordinates
static ToFPoint3D IndexToCartesianCoordinates(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLengthX, ToFScalarType focalLengthY, ToFScalarType principalPointX, ToFScalarType principalPointY)
Convert index based distances to cartesian coordinates.
Definition mitkToFProcessingCommon.cpp:16
mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist
static ToFPoint3D IndexToCartesianCoordinatesWithInterpixdist(unsigned int i, unsigned int j, ToFScalarType distance, ToFScalarType focalLength, ToFScalarType interPixelDistanceX, ToFScalarType interPixelDistanceY, ToFScalarType principalPointX, ToFScalarType principalPointY)
Convert index based distances to cartesian coordinates.
Definition mitkToFProcessingCommon.cpp:70
mitk::ToFProcessingCommon::ToFPoint2D
itk::Point< ToFScalarType, 2 > ToFPoint2D
Definition mitkToFProcessingCommon.h:42
mitk::ToFTestingCommon::VtkPolyDataToMitkPointSet
static mitk::PointSet::Pointer VtkPolyDataToMitkPointSet(vtkSmartPointer< vtkPolyData > poly)
VtkPolyDataToMitkPointSet Converts a vtkPolyData into an mitkPointSet.
Definition mitkToFTestingCommon.h:81
mitk::ToFTestingCommon::PointSetsEqual
static bool PointSetsEqual(mitk::PointSet::Pointer pointSet1, mitk::PointSet::Pointer pointSet2)
PointSetsEqual Method two test if two point sets contain the same points. mitk::Equal is used for com...
Definition mitkToFTestingCommon.h:37
ItkImageRegionIteratorType2D
itk::ImageRegionIterator< ItkImageType_2D > ItkImageRegionIteratorType2D
Definition mitkToFCompositeFilterTest.cpp:38
ItkImageType2D
itk::Image< float, 2 > ItkImageType2D
Definition mitkToFCompositeFilter.h:21
CreateVectorPointSet
std::vector< itk::Index< 3 > > CreateVectorPointSet()
Definition mitkToFDistanceImageToPointSetFilterTest.cpp:57
CreateTestPointSet
mitk::PointSet::Pointer CreateTestPointSet()
Definition mitkToFDistanceImageToPointSetFilterTest.cpp:34
mitkToFDistanceImageToPointSetFilterTest
int mitkToFDistanceImageToPointSetFilterTest(int, char *[])
Definition mitkToFDistanceImageToPointSetFilterTest.cpp:136
mitk::Equal
MITKIGTBASE_EXPORT bool Equal(const mitk::NavigationData &leftHandSide, const mitk::NavigationData &rightHandSide, ScalarType eps=mitk::eps, bool verbose=false)
Equal A function comparing two navigation data objects for beeing equal in meta- and imagedata.
Definition mitkNavigationData.cpp:319