← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Testing/Unit/sitkImportImageTest.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:
Testing/Unit/sitkImportImageTest.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
#include <sitkImportImageFilter.h>
 
19
#include <sitkHashImageFilter.h>
 
20
#include <SimpleITKTestHarness.h>
 
21
 
 
22
// Common fixture for Import tests
 
23
class Import
 
24
  : public ::testing::Test {
 
25
public:
 
26
  virtual void SetUp() {
 
27
    spacing1 = std::vector<double>( 3, 1.0 );
 
28
    spacing2.push_back( 1.1 );
 
29
    spacing2.push_back( 1.2 );
 
30
 
 
31
    origin0 = std::vector<double>( 3, 0.0 );
 
32
    origin1 = std::vector<double>( 3, 1.0 );
 
33
    origin2.push_back( 2.71828183 );
 
34
    origin2.push_back( 3.14159265 );
 
35
    direction2D = std::vector<double>(4, 0.0 );
 
36
    direction3D = std::vector<double>(9, 0.0 );
 
37
 
 
38
    direction2D[0] = direction2D[3] = 1.0;
 
39
 
 
40
    direction3D[0] = direction3D[4] = direction3D[8] = 1.0;
 
41
  }
 
42
 
 
43
  std::vector<double> spacing1;
 
44
  std::vector<double> spacing2;
 
45
 
 
46
  std::vector<double> origin0;
 
47
  std::vector<double> origin1;
 
48
  std::vector<double> origin2;
 
49
 
 
50
  std::vector< uint8_t > uint8_buffer;
 
51
  std::vector< int8_t > int8_buffer;
 
52
  std::vector< uint16_t > uint16_buffer;
 
53
  std::vector< int16_t > int16_buffer;
 
54
  std::vector< uint32_t > uint32_buffer;
 
55
  std::vector< int32_t > int32_buffer;
 
56
  std::vector< uint64_t > uint64_buffer;
 
57
  std::vector< int64_t > int64_buffer;
 
58
  std::vector< float > float_buffer;
 
59
  std::vector< double > double_buffer;
 
60
 
 
61
  std::vector<double> direction2D;
 
62
  std::vector<double> direction3D;
 
63
};
 
64
 
 
65
namespace sitk = itk::simple;
 
66
 
 
67
TEST_F(Import,Required) {
 
68
  // the purpose of this test is to verify that the filter has certain
 
69
  // methods, and to imporve coverage
 
70
 
 
71
  // Check has Self
 
72
  typedef itk::simple::ImportImageFilter::Self ImportFilterType;
 
73
 
 
74
  // default constructable
 
75
  ImportFilterType  importer;
 
76
 
 
77
  // has ToString method
 
78
  std::cout << importer.ToString() << std::endl;
 
79
 
 
80
  EXPECT_EQ( "ImportImageFilter", importer.GetName() );
 
81
}
 
82
 
 
83
TEST_F(Import,BasicUsage) {
 
84
 
 
85
  // This test is designed to set everything and verify it
 
86
 
 
87
  uint8_buffer = std::vector< uint8_t >( 128*128*128, 17 );
 
88
 
 
89
  sitk::ImportImageFilter importer;
 
90
  importer.SetSize( std::vector< unsigned int >( 3, 128u ) );
 
91
  importer.SetSpacing( spacing1 );
 
92
  importer.SetOrigin( origin0 );
 
93
  importer.SetDirection( direction3D );
 
94
  importer.SetBufferAsUInt8( &uint8_buffer[0] );
 
95
 
 
96
  sitk::Image image = importer.Execute();
 
97
 
 
98
  ASSERT_EQ( image.GetDimension(), 3u ) << "image dimension check";
 
99
 
 
100
  EXPECT_EQ( image.GetSize()[0], 128u ) << "X size check";
 
101
  EXPECT_EQ( image.GetSize()[1], 128u ) << "Y size check";
 
102
  EXPECT_EQ( image.GetSize()[2], 128u ) << "Z size check";
 
103
 
 
104
  EXPECT_EQ( image.GetOrigin(), origin0 ) << "origin check";
 
105
  EXPECT_EQ( image.GetSpacing(), spacing1 ) << "spacing check";
 
106
 
 
107
 
 
108
  for ( unsigned int k = 0; k < image.GetSize()[2]; ++k )
 
109
    {
 
110
    std::vector<uint32_t> idx(3, 0 );
 
111
    idx[2] = k;
 
112
    for ( unsigned int j = 0; j < image.GetSize()[1]; ++j )
 
113
      {
 
114
      idx[1] = j;
 
115
      for ( unsigned int i = 0; i < image.GetSize()[0]; ++i )
 
116
          {
 
117
          idx[0] = i;
 
118
          EXPECT_EQ( image.GetPixelAsUInt8( idx ), 17 ) << " expect all pixel to be 17";
 
119
          }
 
120
      }
 
121
    }
 
122
 
 
123
 
 
124
  EXPECT_EQ ( "a2178ce2d158a4a7c5a9ef3d03a33a6099b9c5be", sitk::Hash( image ) ) << " hash value for basic uin8_t";
 
125
 
 
126
  // ================================================
 
127
  //
 
128
  // TEST FOR 2D IMAGE
 
129
  //
 
130
  int32_buffer = std::vector< int32_t >( 73*73, 21 );
 
131
 
 
132
  importer.SetSize( std::vector< unsigned int >( 2, 73u ) );
 
133
  importer.SetSpacing( spacing2 );
 
134
  importer.SetOrigin( origin2 );
 
135
  importer.SetDirection( direction2D );
 
136
  importer.SetBufferAsInt32( &int32_buffer[0] );
 
137
 
 
138
  image = importer.Execute();
 
139
 
 
140
  ASSERT_EQ( image.GetDimension(), 2u ) << "image dimension check";
 
141
 
 
142
  EXPECT_EQ( image.GetSize()[0], 73u ) << "X size check";
 
143
  EXPECT_EQ( image.GetSize()[1], 73u ) << "Y size check";
 
144
 
 
145
  EXPECT_EQ( image.GetOrigin(), origin2 ) << "origin check";
 
146
  EXPECT_EQ( image.GetSpacing(), spacing2 ) << "spacing check";
 
147
 
 
148
  for ( unsigned int j = 0; j < image.GetSize()[1]; ++j )
 
149
    {
 
150
    std::vector<uint32_t> idx(2, 0 );
 
151
    idx[1] = j;
 
152
    for ( unsigned int i = 0; i < image.GetSize()[0]; ++i )
 
153
      {
 
154
      idx[0] = i;
 
155
      EXPECT_EQ( image.GetPixelAsInt32( idx ), 21 ) << " expect all pixel to be 21";
 
156
      }
 
157
    }
 
158
 
 
159
 
 
160
  EXPECT_EQ ( "6f6eefc4c1833e3e29b0968023ead2141fdbee3f", sitk::Hash( image ) ) << " hash value for basic uin32_t";
 
161
}
 
162
 
 
163
TEST_F(Import,Direction) {
 
164
 
 
165
  // This test is to run the direction parameter though it's passes
 
166
 
 
167
  sitk::Image img(0,0,sitk::sitkUInt8);
 
168
 
 
169
  uint8_buffer = std::vector< uint8_t >( 128*128*128, 17 );
 
170
 
 
171
 
 
172
  {
 
173
  sitk::ImportImageFilter importer;
 
174
  importer.SetSize( std::vector< unsigned int >( 3, 128u ) );
 
175
  importer.SetBufferAsUInt8( &uint8_buffer[0] );
 
176
 
 
177
  // check defaults to identity
 
178
  ASSERT_NO_THROW( img = importer.Execute() );
 
179
  EXPECT_EQ( img.GetDirection(), direction3D );
 
180
 
 
181
 
 
182
  importer.SetDirection( direction2D );
 
183
  ASSERT_ANY_THROW( importer.Execute() ) << "Checking 2D direction to 3D import ";
 
184
  }
 
185
 
 
186
  {
 
187
  sitk::ImportImageFilter importer;
 
188
  importer.SetSize( std::vector< unsigned int >( 2, 128u ) );
 
189
  importer.SetBufferAsUInt8( &uint8_buffer[0] );
 
190
 
 
191
  // check defaults to identity
 
192
  ASSERT_NO_THROW( img = importer.Execute() );
 
193
  EXPECT_EQ( img.GetDirection(), direction2D );
 
194
 
 
195
  importer.SetDirection( direction3D  );
 
196
  ASSERT_ANY_THROW( importer.Execute() ) << "Checking 3D direction to 2D import";
 
197
  }
 
198
 
 
199
}
 
200
 
 
201
 
 
202
TEST_F(Import,Shallow) {
 
203
 
 
204
  // This test is designed to verify the buffer is shared
 
205
 
 
206
  uint8_buffer = std::vector< uint8_t >( 128*128*128, 17 );
 
207
 
 
208
  sitk::ImportImageFilter importer;
 
209
  importer.SetSize( std::vector< unsigned int >( 3, 128u ) );
 
210
  importer.SetBufferAsUInt8( &uint8_buffer[0] );
 
211
 
 
212
  sitk::Image image = importer.Execute();
 
213
 
 
214
  ASSERT_EQ( image.GetDimension(), 3u ) << "image dimension check";
 
215
 
 
216
 
 
217
 
 
218
  EXPECT_EQ ( "a2178ce2d158a4a7c5a9ef3d03a33a6099b9c5be", sitk::Hash( image ) ) << " hash value for basic uin8_t";
 
219
 
 
220
  std::vector<uint32_t> idx(3, 0 );
 
221
  uint8_buffer[0] = 19;
 
222
  EXPECT_EQ ( 19,  uint8_buffer[0] ) << " direct setting of buffer";
 
223
  EXPECT_EQ ( 19,  image.GetPixelAsUInt8(idx) ) << " buffer modifying image";
 
224
 
 
225
  image.SetPixelAsUInt8(idx, 23);
 
226
  EXPECT_EQ ( 23,  image.GetPixelAsUInt8(idx) ) << " direct setting of image";
 
227
  EXPECT_EQ ( 23,  uint8_buffer[0] ) << " image modifying buffer";
 
228
 
 
229
}
 
230
 
 
231
TEST_F(Import,ExhaustiveTypes) {
 
232
 
 
233
  sitk::ImportImageFilter importer;
 
234
 
 
235
  importer.SetSize( std::vector< unsigned int >( 2, 16u ) );
 
236
  importer.SetSpacing( spacing1 );
 
237
  importer.SetOrigin( origin0 );
 
238
 
 
239
  EXPECT_EQ( importer.GetSize()[0], 16u );
 
240
  EXPECT_EQ( importer.GetSpacing()[0], spacing1[0] );
 
241
  EXPECT_EQ( importer.GetOrigin()[0], origin0[1] );
 
242
  importer.GetDirection();
 
243
 
 
244
 
 
245
  uint8_buffer = std::vector< uint8_t >( 16*16, 1 );
 
246
  importer.SetBufferAsUInt8( &uint8_buffer[0] );
 
247
  EXPECT_EQ ( "ac458b067c6b021c7e9358229b636e9d1e4cb154", sitk::Hash( importer.Execute() ) ) << " hash value for uint8";
 
248
 
 
249
  int8_buffer = std::vector< int8_t >( 16*16, -1 );
 
250
  importer.SetBufferAsInt8( &int8_buffer[0] );
 
251
  EXPECT_EQ ( "c744cac6af7621524fc3a2b0a9a135a32b33c81b", sitk::Hash( importer.Execute() ) ) << " hash value for int8";
 
252
 
 
253
  uint16_buffer = std::vector< uint16_t >( 16*16, 2 );
 
254
  importer.SetBufferAsUInt16( &uint16_buffer[0] );
 
255
  EXPECT_EQ ( "adbc44d359d3b3c032629bab34e3ee62c4563223", sitk::Hash( importer.Execute() ) ) << " hash value for uint16";
 
256
 
 
257
  int16_buffer = std::vector< int16_t >( 16*16, -3 );
 
258
  importer.SetBufferAsInt16( &int16_buffer[0] );
 
259
  EXPECT_EQ ( "8111171305e02db2276c7366d117598b1f6789ff", sitk::Hash( importer.Execute() ) ) << " hash value for int16";
 
260
 
 
261
  uint32_buffer = std::vector< uint32_t >( 16*16, 8 );
 
262
  importer.SetBufferAsUInt32( &uint32_buffer[0] );
 
263
  EXPECT_EQ ( "4b710847b34bc5e96520de8a1d7b97563077423c", sitk::Hash( importer.Execute() ) ) << " hash value for uint32";
 
264
 
 
265
  int32_buffer = std::vector< int32_t >( 16*16, -123 );
 
266
  importer.SetBufferAsInt32( &int32_buffer[0] );
 
267
  EXPECT_EQ ( "d5748f3800b837611dc94c089ac7926f2bbea973" , sitk::Hash( importer.Execute() ) ) << " hash value for int32";
 
268
 
 
269
  if ( sitk::sitkUInt64 != sitk::sitkUnknown )
 
270
    {
 
271
    uint64_buffer = std::vector< uint64_t >( 16*16, 8 );
 
272
    importer.SetBufferAsUInt64( &uint64_buffer[0] );
 
273
    EXPECT_EQ ( "95c3884597103a98cf6f1def52cab572c41f0eb5", sitk::Hash( importer.Execute() ) ) << " hash value for uint64";
 
274
    }
 
275
 
 
276
  if ( sitk::sitkInt64 != sitk::sitkUnknown )
 
277
    {
 
278
 
 
279
    int64_buffer = std::vector< int64_t >( 16*16, -123 );
 
280
    importer.SetBufferAsInt64( &int64_buffer[0] );
 
281
    EXPECT_EQ ( "d0a23a11b2f39b46cfc09bd71fc4c9661b68a826" , sitk::Hash( importer.Execute() ) ) << " hash value for int64";
 
282
    }
 
283
 
 
284
  float_buffer = std::vector< float >( 16*16, 1.123f );
 
285
  importer.SetBufferAsFloat( &float_buffer[0] );
 
286
  EXPECT_EQ ( "8588f5624f56bb55693d54505388dc06b93d2f14", sitk::Hash( importer.Execute() ) ) << " hash value for float";
 
287
 
 
288
  double_buffer = std::vector< double >( 16*16, 321.123 );
 
289
  importer.SetBufferAsDouble( &double_buffer[0] );
 
290
  EXPECT_EQ ( "00393fe0b94729ff0f777ce848104697ce689c70", sitk::Hash( importer.Execute() ) ) << " hash value for double";
 
291
 
 
292
 
 
293
  uint8_buffer = std::vector< uint8_t >( 16*16*2, 1 );
 
294
  importer.SetBufferAsUInt8( &uint8_buffer[0], 2 );
 
295
  EXPECT_EQ ( "3ef8a08ec90e244fe2a8948b701eafcc1d065712", sitk::Hash( importer.Execute() ) ) << " hash value for vector of uint8";
 
296
 
 
297
  int8_buffer = std::vector< int8_t >( 16*16*3, -1 );
 
298
  importer.SetBufferAsInt8( &int8_buffer[0], 3 );
 
299
  EXPECT_EQ ( "fc1b469729f5a061d4b8b5eb1efba13a7b52d5a7", sitk::Hash( importer.Execute() ) ) << " hash value for vector of int8";
 
300
 
 
301
  uint16_buffer = std::vector< uint16_t >( 16*16*4, 2 );
 
302
  importer.SetBufferAsUInt16( &uint16_buffer[0], 4 );
 
303
  EXPECT_EQ ( "f449215906661bacee88ef886c38f3049d9a232b", sitk::Hash( importer.Execute() ) ) << " hash value for vector of uint16";
 
304
 
 
305
  int16_buffer = std::vector< int16_t >( 16*16*5, -3 );
 
306
  importer.SetBufferAsInt16( &int16_buffer[0], 5 );
 
307
  EXPECT_EQ ( "7bce93764d2393b987ed2b17281073ddb520af46", sitk::Hash( importer.Execute() ) ) << " hash value for vector of int16";
 
308
 
 
309
  uint32_buffer = std::vector< uint32_t >( 16*16*6, 8 );
 
310
  importer.SetBufferAsUInt32( &uint32_buffer[0], 6 );
 
311
  EXPECT_EQ ( "c558884e4bf07ece6a2644307aa3b4eb84be8a11", sitk::Hash( importer.Execute() ) ) << " hash value for vector of uint32";
 
312
 
 
313
  int32_buffer = std::vector< int32_t >( 16*16*7, -123 );
 
314
  importer.SetBufferAsInt32( &int32_buffer[0], 7 );
 
315
  EXPECT_EQ ( "c65dc5820f3691fc4b6b3b9aaba1f506ca3f697e" , sitk::Hash( importer.Execute() ) ) << " hash value for vector of int32";
 
316
 
 
317
  if ( sitk::sitkVectorUInt64 != sitk::sitkUnknown )
 
318
    {
 
319
    uint64_buffer = std::vector< uint64_t >( 16*16*6, 8 );
 
320
    importer.SetBufferAsUInt64( &uint64_buffer[0], 6 );
 
321
    EXPECT_EQ ( "cac37cb71f23cd41ed1e2b60d1e325ee8de4ca71", sitk::Hash( importer.Execute() ) ) << " hash value for vector of uint64";
 
322
    }
 
323
 
 
324
  if ( sitk::sitkVectorInt64 != sitk::sitkUnknown )
 
325
    {
 
326
    int64_buffer = std::vector< int64_t >( 16*16*7, -123 );
 
327
    importer.SetBufferAsInt64( &int64_buffer[0], 7 );
 
328
    EXPECT_EQ ( "91a61e519faf128747bf2d2bbd860d4f05d79ac6" , sitk::Hash( importer.Execute() ) ) << " hash value for vector of int64";
 
329
    }
 
330
 
 
331
  float_buffer = std::vector< float >( 16*16*8, 1.123f );
 
332
  importer.SetBufferAsFloat( &float_buffer[0], 8 );
 
333
  EXPECT_EQ ( "9fb1d83b9c9a5645e7b136761d6924ea7d859284", sitk::Hash( importer.Execute() ) ) << " hash value for vector of float";
 
334
 
 
335
  double_buffer = std::vector< double >( 16*16*9, 321.123 );
 
336
  importer.SetBufferAsDouble( &double_buffer[0], 9 );
 
337
  EXPECT_EQ ( "80514b97613fc659c9ceb45bb44c8a02fec9c4db", sitk::Hash( importer.Execute() ) ) << " hash value for vector of double";
 
338
 
 
339
  importer.SetSize( std::vector< unsigned int >( 5, 16u ) );
 
340
  EXPECT_ANY_THROW( importer.Execute() );
 
341
  importer.SetBufferAsDouble( &double_buffer[0], 0 );
 
342
  EXPECT_ANY_THROW( importer.Execute() );
 
343
 
 
344
 
 
345
 
 
346
}
 
347
 
 
348
TEST_F(Import,Procedual) {
 
349
 
 
350
  sitk::Image img(0,0,sitk::sitkUInt8);
 
351
  std::vector< unsigned int > size( 2, 16u );
 
352
 
 
353
  direction2D[0] = direction2D[3] = -1.0;
 
354
 
 
355
  uint8_buffer = std::vector< uint8_t >( 16*16, 1 );
 
356
  img = sitk::ImportAsUInt8( &uint8_buffer[0],
 
357
                             size,
 
358
                             spacing2,
 
359
                             origin2,
 
360
                             direction2D );
 
361
  EXPECT_EQ ( "ac458b067c6b021c7e9358229b636e9d1e4cb154", sitk::Hash( img ) ) << " hash value for uint8";
 
362
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for uint8";
 
363
  EXPECT_EQ ( img.GetOrigin(), origin2 ) << " origin for uint8";
 
364
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for uint8";
 
365
 
 
366
  int8_buffer = std::vector< int8_t >( 16*16, -1 );
 
367
  img = sitk::ImportAsInt8( &int8_buffer[0],
 
368
                            size,
 
369
                            spacing2,
 
370
                            origin2,
 
371
                            direction2D );
 
372
  EXPECT_EQ ( "c744cac6af7621524fc3a2b0a9a135a32b33c81b", sitk::Hash( img ) ) << " hash value for int8";
 
373
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for int8";
 
374
  EXPECT_EQ ( img.GetOrigin(), origin2 )  << " origin for int8";
 
375
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for int8";
 
376
 
 
377
 
 
378
  uint16_buffer = std::vector< uint16_t >( 16*16, 2 );
 
379
  img = sitk::ImportAsUInt16( &uint16_buffer[0],
 
380
                              size,
 
381
                              spacing2,
 
382
                              origin2,
 
383
                              direction2D );
 
384
  EXPECT_EQ ( "adbc44d359d3b3c032629bab34e3ee62c4563223", sitk::Hash( img ) ) << " hash value for uint16";
 
385
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for uint16";
 
386
  EXPECT_EQ ( img.GetOrigin(), origin2 ) << " origin for uint16";
 
387
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for uint16";
 
388
 
 
389
 
 
390
  int16_buffer = std::vector< int16_t >( 16*16, -3 );
 
391
  img = sitk::ImportAsInt16( &int16_buffer[0],
 
392
                             size,
 
393
                             spacing2,
 
394
                             origin2,
 
395
                             direction2D );
 
396
  EXPECT_EQ ( "8111171305e02db2276c7366d117598b1f6789ff", sitk::Hash( img ) ) << " hash value for int16";
 
397
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for int16";
 
398
  EXPECT_EQ ( img.GetOrigin(), origin2 )  << " origin for int16";
 
399
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for int16";
 
400
 
 
401
 
 
402
  uint32_buffer = std::vector< uint32_t >( 16*16, 8 );
 
403
  img = sitk::ImportAsUInt32( &uint32_buffer[0],
 
404
                              size,
 
405
                              spacing2,
 
406
                              origin2,
 
407
                              direction2D );
 
408
  EXPECT_EQ ( "4b710847b34bc5e96520de8a1d7b97563077423c", sitk::Hash( img ) ) << " hash value for uint32";
 
409
  EXPECT_EQ ( img.GetSpacing(), spacing2 )  << " spacing for uint32";
 
410
  EXPECT_EQ ( img.GetOrigin(), origin2 )  << " origin for uint32";
 
411
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for uint32";
 
412
 
 
413
 
 
414
  int32_buffer = std::vector< int32_t >( 16*16, -123 );
 
415
  img = sitk::ImportAsInt32( &int32_buffer[0],
 
416
                             size,
 
417
                             spacing2,
 
418
                             origin2,
 
419
                             direction2D );
 
420
  EXPECT_EQ ( "d5748f3800b837611dc94c089ac7926f2bbea973" , sitk::Hash( img ) ) << " hash value for int32";
 
421
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for int32";
 
422
  EXPECT_EQ ( img.GetOrigin(), origin2 )  << " origin for int32";
 
423
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for int32";
 
424
 
 
425
 
 
426
  float_buffer = std::vector< float >( 16*16, 1.123f );
 
427
  img = sitk::ImportAsFloat( &float_buffer[0],
 
428
                             size,
 
429
                             spacing2,
 
430
                             origin2,
 
431
                             direction2D );
 
432
  EXPECT_EQ ( "8588f5624f56bb55693d54505388dc06b93d2f14", sitk::Hash( img ) ) << " hash value for float";
 
433
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for float";
 
434
  EXPECT_EQ ( img.GetOrigin(), origin2 ) << " origin for float";
 
435
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for float";
 
436
 
 
437
 
 
438
  double_buffer = std::vector< double >( 16*16, 321.123 );
 
439
  img = sitk::ImportAsDouble( &double_buffer[0],
 
440
                              size,
 
441
                              spacing2,
 
442
                              origin2,
 
443
                              direction2D );
 
444
  EXPECT_EQ ( "00393fe0b94729ff0f777ce848104697ce689c70", sitk::Hash( img ) ) << " hash value for double";
 
445
  EXPECT_EQ ( img.GetSpacing(), spacing2 ) << " spacing for double";
 
446
  EXPECT_EQ ( img.GetOrigin(), origin2 ) << " origin for float";
 
447
  EXPECT_EQ ( img.GetDirection(), direction2D ) << " direction for double";
 
448
 
 
449
}