MITK-IGT
IGT Extension of MITK
Loading...
Searching...
No Matches
mitkToFDistanceImageToSurfaceFilterTest.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 <mitkToFDistanceImageToSurfaceFilter.h>
15
16#include <mitkImage.h>
17#include <mitkImagePixelReadAccessor.h>
18#include <mitkImageGenerator.h>
19#include <mitkSurface.h>
20#include <mitkToFProcessingCommon.h>
21#include <mitkNumericTypes.h>
22#include <mitkToFTestingCommon.h>
23#include <mitkIOUtil.h>
24
25#include <vtkPoints.h>
26#include <vtkPolyData.h>
27#include <vtkSmartPointer.h>
28
33typedef mitk::ToFProcessingCommon::ToFPoint2D ToFPoint2D;
34typedef mitk::ToFProcessingCommon::ToFPoint3D ToFPoint3D;
35typedef mitk::ToFProcessingCommon::ToFScalarType ToFScalarType;
36
37int mitkToFDistanceImageToSurfaceFilterTest(int /* argc */, char* /*argv*/[])
38{
39 MITK_TEST_BEGIN("ToFDistanceImageToSurfaceFilter");
40 mitk::ToFDistanceImageToSurfaceFilter::Pointer filter = mitk::ToFDistanceImageToSurfaceFilter::New();
41 // create test image
42 unsigned int dimX =204;
43 unsigned int dimY =204;
44 mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(dimX,dimY);
45 //initialize intrinsic parameters with some arbitrary values
46 ToFScalarType focalLengthX = 295.78960;
47 ToFScalarType focalLengthY = 296.348535;
48 ToFPoint2D focalLengthXY;
49 focalLengthXY[0]=focalLengthX;
50 focalLengthXY[1]=focalLengthY;
51 ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
52 ToFPoint2D principalPoint;
53 principalPoint[0] = 103.576546;
54 principalPoint[1] = 100.1532;
55 mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
56 cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
57 cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
58 cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
59 // test SetCameraIntrinsics()
60 filter->SetCameraIntrinsics(cameraIntrinsics);
61 MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
62 ToFPoint2D pp;
63 pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
64 pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
65 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
66 // test SetInterPixelDistance()
67 ToFPoint2D interPixelDistance;
68 interPixelDistance[0] = 0.04564;
69 interPixelDistance[1] = 0.0451564;
70 filter->SetInterPixelDistance(interPixelDistance);
71 ToFPoint2D ipD = filter->GetInterPixelDistance();
72 MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
73
74 // test SetReconstructionMode()
75 filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
76 MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
77
78 // test Set/GetInput()
79 filter->SetInput(image);
80 MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
81
82 // test filter without subset (without interpixeldistance)
83 MITK_INFO<<"Test filter with subset without interpixeldistance ";
84 filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
85 MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
86
87 vtkSmartPointer<vtkPoints> expectedResult = vtkSmartPointer<vtkPoints>::New();
88 expectedResult->SetDataTypeToDouble();
89 double* point = new double[3];
90// MITK_INFO<<"Test";
91// MITK_INFO<<"focal: "<<focalLength;
92// MITK_INFO<<"inter: "<<interPixelDistance;
93// MITK_INFO<<"prinicipal: "<<principalPoint;
94 for (unsigned int j=0; j<dimX; j++)
95 {
96 for (unsigned int i=0; i<dimY; i++)
97 {
98 itk::Index<2> index = { { static_cast<itk::IndexValueType>(i), static_cast< itk::IndexValueType >( j) } };
99 float distance = 0.0;
100
101 try
102 {
103 mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
104 distance = readAccess.GetPixelByIndex(index);
105 }
106 catch(mitk::Exception& e)
107 {
108 MITK_ERROR << "Image read exception!" << e.what();
109 }
110
111
112 ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
113// if ((i==0)&&(j==0))
114// {
115// MITK_INFO<<"Distance test: "<<distance;
116// MITK_INFO<<"coordinate test: "<<coordinate;
117// }
118 point[0] = coordinate[0];
119 point[1] = coordinate[1];
120 point[2] = coordinate[2];
121 unsigned int pointID = index[0] + index[1]*dimY;
122 //MITK_INFO<<"id: "<<pointID;
123 if (distance!=0)
124 {
125 expectedResult->InsertPoint(pointID,point);
126 }
127 }
128 }
129 filter->Update();
130 mitk::Surface::Pointer resultSurface = filter->GetOutput();
131 vtkSmartPointer<vtkPoints> result = vtkSmartPointer<vtkPoints>::New();
132 result->SetDataTypeToDouble();
133 result = resultSurface->GetVtkPolyData()->GetPoints();
134
135 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
136 bool pointSetsEqual = true;
137 for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
138 {
139 double* expected = expectedResult->GetPoint(i);
140 double* res = result->GetPoint(i);
141
142 ToFPoint3D expectedPoint;
143 expectedPoint[0] = expected[0];
144 expectedPoint[1] = expected[1];
145 expectedPoint[2] = expected[2];
146 ToFPoint3D resultPoint;
147 resultPoint[0] = res[0];
148 resultPoint[1] = res[1];
149 resultPoint[2] = res[2];
150
151 if (!mitk::Equal(expectedPoint,resultPoint))
152 {
153// MITK_INFO << i;
154 pointSetsEqual = false;
155 }
156 }
157 MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
158
159 // test filter without subset (with interpixeldistance)
160 MITK_INFO<<"Test filter with subset with interpixeldistance ";
161 filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
162 MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
163 // calculate focal length considering inter pixel distance
164 ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
165 expectedResult = vtkSmartPointer<vtkPoints>::New();
166 expectedResult->SetDataTypeToDouble();
167 point = new double[3];
168// MITK_INFO<<"Test";
169// MITK_INFO<<"focal: "<<focalLength;
170// MITK_INFO<<"inter: "<<interPixelDistance;
171// MITK_INFO<<"prinicipal: "<<principalPoint;
172 for (unsigned int j=0; j<dimX; j++)
173 {
174 for (unsigned int i=0; i<dimY; i++)
175 {
176 itk::Index<2> index = {{ static_cast<itk::IndexValueType >(i), static_cast< itk::IndexValueType >( j )}};
177 float distance = 0.0;
178 try
179 {
180 mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
181 distance = readAccess.GetPixelByIndex(index);
182 }
183 catch(mitk::Exception& e)
184 {
185 MITK_ERROR << "Image read exception!" << e.what();
186 }
187 ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
188// if ((i==0)&&(j==0))
189// {
190// MITK_INFO<<"Distance test: "<<distance;
191// MITK_INFO<<"coordinate test: "<<coordinate;
192// }
193 point[0] = coordinate[0];
194 point[1] = coordinate[1];
195 point[2] = coordinate[2];
196 unsigned int pointID = index[0] + index[1]*dimY;
197 //MITK_INFO<<"id: "<<pointID;
198 if (distance!=0)
199 {
200 expectedResult->InsertPoint(pointID,point);
201 }
202 }
203 }
204 filter->Modified();
205 filter->Update();
206 resultSurface = filter->GetOutput();
207 result = vtkSmartPointer<vtkPoints>::New();
208 result->SetDataTypeToDouble();
209 result = resultSurface->GetVtkPolyData()->GetPoints();
210 MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
211 pointSetsEqual = true;
212 for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
213 {
214 double* expected = expectedResult->GetPoint(i);
215 double* res = result->GetPoint(i);
216
217 ToFPoint3D expectedPoint;
218 expectedPoint[0] = expected[0];
219 expectedPoint[1] = expected[1];
220 expectedPoint[2] = expected[2];
221 ToFPoint3D resultPoint;
222 resultPoint[0] = res[0];
223 resultPoint[1] = res[1];
224 resultPoint[2] = res[2];
225
226 if (!mitk::Equal(expectedPoint,resultPoint))
227 {
228// MITK_INFO << i;
229 MITK_INFO<<"expected: "<<expectedPoint;
230 MITK_INFO<<"result: "<<resultPoint;
231 pointSetsEqual = false;
232 }
233 }
234 MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
235
236
237 //Backwardtransformation test without interpixeldistance
238 bool backwardTransformationsPointsEqual = true;
239 for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
240 {
241 double* expected = expectedResult->GetPoint(i);
242 double* res = result->GetPoint(i);
243
244 ToFPoint3D expectedPoint;
245 expectedPoint[0] = expected[0];
246 expectedPoint[1] = expected[1];
247 expectedPoint[2] = expected[2];
248 ToFPoint3D resultPoint;
249 resultPoint[0] = res[0];
250 resultPoint[1] = res[1];
251 resultPoint[2] = res[2];
252
253 ToFPoint3D expectedPointBackward =
254 mitk::ToFProcessingCommon::CartesianToIndexCoordinates(expectedPoint,focalLengthXY,principalPoint);
255
256 ToFPoint3D resultPointBackward =
257 mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
258
259 if (!mitk::Equal(expectedPointBackward,resultPointBackward))
260 {
261// MITK_INFO << i;
262// MITK_INFO<<"expected: "<<expectedPoint;
263// MITK_INFO<<"result: "<<resultPoint;
264 backwardTransformationsPointsEqual = false;
265 }
266 }
267 MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation without interpixeldistance");
268
269 //Backwardtransformation test with interpixeldistance
270 backwardTransformationsPointsEqual = true;
271 for ( int i=0; i<expectedResult->GetNumberOfPoints(); i++)
272 {
273 double* expected = expectedResult->GetPoint(i);
274 double* res = result->GetPoint(i);
275
276 ToFPoint3D expectedPoint;
277 expectedPoint[0] = expected[0];
278 expectedPoint[1] = expected[1];
279 expectedPoint[2] = expected[2];
280 ToFPoint3D resultPoint;
281 resultPoint[0] = res[0];
282 resultPoint[1] = res[1];
283 resultPoint[2] = res[2];
284
285 ToFPoint3D expectedPointBackward =
286 mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(expectedPoint,focalLength,interPixelDistance,principalPoint);
287
288 ToFPoint3D resultPointBackward =
289 mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
290
291 if (!mitk::Equal(expectedPointBackward,resultPointBackward))
292 {
293// MITK_INFO << i;
294// MITK_INFO<<"expected: "<<expectedPoint;
295// MITK_INFO<<"result: "<<resultPoint;
296 backwardTransformationsPointsEqual = false;
297 }
298 }
299 MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation with interpixeldistance");
300
301
302 //Backwardtransformation test compare to original input without interpixeldistance
303 bool compareToInput = true;
304 for ( int i=0; i<result->GetNumberOfPoints(); i++)
305 {
306 double* res = result->GetPoint(i);
307
308 ToFPoint3D resultPoint;
309 resultPoint[0] = res[0];
310 resultPoint[1] = res[1];
311 resultPoint[2] = res[2];
312
313 ToFPoint3D resultPointBackward =
314 mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
315
316 itk::Index<2> index = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
317 float distanceBackward = 0.0;
318
319 try
320 {
321 mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
322 distanceBackward = readAccess.GetPixelByIndex(index);
323 }
324 catch(mitk::Exception& e)
325 {
326 MITK_ERROR << "Image read exception!" << e.what();
327 }
328
329 if (!mitk::Equal(distanceBackward,(float) resultPointBackward[2]))
330 {
331 MITK_INFO<<"expected: " << resultPointBackward[2];
332 MITK_INFO<<"result: "<< distanceBackward;
333 compareToInput = false;
334 }
335 }
336 MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image without interpixeldistance");
337
338
339 //Backwardtransformation test compare to original input with interpixeldistance
340 compareToInput = true;
341 for ( int i=0; i<result->GetNumberOfPoints(); i++)
342 {
343 double* res = result->GetPoint(i);
344
345 ToFPoint3D resultPoint;
346 resultPoint[0] = res[0];
347 resultPoint[1] = res[1];
348 resultPoint[2] = res[2];
349
350 ToFPoint3D resultPointBackward =
351 mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
352
353 itk::Index<2> pixelIndex = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
354 float distanceBackward = 0.0;
355 try
356 {
357 mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
358 distanceBackward = readAccess.GetPixelByIndex(pixelIndex);
359 }
360 catch(mitk::Exception& e)
361 {
362 MITK_ERROR << "Image read exception!" << e.what();
363 }
364
365 if (!mitk::Equal(distanceBackward, (float) resultPointBackward[2]))
366 {
367 compareToInput = false;
368 }
369 }
370 MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image with interpixeldistance");
371
372 //clean up
373 delete[] point;
374 // expectedResult->Delete();
375
376 MITK_TEST_END();
377
378}
379
380
mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist
static ToFPoint3D CartesianToIndexCoordinatesWithInterpixdist(ToFScalarType cartesianPointX, ToFScalarType cartesianPointY, ToFScalarType cartesianPointZ, ToFScalarType focalLength, ToFScalarType interPixelDistanceX, ToFScalarType interPixelDistanceY, ToFScalarType principalPointX, ToFScalarType principalPointY, bool calculateDistance=true)
Convert cartesian coordinates to index based distances.
Definition mitkToFProcessingCommon.cpp:124
mitk::ToFProcessingCommon::CartesianToIndexCoordinates
static ToFPoint3D CartesianToIndexCoordinates(ToFScalarType cartesianPointX, ToFScalarType cartesianPointY, ToFScalarType cartesianPointZ, ToFScalarType focalLengthX, ToFScalarType focalLengthY, ToFScalarType principalPointX, ToFScalarType principalPointY, bool calculateDistance=true)
Convert cartesian coordinates to index based distances.
Definition mitkToFProcessingCommon.cpp:92
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::ToFProcessingCommon::ToFPoint3D
itk::Point< ToFScalarType, 3 > ToFPoint3D
Definition mitkToFProcessingCommon.h:43
ToFPoint2D
mitk::ToFProcessingCommon::ToFPoint2D ToFPoint2D
test for the class "ToFCompositeFilter".
Definition mitkToFCompositeFilterTest.cpp:34
ToFScalarType
mitk::ToFProcessingCommon::ToFScalarType ToFScalarType
Definition mitkToFDistanceImageToSurfaceFilterTest.cpp:35
mitkToFDistanceImageToSurfaceFilterTest
int mitkToFDistanceImageToSurfaceFilterTest(int, char *[])
Definition mitkToFDistanceImageToSurfaceFilterTest.cpp:37
ToFPoint3D
mitk::ToFProcessingCommon::ToFPoint3D ToFPoint3D
Definition mitkToFDistanceImageToSurfaceFilterTest.cpp:34
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