← Back to branch summary

~ubuntu-branches/debian/sid/simpleitk/sid

« back to all changes in this revision

Viewing changes to Code/IO/src/sitkImportImageFilter.cxx

  • Committer: Package Import Robot
  • Author(s): Ghislain Antony Vaillant
  • Date: 2017-11-02 08:49:18 UTC
  • Revision ID: package-import@ubuntu.com-20171102084918-7hs09ih668xq87ej
Tags: upstream-1.0.1
Import upstream version 1.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Code/IO/src/sitkImportImageFilter.cxx
 
1
/*=========================================================================
 
2
*
 
3
*  Copyright Insight Software Consortium
 
4
*
 
5
*  Licensed under the Apache License, Version 2.0 (the "License");
 
6
*  you may not use this file except in compliance with the License.
 
7
*  You may obtain a copy of the License at
 
8
*
 
9
*         http://www.apache.org/licenses/LICENSE-2.0.txt
 
10
*
 
11
*  Unless required by applicable law or agreed to in writing, software
 
12
*  distributed under the License is distributed on an "AS IS" BASIS,
 
13
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
14
*  See the License for the specific language governing permissions and
 
15
*  limitations under the License.
 
16
*
 
17
*=========================================================================*/
 
18
#ifdef _MFC_VER
 
19
#pragma warning(disable:4996)
 
20
#endif
 
21
 
 
22
#include "sitkImportImageFilter.h"
 
23
#include "sitkExceptionObject.h"
 
24
 
 
25
#include <itkImage.h>
 
26
#include <itkVectorImage.h>
 
27
 
 
28
#include <iterator>
 
29
 
 
30
// private namespace
 
31
namespace
 
32
{
 
33
const unsigned int UnusedDimension = 2;
 
34
}
 
35
 
 
36
namespace itk {
 
37
namespace simple {
 
38
 
 
39
Image ImportAsInt8(
 
40
    int8_t * buffer,
 
41
    const std::vector< unsigned int > &size,
 
42
    const std::vector< double > &spacing,
 
43
    const std::vector< double > &origin,
 
44
    const std::vector< double > &direction,
 
45
    unsigned int numberOfComponents
 
46
) {
 
47
    ImportImageFilter import;
 
48
    import.SetSize( size );
 
49
    import.SetSpacing( spacing );
 
50
    import.SetOrigin( origin );
 
51
    import.SetDirection( direction );
 
52
    import.SetBufferAsInt8( buffer, numberOfComponents );
 
53
    return import.Execute();
 
54
}
 
55
 
 
56
Image ImportAsUInt8(
 
57
    uint8_t * buffer,
 
58
    const std::vector< unsigned int > &size,
 
59
    const std::vector< double > &spacing,
 
60
    const std::vector< double > &origin,
 
61
    const std::vector< double > &direction,
 
62
    unsigned int numberOfComponents
 
63
) {
 
64
    ImportImageFilter import;
 
65
    import.SetSize( size );
 
66
    import.SetSpacing( spacing );
 
67
    import.SetOrigin( origin );
 
68
    import.SetDirection( direction );
 
69
    import.SetBufferAsUInt8( buffer, numberOfComponents );
 
70
    return import.Execute();
 
71
}
 
72
 
 
73
Image ImportAsInt16(
 
74
    int16_t * buffer,
 
75
    const std::vector< unsigned int > &size,
 
76
    const std::vector< double > &spacing,
 
77
    const std::vector< double > &origin,
 
78
    const std::vector< double > &direction,
 
79
    unsigned int numberOfComponents
 
80
) {
 
81
    ImportImageFilter import;
 
82
    import.SetSize( size );
 
83
    import.SetSpacing( spacing );
 
84
    import.SetOrigin( origin );
 
85
    import.SetDirection( direction );
 
86
    import.SetBufferAsInt16( buffer, numberOfComponents );
 
87
    return import.Execute();
 
88
}
 
89
 
 
90
Image ImportAsUInt16(
 
91
    uint16_t * buffer,
 
92
    const std::vector< unsigned int > &size,
 
93
    const std::vector< double > &spacing,
 
94
    const std::vector< double > &origin,
 
95
    const std::vector< double > &direction,
 
96
    unsigned int numberOfComponents
 
97
) {
 
98
    ImportImageFilter import;
 
99
    import.SetSize( size );
 
100
    import.SetSpacing( spacing );
 
101
    import.SetOrigin( origin );
 
102
    import.SetDirection( direction );
 
103
    import.SetBufferAsUInt16( buffer, numberOfComponents );
 
104
    return import.Execute();
 
105
}
 
106
 
 
107
Image ImportAsInt32(
 
108
    int32_t * buffer,
 
109
    const std::vector< unsigned int > &size,
 
110
    const std::vector< double > &spacing,
 
111
    const std::vector< double > &origin,
 
112
    const std::vector< double > &direction,
 
113
    unsigned int numberOfComponents
 
114
) {
 
115
    ImportImageFilter import;
 
116
    import.SetSize( size );
 
117
    import.SetSpacing( spacing );
 
118
    import.SetOrigin( origin );
 
119
    import.SetDirection( direction );
 
120
    import.SetBufferAsInt32( buffer, numberOfComponents );
 
121
    return import.Execute();
 
122
}
 
123
 
 
124
Image ImportAsUInt32(
 
125
    uint32_t * buffer,
 
126
    const std::vector< unsigned int > &size,
 
127
    const std::vector< double > &spacing,
 
128
    const std::vector< double > &origin,
 
129
    const std::vector< double > &direction,
 
130
    unsigned int numberOfComponents
 
131
) {
 
132
    ImportImageFilter import;
 
133
    import.SetSize( size );
 
134
    import.SetSpacing( spacing );
 
135
    import.SetOrigin( origin );
 
136
    import.SetDirection( direction );
 
137
    import.SetBufferAsUInt32( buffer, numberOfComponents );
 
138
    return import.Execute();
 
139
}
 
140
 
 
141
Image ImportAsInt64(
 
142
    int64_t * buffer,
 
143
    const std::vector< unsigned int > &size,
 
144
    const std::vector< double > &spacing,
 
145
    const std::vector< double > &origin,
 
146
    const std::vector< double > &direction,
 
147
    unsigned int numberOfComponents
 
148
) {
 
149
    ImportImageFilter import;
 
150
    import.SetSize( size );
 
151
    import.SetSpacing( spacing );
 
152
    import.SetOrigin( origin );
 
153
    import.SetDirection( direction );
 
154
    import.SetBufferAsInt64( buffer, numberOfComponents );
 
155
    return import.Execute();
 
156
}
 
157
 
 
158
Image ImportAsUInt64(
 
159
    uint64_t * buffer,
 
160
    const std::vector< unsigned int > &size,
 
161
    const std::vector< double > &spacing,
 
162
    const std::vector< double > &origin,
 
163
    const std::vector< double > &direction,
 
164
    unsigned int numberOfComponents
 
165
) {
 
166
    ImportImageFilter import;
 
167
    import.SetSize( size );
 
168
    import.SetSpacing( spacing );
 
169
    import.SetOrigin( origin );
 
170
    import.SetDirection( direction );
 
171
    import.SetBufferAsUInt64( buffer, numberOfComponents );
 
172
    return import.Execute();
 
173
}
 
174
 
 
175
Image ImportAsFloat(
 
176
    float * buffer,
 
177
    const std::vector< unsigned int > &size,
 
178
    const std::vector< double > &spacing,
 
179
    const std::vector< double > &origin,
 
180
    const std::vector< double > &direction,
 
181
    unsigned int numberOfComponents
 
182
) {
 
183
    ImportImageFilter import;
 
184
    import.SetSize( size );
 
185
    import.SetSpacing( spacing );
 
186
    import.SetOrigin( origin );
 
187
    import.SetDirection( direction );
 
188
    import.SetBufferAsFloat( buffer, numberOfComponents );
 
189
    return import.Execute();
 
190
}
 
191
 
 
192
Image ImportAsDouble(
 
193
    double * buffer,
 
194
    const std::vector< unsigned int > &size,
 
195
    const std::vector< double > &spacing,
 
196
    const std::vector< double > &origin,
 
197
    const std::vector< double > &direction,
 
198
    unsigned int numberOfComponents
 
199
) {
 
200
    ImportImageFilter import;
 
201
    import.SetSize( size );
 
202
    import.SetSpacing( spacing );
 
203
    import.SetOrigin( origin );
 
204
    import.SetDirection( direction );
 
205
    import.SetBufferAsDouble( buffer, numberOfComponents );
 
206
    return import.Execute();
 
207
}
 
208
 
 
209
ImportImageFilter::ImportImageFilter()
 
210
{
 
211
  m_NumberOfComponentsPerPixel = 0;
 
212
  m_PixelIDValue = sitkUnknown;
 
213
  m_Origin = std::vector<double>( 3, 0.0 );
 
214
  m_Spacing = std::vector<double>( 3, 1.0 );
 
215
  this->m_Buffer = NULL;
 
216
 
 
217
  // list of pixel types supported
 
218
  typedef NonLabelPixelIDTypeList PixelIDTypeList;
 
219
 
 
220
  this->m_MemberFactory.reset( new detail::MemberFunctionFactory<MemberFunctionType>( this ) );
 
221
 
 
222
  this->m_MemberFactory->RegisterMemberFunctions< PixelIDTypeList, 4 > ();
 
223
  this->m_MemberFactory->RegisterMemberFunctions< PixelIDTypeList, 3 > ();
 
224
  this->m_MemberFactory->RegisterMemberFunctions< PixelIDTypeList, 2 > ();
 
225
      
 
226
}
 
227
 
 
228
ImportImageFilter::Self& ImportImageFilter::SetSpacing( const std::vector< double > &spacing )
 
229
{
 
230
  this->m_Spacing = spacing;
 
231
  return *this;
 
232
}
 
233
 
 
234
const std::vector< double > &ImportImageFilter::GetSpacing( ) const
 
235
{
 
236
  return this->m_Spacing;
 
237
}
 
238
 
 
239
ImportImageFilter::Self& ImportImageFilter::SetOrigin( const std::vector< double > &origin )
 
240
{
 
241
  this->m_Origin = origin;
 
242
  return *this;
 
243
}
 
244
 
 
245
const std::vector< double > &ImportImageFilter::GetOrigin( ) const
 
246
{
 
247
  return this->m_Origin;
 
248
}
 
249
 
 
250
ImportImageFilter::Self& ImportImageFilter::SetSize( const std::vector< unsigned int > &size )
 
251
{
 
252
  this->m_Size = size;
 
253
  return *this;
 
254
}
 
255
 
 
256
const std::vector< unsigned int > &ImportImageFilter::GetSize( ) const
 
257
{
 
258
  return this->m_Size;
 
259
}
 
260
 
 
261
ImportImageFilter::Self& ImportImageFilter::SetDirection( const std::vector< double > &direction )
 
262
{
 
263
  this->m_Direction = direction;
 
264
  return *this;
 
265
}
 
266
 
 
267
const std::vector< double > &ImportImageFilter::GetDirection( ) const
 
268
{
 
269
  return this->m_Direction;
 
270
}
 
271
 
 
272
ImportImageFilter::Self& ImportImageFilter::SetBufferAsInt8( int8_t * buffer, unsigned int numberOfComponents )
 
273
{
 
274
  this->m_Buffer = buffer;
 
275
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
276
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
277
    {
 
278
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<int8_t, UnusedDimension> >::Result;
 
279
    }
 
280
  else
 
281
    {
 
282
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<int8_t, UnusedDimension> >::Result;
 
283
    }
 
284
  return *this;
 
285
}
 
286
ImportImageFilter::Self& ImportImageFilter::SetBufferAsUInt8( uint8_t * buffer, unsigned int numberOfComponents )
 
287
{
 
288
  this->m_Buffer = buffer;
 
289
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
290
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
291
    {
 
292
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<uint8_t, UnusedDimension> >::Result;
 
293
    }
 
294
  else
 
295
    {
 
296
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<uint8_t, UnusedDimension> >::Result;
 
297
    }
 
298
  return *this;
 
299
}
 
300
ImportImageFilter::Self& ImportImageFilter::SetBufferAsInt16( int16_t * buffer, unsigned int numberOfComponents )
 
301
{
 
302
  this->m_Buffer = buffer;
 
303
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
304
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
305
    {
 
306
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<int16_t, UnusedDimension> >::Result;
 
307
    }
 
308
  else
 
309
    {
 
310
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<int16_t, UnusedDimension> >::Result;
 
311
    }
 
312
  return *this;
 
313
}
 
314
ImportImageFilter::Self& ImportImageFilter::SetBufferAsUInt16( uint16_t * buffer, unsigned int numberOfComponents )
 
315
{
 
316
  this->m_Buffer = buffer;
 
317
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
318
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
319
    {
 
320
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<uint16_t, UnusedDimension> >::Result;
 
321
    }
 
322
  else
 
323
    {
 
324
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<uint16_t, UnusedDimension> >::Result;
 
325
    }
 
326
  return *this;
 
327
}
 
328
ImportImageFilter::Self& ImportImageFilter::SetBufferAsInt32( int32_t * buffer, unsigned int numberOfComponents )
 
329
{
 
330
  this->m_Buffer = buffer;
 
331
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
332
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
333
    {
 
334
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<int32_t, UnusedDimension> >::Result;
 
335
    }
 
336
  else
 
337
    {
 
338
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<int32_t, UnusedDimension> >::Result;
 
339
    }
 
340
  return *this;
 
341
}
 
342
ImportImageFilter::Self& ImportImageFilter::SetBufferAsUInt32( uint32_t * buffer, unsigned int numberOfComponents )
 
343
{
 
344
  this->m_Buffer = buffer;
 
345
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
346
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
347
    {
 
348
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<uint32_t, UnusedDimension> >::Result;
 
349
    }
 
350
  else
 
351
    {
 
352
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<uint32_t, UnusedDimension> >::Result;
 
353
    }
 
354
  return *this;
 
355
}
 
356
ImportImageFilter::Self& ImportImageFilter::SetBufferAsInt64( int64_t * buffer, unsigned int numberOfComponents )
 
357
{
 
358
  this->m_Buffer = buffer;
 
359
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
360
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
361
    {
 
362
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<int64_t, UnusedDimension> >::Result;
 
363
    }
 
364
  else
 
365
    {
 
366
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<int64_t, UnusedDimension> >::Result;
 
367
    }
 
368
  return *this;
 
369
}
 
370
ImportImageFilter::Self& ImportImageFilter::SetBufferAsUInt64( uint64_t * buffer, unsigned int numberOfComponents )
 
371
{
 
372
  this->m_Buffer = buffer;
 
373
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
374
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
375
    {
 
376
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<uint64_t, UnusedDimension> >::Result;
 
377
    }
 
378
  else
 
379
    {
 
380
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<uint64_t, UnusedDimension> >::Result;
 
381
    }
 
382
  return *this;
 
383
}
 
384
 
 
385
ImportImageFilter::Self& ImportImageFilter::SetBufferAsFloat( float * buffer, unsigned int numberOfComponents )
 
386
{
 
387
  this->m_Buffer = buffer;
 
388
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
389
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
390
    {
 
391
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<float, UnusedDimension> >::Result;
 
392
    }
 
393
  else
 
394
    {
 
395
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<float, UnusedDimension> >::Result;
 
396
    }
 
397
  return *this;
 
398
}
 
399
ImportImageFilter::Self& ImportImageFilter::SetBufferAsDouble( double * buffer, unsigned int numberOfComponents )
 
400
{
 
401
  this->m_Buffer = buffer;
 
402
  this->m_NumberOfComponentsPerPixel = numberOfComponents;
 
403
  if ( this->m_NumberOfComponentsPerPixel == 1 )
 
404
    {
 
405
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::Image<double, UnusedDimension> >::Result;
 
406
    }
 
407
  else
 
408
    {
 
409
    this->m_PixelIDValue = ImageTypeToPixelIDValue< itk::VectorImage<double, UnusedDimension> >::Result;
 
410
    }
 
411
  return *this;
 
412
}
 
413
 
 
414
 
 
415
#define PRINT_IVAR_MACRO( VAR ) "\t" << #VAR << ": " << VAR << std::endl
 
416
 
 
417
std::string ImportImageFilter::ToString() const
 
418
{
 
419
  std::ostringstream out;
 
420
 
 
421
  out << "itk::simple::ImportImageFilter\n"
 
422
      << PRINT_IVAR_MACRO( m_NumberOfComponentsPerPixel )
 
423
      << PRINT_IVAR_MACRO( m_PixelIDValue )
 
424
      << PRINT_IVAR_MACRO( m_Origin )
 
425
      << PRINT_IVAR_MACRO( m_Spacing )
 
426
      << PRINT_IVAR_MACRO( m_Size )
 
427
      << PRINT_IVAR_MACRO( m_Direction )
 
428
      << PRINT_IVAR_MACRO( m_Buffer );
 
429
  return out.str();
 
430
}
 
431
 
 
432
Image ImportImageFilter::Execute ()
 
433
{
 
434
  unsigned int imageDimension = this->m_Size.size();
 
435
 
 
436
  // perform sanity check on some parameters
 
437
  if (  this->m_NumberOfComponentsPerPixel == 0 || this->m_PixelIDValue == sitkUnknown )
 
438
    {
 
439
    sitkExceptionMacro( << "PixelType or NumberOfComponentsPerPixel are invalid!" );
 
440
    }
 
441
 
 
442
 
 
443
  if ( imageDimension != 3 && imageDimension != 2 )
 
444
    {
 
445
    sitkExceptionMacro(<< "The length of size is invalid! "
 
446
                       << "Only image of dimension 2 or 3 are supported." );
 
447
    }
 
448
 
 
449
  if ( !this->m_MemberFactory->HasMemberFunction( this->m_PixelIDValue, imageDimension ) )
 
450
    {
 
451
    sitkExceptionMacro( << "PixelType is not supported!" << std::endl
 
452
                        << "Pixel Type: "
 
453
                        << GetPixelIDValueAsString( this->m_PixelIDValue ) << std::endl
 
454
                        << "Refusing to load! " << std::endl );
 
455
    }
 
456
 
 
457
  return this->m_MemberFactory->GetMemberFunction( this->m_PixelIDValue, imageDimension )();
 
458
}
 
459
 
 
460
 
 
461
template <class TImageType>
 
462
Image ImportImageFilter::ExecuteInternal( )
 
463
{
 
464
 
 
465
  typedef TImageType                            ImageType;
 
466
  const unsigned int Dimension = ImageType::ImageDimension;
 
467
 
 
468
  // if the InstantiatedToken is correctly implemented this should
 
469
  // not occur
 
470
  assert( ImageTypeToPixelIDValue<ImageType>::Result != (int)sitkUnknown );
 
471
 
 
472
  typename ImageType::Pointer image = ImageType::New();
 
473
 
 
474
 
 
475
 
 
476
 
 
477
  //
 
478
  //  Origin
 
479
  //
 
480
  typename ImageType::PointType origin = sitkSTLVectorToITK< typename ImageType::PointType >( this->m_Origin );
 
481
  image->SetOrigin( origin );
 
482
 
 
483
  //
 
484
  //  Spacing
 
485
  //
 
486
  typename ImageType::SpacingType spacing = sitkSTLVectorToITK< typename ImageType::SpacingType >( this->m_Spacing );
 
487
  image->SetSpacing( spacing );
 
488
 
 
489
  //
 
490
  //  Size and Region
 
491
  //
 
492
  typename ImageType::RegionType region;
 
493
  typename ImageType::SizeType size = sitkSTLVectorToITK< typename ImageType::SizeType >( this->m_Size );
 
494
  region.SetSize(size);
 
495
  // set the size and region to the ITK image.
 
496
  image->SetRegions( region );
 
497
 
 
498
  //
 
499
  // Direction, if m_Direction is not set, use ITK's default which is
 
500
  // an identity.
 
501
  //
 
502
  if (this->m_Direction.size() != 0 )
 
503
    {
 
504
    image->SetDirection(  sitkSTLToITKDirection<typename ImageType::DirectionType>( this->m_Direction ) );
 
505
    }
 
506
 
 
507
 
 
508
  size_t numberOfElements = m_NumberOfComponentsPerPixel;
 
509
  for(unsigned int si = 0; si < Dimension; si++ )
 
510
    {
 
511
    numberOfElements *= size[si];
 
512
    }
 
513
 
 
514
  const bool TheContainerWillTakeCareOfDeletingTheMemoryBuffer = false;
 
515
 
 
516
  // Set the image's pixel container to import the pointer provided.
 
517
  image->GetPixelContainer()->SetImportPointer(static_cast<typename ImageType::InternalPixelType*>(m_Buffer), numberOfElements,
 
518
                                               TheContainerWillTakeCareOfDeletingTheMemoryBuffer);
 
519
 
 
520
 
 
521
  //
 
522
  // Meta-programmed method to set the number of components if a
 
523
  // vector image
 
524
  //
 
525
  this->SetNumberOfComponentsOnImage( image.GetPointer() );
 
526
 
 
527
  // This line must be the last line in the function to prevent a deep
 
528
  // copy caused by a implicit sitk::MakeUnique
 
529
  return Image( image );
 
530
}
 
531
 
 
532
template <class TFilterType>
 
533
typename EnableIf<IsVector<TFilterType>::Value>::Type
 
534
ImportImageFilter::SetNumberOfComponentsOnImage ( TFilterType*image )
 
535
{
 
536
  image->SetNumberOfComponentsPerPixel( m_NumberOfComponentsPerPixel );
 
537
}
 
538
 
 
539
}
 
540
}