1 /*============================================================================
2 MetaIO
3 Copyright 2000-2010 Insight Software Consortium
4
5 Distributed under the OSI-approved BSD License (the "License");
6 see accompanying file Copyright.txt for details.
7
8 This software is distributed WITHOUT ANY WARRANTY; without even the
9 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10 See the License for more information.
11 ============================================================================*/
12 #include "metaTransform.h"
13
14 #ifdef _MSC_VER
15 #pragma warning(disable:4702)
16 #endif
17
18 #include <stdio.h>
19 #include <ctype.h>
20 #include <string>
21
22 #if (METAIO_USE_NAMESPACE)
23 namespace METAIO_NAMESPACE {
24 #endif
25
26
27 /** MetaTransform constructors */
28 MetaTransform::
MetaTransform()29 MetaTransform()
30 :MetaObject()
31 {
32 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform()" << METAIO_STREAM::endl;
33 Clear();
34 }
35
36 //
37 MetaTransform::
MetaTransform(const char * _headerName)38 MetaTransform(const char *_headerName)
39 :MetaObject()
40 {
41 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform()" << METAIO_STREAM::endl;
42 Clear();
43 Read(_headerName);
44 }
45
46 //
47 MetaTransform::
MetaTransform(const MetaTransform * _group)48 MetaTransform(const MetaTransform *_group)
49 :MetaObject()
50 {
51 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform()" << METAIO_STREAM::endl;
52 Clear();
53 CopyInfo(_group);
54 }
55
56 MetaTransform::
MetaTransform(unsigned int dim)57 MetaTransform(unsigned int dim)
58 :MetaObject(dim)
59 {
60 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform()" << METAIO_STREAM::endl;
61 Clear();
62 }
63
64 //
65 MetaTransform::
~MetaTransform()66 ~MetaTransform()
67 {
68 delete parameters;
69 M_Destroy();
70 }
71
72 //
73 void MetaTransform::
PrintInfo() const74 PrintInfo() const
75 {
76 MetaObject::PrintInfo();
77 }
78
79 void MetaTransform::
CopyInfo(const MetaObject * _object)80 CopyInfo(const MetaObject * _object)
81 {
82 MetaObject::CopyInfo(_object);
83 }
84
85 /** Clear group information */
86 void MetaTransform::
Clear(void)87 Clear(void)
88 {
89 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform: Clear" << METAIO_STREAM::endl;
90 MetaObject::Clear();
91 if(parameters)
92 {
93 delete parameters;
94 }
95 parameters = NULL;
96 parametersDimension = 0;
97 transformOrder = 0;
98
99
100 for(unsigned int i=0;i<100;i++)
101 {
102 gridSpacing[i] = 1;
103 gridOrigin[i] = 0;
104 gridRegionSize[i] = 0;
105 gridRegionIndex[i] = 0;
106 }
107 }
108
109 /** Destroy group information */
110 void MetaTransform::
M_Destroy(void)111 M_Destroy(void)
112 {
113 MetaObject::M_Destroy();
114 }
115
116 /** Set Read fields */
117 void MetaTransform::
M_SetupReadFields(void)118 M_SetupReadFields(void)
119 {
120 if(META_DEBUG) METAIO_STREAM::cout << "MetaTransform: M_SetupReadFields" << METAIO_STREAM::endl;
121 MetaObject::M_SetupReadFields();
122
123 int nDimsRecordNumber = MET_GetFieldRecordNumber("NDims", &m_Fields);
124
125 MET_FieldRecordType* mF = new MET_FieldRecordType;
126 MET_InitReadField(mF, "Order", MET_INT,false);
127 m_Fields.push_back(mF);
128
129 mF = new MET_FieldRecordType;
130 MET_InitReadField(mF, "GridRegionSize", MET_DOUBLE_ARRAY,false,nDimsRecordNumber);
131 m_Fields.push_back(mF);
132
133 mF = new MET_FieldRecordType;
134 MET_InitReadField(mF, "GridRegionIndex", MET_DOUBLE_ARRAY,false,nDimsRecordNumber);
135 m_Fields.push_back(mF);
136
137 mF = new MET_FieldRecordType;
138 MET_InitReadField(mF, "GridOrigin", MET_DOUBLE_ARRAY,false,nDimsRecordNumber);
139 m_Fields.push_back(mF);
140
141 mF = new MET_FieldRecordType;
142 MET_InitReadField(mF, "GridSpacing", MET_DOUBLE_ARRAY,false,nDimsRecordNumber);
143 m_Fields.push_back(mF);
144
145 mF = new MET_FieldRecordType;
146 MET_InitReadField(mF, "NParameters", MET_INT,true);
147 m_Fields.push_back(mF);
148
149 mF = new MET_FieldRecordType;
150 MET_InitReadField(mF, "Parameters", MET_NONE);
151 mF->terminateRead = true;
152 m_Fields.push_back(mF);
153
154 }
155
156 void MetaTransform::
M_SetupWriteFields(void)157 M_SetupWriteFields(void)
158 {
159 strcpy(m_ObjectTypeName,"Transform");
160 MetaObject::M_SetupWriteFields();
161
162 // We don't want to write the matrix and the offset
163 MET_FieldRecordType * mF;
164 mF = MET_GetFieldRecord("TransformMatrix",&m_Fields);
165
166 FieldsContainerType::iterator it = m_Fields.begin();
167 while(it != m_Fields.end())
168 {
169 if(*it == mF)
170 {
171 m_Fields.erase(it);
172 break;
173 }
174 ++it;
175 }
176
177 mF = MET_GetFieldRecord("Offset",&m_Fields);
178 it = m_Fields.begin();
179 while(it != m_Fields.end())
180 {
181 if(*it == mF)
182 {
183 m_Fields.erase(it);
184 break;
185 }
186 ++it;
187 }
188
189 mF = MET_GetFieldRecord("ElementSpacing",&m_Fields);
190 it = m_Fields.begin();
191 while(it != m_Fields.end())
192 {
193 if(*it == mF)
194 {
195 m_Fields.erase(it);
196 break;
197 }
198 ++it;
199 }
200
201 int i;
202 bool writeCoR = false;
203 for(i=0;i<m_NDims;i++)
204 {
205 if(m_CenterOfRotation[i] != 0.0)
206 {
207 writeCoR = true;
208 break;
209 }
210 }
211
212 if(!writeCoR)
213 {
214 mF = MET_GetFieldRecord("CenterOfRotation",&m_Fields);
215 it = m_Fields.begin();
216 while(it != m_Fields.end())
217 {
218 if(*it == mF)
219 {
220 m_Fields.erase(it);
221 break;
222 }
223 ++it;
224 }
225 }
226
227 if(transformOrder > 0)
228 {
229 mF = new MET_FieldRecordType;
230 MET_InitWriteField(mF, "Order", MET_INT,transformOrder);
231 m_Fields.push_back(mF);
232 }
233
234 // Grid Spacing
235 bool writeGridSpacing = false;
236 for(i=0;i<100;i++)
237 {
238 if(gridSpacing[i] != 1)
239 {
240 writeGridSpacing = true;
241 break;
242 }
243 }
244
245 if(writeGridSpacing)
246 {
247 mF = new MET_FieldRecordType;
248 MET_InitWriteField(mF, "GridSpacing", MET_DOUBLE_ARRAY,m_NDims,gridSpacing);
249 m_Fields.push_back(mF);
250 }
251
252 // Grid Origin
253 bool writeGridOrigin = false;
254 for(i=0;i<100;i++)
255 {
256 if(gridOrigin[i] != 0)
257 {
258 writeGridOrigin = true;
259 break;
260 }
261 }
262
263 if(writeGridOrigin)
264 {
265 mF = new MET_FieldRecordType;
266 MET_InitWriteField(mF, "GridOrigin", MET_DOUBLE_ARRAY,m_NDims,gridOrigin);
267 m_Fields.push_back(mF);
268 }
269
270 // Grid region size
271 bool writeGridRegionSize = false;
272 for(i=0;i<100;i++)
273 {
274 if(gridRegionSize[i] != 0)
275 {
276 writeGridRegionSize = true;
277 break;
278 }
279 }
280
281 if(writeGridRegionSize)
282 {
283 mF = new MET_FieldRecordType;
284 MET_InitWriteField(mF, "GridRegionSize", MET_DOUBLE_ARRAY,m_NDims,gridRegionSize);
285 m_Fields.push_back(mF);
286 }
287
288
289 // Grid region index
290 bool writeGridRegionIndex = false;
291 for(i=0;i<100;i++)
292 {
293 if(gridRegionIndex[i] != 0)
294 {
295 writeGridRegionIndex = true;
296 break;
297 }
298 }
299
300 if(writeGridRegionIndex)
301 {
302 mF = new MET_FieldRecordType;
303 MET_InitWriteField(mF, "GridRegionIndex", MET_DOUBLE_ARRAY,m_NDims,gridRegionIndex);
304 m_Fields.push_back(mF);
305 }
306
307 mF = new MET_FieldRecordType;
308 MET_InitWriteField(mF, "NParameters", MET_INT,parametersDimension);
309 m_Fields.push_back(mF);
310
311 mF = new MET_FieldRecordType;
312 MET_InitWriteField(mF, "Parameters", MET_NONE);
313 m_Fields.push_back(mF);
314 }
315
316 bool MetaTransform::
M_Write(void)317 M_Write(void)
318 {
319
320 if(!MetaObject::M_Write())
321 {
322 METAIO_STREAM::cout << "MetaLandmark: M_Read: Error parsing file" << METAIO_STREAM::endl;
323 return false;
324 }
325
326 /** Then copy all points */
327 if(m_BinaryData)
328 {
329 char* data = new char[parametersDimension*sizeof(double)];
330 unsigned int j=0;
331 for(unsigned int i=0;i<parametersDimension;i++)
332 {
333 data[j] = (char)parameters[i];
334 j+=sizeof(double);
335 }
336 m_WriteStream->write((char *)data,parametersDimension*sizeof(double));
337 m_WriteStream->write("\n",1);
338 delete [] data;
339 }
340 else
341 {
342 for(unsigned int i=0;i<parametersDimension;i++)
343 {
344 *m_WriteStream << parameters[i] << " ";
345 }
346 *m_WriteStream << METAIO_STREAM::endl;
347 }
348
349 return true;
350
351 }
352
353
354 // Set/Get the spacing
GridSpacing(void) const355 const double * MetaTransform::GridSpacing(void) const
356 {
357 return gridSpacing;
358 }
359
GridSpacing(const double * _gridSpacing)360 void MetaTransform::GridSpacing(const double * _gridSpacing)
361 {
362 for(int i=0;i<m_NDims;i++)
363 {
364 gridSpacing[i] = _gridSpacing[i];
365 }
366 }
367
368 // Set/Get the grid index
GridOrigin(void) const369 const double * MetaTransform::GridOrigin(void) const
370 {
371 return gridOrigin;
372 }
373
GridOrigin(const double * _gridOrigin)374 void MetaTransform::GridOrigin(const double * _gridOrigin)
375 {
376 for(int i=0;i<m_NDims;i++)
377 {
378 gridOrigin[i] = _gridOrigin[i];
379 }
380 }
381
382 // Set/Get the region size
GridRegionSize(void) const383 const double * MetaTransform::GridRegionSize(void) const
384 {
385 return gridRegionSize;
386 }
387
GridRegionSize(const double * _gridRegionSize)388 void MetaTransform::GridRegionSize(const double * _gridRegionSize)
389 {
390 for(int i=0;i<m_NDims;i++)
391 {
392 gridRegionSize[i] = _gridRegionSize[i];
393 }
394 }
395
396 // Set/Get the region index
GridRegionIndex(void) const397 const double * MetaTransform::GridRegionIndex(void) const
398 {
399 return gridRegionIndex;
400 }
401
GridRegionIndex(const double * _gridRegionIndex)402 void MetaTransform::GridRegionIndex(const double * _gridRegionIndex)
403 {
404 for(int i=0;i<m_NDims;i++)
405 {
406 gridRegionIndex[i] = _gridRegionIndex[i];
407 }
408 }
409
Parameters(void) const410 const double * MetaTransform::Parameters(void) const
411 {
412 return parameters;
413 }
414
415
Parameters(unsigned int dimension,const double * _parameters)416 void MetaTransform::Parameters(unsigned int dimension, const double * _parameters)
417 {
418 parametersDimension = dimension;
419
420 if(parameters)
421 {
422 delete parameters;
423 }
424
425 parameters = new double[parametersDimension];
426
427 // Copy the parameters
428 for(unsigned int i=0;i<parametersDimension;i++)
429 {
430 parameters[i] = _parameters[i];
431 }
432 }
433
434 bool MetaTransform::
M_Read(void)435 M_Read(void)
436 {
437 if(META_DEBUG)
438 {
439 METAIO_STREAM::cout << "MetaTransform: M_Read: Loading Header" << METAIO_STREAM::endl;
440 }
441
442 if(!MetaObject::M_Read())
443 {
444 METAIO_STREAM::cout << "MetaTransform: M_Read: Error parsing file" << METAIO_STREAM::endl;
445 return false;
446 }
447
448 if(META_DEBUG)
449 {
450 METAIO_STREAM::cout << "MetaTransform: M_Read: Parsing Header" << METAIO_STREAM::endl;
451 }
452
453 MET_FieldRecordType * mF;
454
455 mF = MET_GetFieldRecord("NParameters", &m_Fields);
456 if(mF->defined)
457 {
458 parametersDimension = (unsigned int)mF->value[0];
459 }
460
461 mF = MET_GetFieldRecord("GridSpacing", &m_Fields);
462 int i;
463 if(mF && mF->defined)
464 {
465 for(i=0; i<mF->length; i++)
466 {
467 gridSpacing[i] = static_cast<double>( mF->value[i] );
468 }
469 }
470
471 mF = MET_GetFieldRecord("GridOrigin", &m_Fields);
472 if(mF && mF->defined)
473 {
474 for(i=0; i<mF->length; i++)
475 {
476 gridOrigin[i] = static_cast<double>( mF->value[i] );
477 }
478 }
479
480 mF = MET_GetFieldRecord("GridRegionSize", &m_Fields);
481 if(mF && mF->defined)
482 {
483 for(i=0; i<mF->length; i++)
484 {
485 gridRegionSize[i] = static_cast<double>( mF->value[i] );
486 }
487 }
488
489 mF = MET_GetFieldRecord("GridRegionIndex", &m_Fields);
490 if(mF && mF->defined)
491 {
492 for(i=0; i<mF->length; i++)
493 {
494 gridRegionIndex[i] = static_cast<double>( mF->value[i] );
495 }
496 }
497
498
499 mF = MET_GetFieldRecord("Order", &m_Fields);
500 if(mF->defined)
501 {
502 transformOrder = (unsigned int)mF->value[0];
503 }
504
505 if(parameters)
506 {
507 delete parameters;
508 }
509
510 parameters = new double[parametersDimension];
511
512 if(m_BinaryData)
513 {
514 char* _data = new char[parametersDimension*sizeof(double)];
515 m_ReadStream->read((char *)_data, parametersDimension*sizeof(double));
516
517 unsigned int gc = static_cast<unsigned int>(m_ReadStream->gcount());
518 if(gc != parametersDimension*sizeof(double))
519 {
520 METAIO_STREAM::cout << "MetaTransform: m_Read: data not read completely"
521 << METAIO_STREAM::endl;
522 METAIO_STREAM::cout << " ideal = " << parametersDimension*sizeof(double) << " : actual = " << gc << METAIO_STREAM::endl;
523 delete [] _data;
524 return false;
525 }
526
527 unsigned long k=0;
528
529 for(unsigned int j=0; j<parametersDimension; j++)
530 {
531 parameters[j] = _data[k];
532 k += sizeof(double);
533 }
534 delete [] _data;
535 }
536 else
537 {
538 for(unsigned int k=0; k<parametersDimension; k++)
539 {
540 *m_ReadStream >> parameters[k];
541 m_ReadStream->get();
542 }
543 }
544
545 /*
546 char c = ' ';
547 while( (c!='\n') && (!m_ReadStream->eof()))
548 {
549 c = m_ReadStream->get();// to avoid unrecognize charactere
550 }
551 */
552 return true;
553 }
554
555 #if (METAIO_USE_NAMESPACE)
556 };
557 #endif
558