Debian Codegraph @

src/readers/aslVTKFormatReaders.cxx

raw
1 /*
2 * Advanced Simulation Library <http://asl.org.il>
3 *
4 * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5 *
6 *
7 * This file is part of Advanced Simulation Library (ASL).
8 *
9 * ASL is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU Affero General Public License as
11 * published by the Free Software Foundation, version 3 of the License.
12 *
13 * ASL is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Affero General Public License for more details.
17 *
18 * You should have received a copy of the GNU Affero General Public License
19 * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20 *
21 */
22
23
24 #include "aslVTKFormatReaders.h"
25 #include <acl/acl.h>
26 #include <acl/aclMath/aclVectorOfElements.h>
27 #include <utilities/aslVTKCasters.h>
28 #include <vtkMINCImageReader.h>
29 #include <vtkXMLImageDataReader.h>
30 #include <vtkStructuredPointsReader.h>
31 #include <vtkStructuredPoints.h>
32 #include <vtkDICOMImageReader.h>
33 #include <vtkImageData.h>
34 #include <vtkXMLPolyDataReader.h>
35 #include <vtkSTLReader.h>
36 #include <vtkImplicitModeller.h>
37 #include <boost/filesystem.hpp>
38 #include <data/aslDataWithGhostNodes.h>
39
40 using namespace boost::filesystem;
41
42 namespace asl
43 {
44 using namespace asl;
45
46 SPDataWithGhostNodesACLData readMINC(const string & fileName,
47 unsigned int arrayNum,
48 acl::CommandQueue queue)
49 {
50 vtkSmartPointer<vtkMINCImageReader> reader(vtkSmartPointer<vtkMINCImageReader>::New());
51 reader->RescaleRealValuesOn();
52 if (!reader->CanReadFile(fileName.c_str()))
53 errorMessage("MINC reader: The input file is corrupted or file name is wrong: " + fileName);
54 reader->SetFileName(fileName.c_str());
55 reader->Update();
56 auto data(makeData(reader->GetOutput(), arrayNum, queue));
57 return data;
58 }
59
60
61 SPDataWithGhostNodesACLData readVTKXML(const string & fileName,
62 unsigned int arrayNum,
63 acl::CommandQueue queue)
64 {
65 vtkSmartPointer<vtkXMLImageDataReader> reader(vtkSmartPointer<vtkXMLImageDataReader>::New());
66 if (!reader->CanReadFile(fileName.c_str()))
67 errorMessage("VTKXML reader: The input file is corrupted or file name is wrong: " + fileName);
68 reader->SetFileName(fileName.c_str());
69 reader->Update();
70 auto data(makeData(reader->GetOutput(), arrayNum, queue));
71 return data;
72 }
73
74
75 SPDataWithGhostNodesACLData readVTK(const string & fileName,
76 unsigned int arrayNum,
77 acl::CommandQueue queue)
78 {
79 vtkSmartPointer<vtkStructuredPointsReader> reader(vtkSmartPointer<vtkStructuredPointsReader>::New());
80 reader->SetFileName(fileName.c_str());
81 reader->Update();
82 if (!reader->IsFileStructuredPoints())
83 errorMessage("VTK reader: The input file is corrupted or file name is wrong: " + fileName);
84
85 auto data(makeData(vtkSmartPointer<vtkStructuredPoints>(reader->GetOutput()), arrayNum, queue));
86 return data;
87 }
88
89
90 SPDataWithGhostNodesACLData readDICOM(const string & fileName,
91 unsigned int arrayNum,
92 acl::CommandQueue queue)
93 {
94 vtkSmartPointer<vtkDICOMImageReader> reader(vtkSmartPointer<vtkDICOMImageReader>::New());
95 if (!reader->CanReadFile(fileName.c_str()))
96 errorMessage("DICOM reader: The input file is corrupted or file name is wrong: " + fileName);
97 reader->SetFileName(fileName.c_str());
98 reader->Update();
99 auto data(makeData(reader->GetOutput(), arrayNum, queue));
100 return data;
101 }
102
103
104 SPDataWithGhostNodesACLData read(const string & fileName,
105 unsigned int arrayNum,
106 acl::CommandQueue queue)
107 {
108 string fileExtension;
109 path pathToFile(fileName);
110 fileExtension = pathToFile.extension().string();
111
112 SPDataWithGhostNodesACLData data;
113
114 if (fileExtension == ".vtk")
115 data = readVTK(fileName, arrayNum, queue);
116
117 if (fileExtension == ".vti")
118 data = readVTKXML(fileName, arrayNum, queue);
119
120 if (fileExtension == ".mnc")
121 data = readMINC(fileName, arrayNum, queue);
122
123 if (fileExtension == ".dcm")
124 data = readDICOM(fileName, arrayNum, queue);
125
126 if (data.get() == 0)
127 errorMessage("Reader: file format not supported");
128
129 return data;
130 }
131
132 SPDataWithGhostNodesACLData surfaceToData(vtkDataSet* surf,
133 double dx,
134 acl::CommandQueue queue)
135 {
136 vtkSmartPointer<vtkImplicitModeller> modeller(vtkSmartPointer<vtkImplicitModeller>::New());
137 modeller->SetOutputScalarTypeToFloat();
138 modeller->CappingOff();
139 modeller->SetCapValue(dx*3.6);
140 modeller->SetInputData(surf);
141 modeller->ComputeModelBounds(surf);
142 modeller->SetMaximumDistance(dx*1.8*2.);
143 double b[6];
144 modeller->GetModelBounds (b);
145 modeller->SetSampleDimensions((b[1]-b[0]) / dx, (b[3]-b[2]) / dx, (b[5]-b[4]) / dx);
146 modeller->SetProcessModeToPerVoxel();
147 modeller->Update();
148
149 auto data(makeData(modeller->GetOutput(), 0, queue));
150 acl::initData(data->getEContainer(), (data->getEContainer() - dx*1.8)/dx/1.8);
151
152 return data;
153 }
154
155 SPDataWithGhostNodesACLData surfaceToData(vtkDataSet* surf,
156 Block & b,
157 acl::CommandQueue queue)
158 {
159 vtkSmartPointer<vtkImplicitModeller> modeller(vtkSmartPointer<vtkImplicitModeller>::New());
160 modeller->SetOutputScalarTypeToFloat();
161 modeller->CappingOff();
162 modeller->SetCapValue(b.dx*3.6);
163 modeller->SetInputData(surf);
164 modeller->SetMaximumDistance(b.dx*1.8*2.);
165 double bound[6];
166 auto bp(b.getBPosition());
167 bound[0]=b.position[2]; bound[1]=bp[2];
168 bound[2]=b.position[1]; bound[3]=bp[1];
169 bound[4]=b.position[0]; bound[5]=bp[0];
170 modeller->SetModelBounds (bound);
171 int s[3];
172 s[0] = b.getSize()[2];
173 s[1] = b.getSize()[1];
174 s[2] = b.getSize()[0];
175 modeller->SetSampleDimensions(s);
176 modeller->SetProcessModeToPerVoxel();
177 modeller->Update();
178
179 auto data(makeData(modeller->GetOutput(), 0, queue));
180 acl::initData(data->getEContainer(), (data->getEContainer() - b.dx*1.2)/b.dx/1.8);
181
182 return data;
183 }
184
185 SPDataWithGhostNodesACLData surfaceToData(vtkDataSet* surf,
186 double dx,
187 double offset_X0, double offset_XE,
188 double offset_Y0, double offset_YE,
189 double offset_Z0, double offset_ZE,
190 acl::CommandQueue queue)
191 {
192 vtkSmartPointer<vtkImplicitModeller> modeller(vtkSmartPointer<vtkImplicitModeller>::New());
193 modeller->SetOutputScalarTypeToFloat();
194 modeller->CappingOff();
195 modeller->SetCapValue(dx*3.6);
196 modeller->SetInputData(surf);
197 modeller->ComputeModelBounds(surf);
198 modeller->SetMaximumDistance(dx*1.8*2.);
199 double b[6];
200 modeller->GetModelBounds (b);
201 double bound[6];
202 bound[0]=b[0] - (b[1]-b[0])*offset_Z0; bound[1]=b[1] + (b[1]-b[0])*offset_ZE;
203 bound[2]=b[2] - (b[3]-b[2])*offset_Y0; bound[3]=b[3] + (b[3]-b[2])*offset_YE;
204 bound[4]=b[4] - (b[5]-b[4])*offset_X0; bound[5]=b[5] + (b[5]-b[4])*offset_XE;
205 modeller->SetModelBounds (bound);
206 modeller->SetSampleDimensions((bound[1]-bound[0]) / dx,
207 (bound[3]-bound[2]) / dx,
208 (bound[5]-bound[4]) / dx);
209 modeller->SetProcessModeToPerVoxel();
210 modeller->Update();
211
212 auto data(makeData(modeller->GetOutput(), 0, queue));
213 acl::initData(data->getEContainer(), (data->getEContainer() - dx*1.8)/dx/1.8);
214
215 return data;
216 }
217
218
219 SPDataWithGhostNodesACLData readSurfaceVTKXML(const string & fileName,
220 double dx,
221 acl::CommandQueue queue)
222 {
223 vtkSmartPointer<vtkXMLPolyDataReader> reader(vtkSmartPointer<vtkXMLPolyDataReader>::New());
224 if (!reader->CanReadFile(fileName.c_str()))
225 errorMessage("SurfaceVTKXML reader: The input file is corrupted or file name is wrong: " + fileName);
226 reader->SetFileName(fileName.c_str());
227 reader->Update();
228
229 return surfaceToData(reader->GetOutput(),dx,queue);
230 }
231
232 SPDataWithGhostNodesACLData readSurfaceVTKXML(const string & fileName,
233 Block & b,
234 acl::CommandQueue queue)
235 {
236 vtkSmartPointer<vtkXMLPolyDataReader> reader(vtkSmartPointer<vtkXMLPolyDataReader>::New());
237 if (!reader->CanReadFile(fileName.c_str()))
238 errorMessage("SurfaceVTKXML reader: The input file is corrupted or file name is wrong: " + fileName);
239 reader->SetFileName(fileName.c_str());
240 reader->Update();
241
242 return surfaceToData(reader->GetOutput(),b,queue);
243 }
244
245 SPDataWithGhostNodesACLData readSurfaceVTKXML(const string & fileName,
246 double dx,
247 double offset_X0, double offset_XE,
248 double offset_Y0, double offset_YE,
249 double offset_Z0, double offset_ZE,
250 acl::CommandQueue queue)
251 {
252 vtkSmartPointer<vtkXMLPolyDataReader> reader(vtkSmartPointer<vtkXMLPolyDataReader>::New());
253 if (!reader->CanReadFile(fileName.c_str()))
254 errorMessage("SurfaceVTKXML reader: The input file is corrupted or file name is wrong: " + fileName);
255 reader->SetFileName(fileName.c_str());
256 reader->Update();
257
258 return surfaceToData(reader->GetOutput(),
259 dx,
260 offset_X0, offset_XE,
261 offset_Y0, offset_YE,
262 offset_Z0, offset_ZE,
263 queue);
264 }
265
266 SPDataWithGhostNodesACLData readSurfaceSTL(const string & fileName,
267 double dx,
268 acl::CommandQueue queue)
269 {
270 vtkSmartPointer<vtkSTLReader> reader(vtkSmartPointer<vtkSTLReader>::New());
271 reader->SetFileName(fileName.c_str());
272 reader->Update();
273
274 return surfaceToData(reader->GetOutput(),dx,queue);
275 }
276
277 SPDataWithGhostNodesACLData readSurfaceSTL(const string & fileName,
278 Block & b,
279 acl::CommandQueue queue)
280 {
281 vtkSmartPointer<vtkSTLReader> reader(vtkSmartPointer<vtkSTLReader>::New());
282 reader->SetFileName(fileName.c_str());
283 reader->Update();
284
285 return surfaceToData(reader->GetOutput(),b,queue);
286 }
287
288 SPDataWithGhostNodesACLData readSurfaceSTL(const string & fileName,
289 double dx,
290 double offset_X0, double offset_XE,
291 double offset_Y0, double offset_YE,
292 double offset_Z0, double offset_ZE,
293 acl::CommandQueue queue)
294 {
295 vtkSmartPointer<vtkSTLReader> reader(vtkSmartPointer<vtkSTLReader>::New());
296 reader->SetFileName(fileName.c_str());
297 reader->Update();
298
299 return surfaceToData(reader->GetOutput(),
300 dx,
301 offset_X0, offset_XE,
302 offset_Y0, offset_YE,
303 offset_Z0, offset_ZE,
304 queue);
305 }
306
307 SPDataWithGhostNodesACLData readSurface(const string & fileName,
308 double dx,
309 acl::CommandQueue queue)
310 {
311 string fileExtension;
312 path pathToFile(fileName);
313 fileExtension = pathToFile.extension().string();
314
315 SPDataWithGhostNodesACLData data;
316
317 if (fileExtension == ".vtp")
318 data = readSurfaceVTKXML(fileName, dx, queue);
319
320 if (fileExtension == ".stl")
321 data = readSurfaceSTL(fileName, dx, queue);
322
323 if (data.get() == 0)
324 errorMessage("Reader: file format not supported");
325
326 return data;
327 }
328
329 SPDataWithGhostNodesACLData readSurface(const string & fileName,
330 Block & b,
331 acl::CommandQueue queue)
332 {
333 string fileExtension;
334 path pathToFile(fileName);
335 fileExtension = pathToFile.extension().string();
336
337 SPDataWithGhostNodesACLData data;
338
339 if (fileExtension == ".vtp")
340 data = readSurfaceVTKXML(fileName, b, queue);
341
342 if (fileExtension == ".stl")
343 data = readSurfaceSTL(fileName, b, queue);
344
345 if (data.get() == 0)
346 errorMessage("Reader: file format not supported");
347
348 return data;
349 }
350
351 SPDataWithGhostNodesACLData readSurface(const string & fileName,
352 double dx,
353 double offset_X0, double offset_XE,
354 double offset_Y0, double offset_YE,
355 double offset_Z0, double offset_ZE,
356 acl::CommandQueue queue)
357 {
358 string fileExtension;
359 path pathToFile(fileName);
360 fileExtension = pathToFile.extension().string();
361
362 SPDataWithGhostNodesACLData data;
363
364 if (fileExtension == ".vtp")
365 data = readSurfaceVTKXML(fileName,
366 dx,
367 offset_X0, offset_XE,
368 offset_Y0, offset_YE,
369 offset_Z0, offset_ZE,
370 queue);
371
372 if (fileExtension == ".stl")
373 data = readSurfaceSTL(fileName,
374 dx,
375 offset_X0, offset_XE,
376 offset_Y0, offset_YE,
377 offset_Z0, offset_ZE,
378 queue);
379
380 if (data.get() == 0)
381 errorMessage("Reader: file format not supported");
382
383 return data;
384 }
385
386 } //asl
387
388