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 #ifdef _MSC_VER
13 #pragma warning(disable:4702)
14 #pragma warning(disable:4284)
15 #endif
16
17 #include "metaLandmark.h"
18
19 #include <cctype>
20 #include <cstdio>
21 #include <string>
22
23 #if (METAIO_USE_NAMESPACE)
24 namespace METAIO_NAMESPACE {
25 #endif
26
27 LandmarkPnt::
LandmarkPnt(int dim)28 LandmarkPnt(int dim)
29 {
30 m_Dim = dim;
31 m_X = new float[m_Dim];
32 for(unsigned int i=0;i<m_Dim;i++)
33 {
34 m_X[i] = 0;
35 }
36
37 //Color is red by default
38 m_Color[0]=1.0f;
39 m_Color[1]=0.0f;
40 m_Color[2]=0.0f;
41 m_Color[3]=1.0f;
42 }
43
44 LandmarkPnt::
~LandmarkPnt()45 ~LandmarkPnt()
46 {
47 delete []m_X;
48 }
49
50 //
51 // MedImage Constructors
52 //
53 MetaLandmark::
MetaLandmark()54 MetaLandmark()
55 :MetaObject()
56 {
57 if(META_DEBUG) std::cout << "MetaLandmark()" << std::endl;
58 m_NPoints = 0;
59 Clear();
60 }
61
62 //
63 MetaLandmark::
MetaLandmark(const char * _headerName)64 MetaLandmark(const char *_headerName)
65 :MetaObject()
66 {
67 if(META_DEBUG) std::cout << "MetaLandmark()" << std::endl;
68 m_NPoints = 0;
69 Clear();
70 Read(_headerName);
71 }
72
73 //
74 MetaLandmark::
MetaLandmark(const MetaLandmark * _tube)75 MetaLandmark(const MetaLandmark *_tube)
76 :MetaObject()
77 {
78 if(META_DEBUG) std::cout << "MetaLandmark()" << std::endl;
79 m_NPoints = 0;
80 Clear();
81 CopyInfo(_tube);
82 }
83
84
85
86 //
87 MetaLandmark::
MetaLandmark(unsigned int dim)88 MetaLandmark(unsigned int dim)
89 :MetaObject(dim)
90 {
91 if(META_DEBUG) std::cout << "MetaLandmark()" << std::endl;
92 m_NPoints = 0;
93 Clear();
94 }
95
96 //
97 MetaLandmark::
~MetaLandmark()98 ~MetaLandmark()
99 {
100 Clear();
101 M_Destroy();
102 }
103
104 //
105 void MetaLandmark::
PrintInfo() const106 PrintInfo() const
107 {
108 MetaObject::PrintInfo();
109 std::cout << "PointDim = " << m_PointDim << std::endl;
110 std::cout << "NPoints = " << m_NPoints << std::endl;
111 char str[255];
112 MET_TypeToString(m_ElementType, str);
113 std::cout << "ElementType = " << str << std::endl;
114 }
115
116 void MetaLandmark::
CopyInfo(const MetaObject * _object)117 CopyInfo(const MetaObject * _object)
118 {
119 MetaObject::CopyInfo(_object);
120 }
121
122
123
124 void MetaLandmark::
PointDim(const char * pointDim)125 PointDim(const char* pointDim)
126 {
127 strcpy(m_PointDim,pointDim);
128 }
129
130 const char* MetaLandmark::
PointDim() const131 PointDim() const
132 {
133 return m_PointDim;
134 }
135
136 void MetaLandmark::
NPoints(int npnt)137 NPoints(int npnt)
138 {
139 m_NPoints = npnt;
140 }
141
142 int MetaLandmark::
NPoints() const143 NPoints() const
144 {
145 return m_NPoints;
146 }
147
148
149 /** Clear tube information */
150 void MetaLandmark::
Clear()151 Clear()
152 {
153 if(META_DEBUG) std::cout << "MetaLandmark: Clear" << std::endl;
154 MetaObject::Clear();
155 if(META_DEBUG) std::cout << "MetaLandmark: Clear: m_NPoints" << std::endl;
156 // Delete the list of pointers to tubes.
157 PointListType::iterator it = m_PointList.begin();
158 while(it != m_PointList.end())
159 {
160 LandmarkPnt* pnt = *it;
161 ++it;
162 delete pnt;
163 }
164 m_PointList.clear();
165 m_NPoints = 0;
166 strcpy(m_PointDim, "x y z red green blue alpha");
167 m_ElementType = MET_FLOAT;
168 }
169
170 /** Destroy tube information */
171 void MetaLandmark::
M_Destroy()172 M_Destroy()
173 {
174 MetaObject::M_Destroy();
175 }
176
177 /** Set Read fields */
178 void MetaLandmark::
M_SetupReadFields()179 M_SetupReadFields()
180 {
181 if(META_DEBUG) std::cout << "MetaLandmark: M_SetupReadFields" << std::endl;
182
183 MetaObject::M_SetupReadFields();
184
185 MET_FieldRecordType * mF;
186
187 mF = new MET_FieldRecordType;
188 MET_InitReadField(mF, "PointDim", MET_STRING, true);
189 m_Fields.push_back(mF);
190
191 mF = new MET_FieldRecordType;
192 MET_InitReadField(mF, "NPoints", MET_INT, true);
193 m_Fields.push_back(mF);
194
195 mF = new MET_FieldRecordType;
196 MET_InitReadField(mF, "ElementType", MET_STRING, true);
197 mF->required = true;
198 m_Fields.push_back(mF);
199
200 mF = new MET_FieldRecordType;
201 MET_InitReadField(mF, "Points", MET_NONE, true);
202 mF->terminateRead = true;
203 m_Fields.push_back(mF);
204
205 }
206
207 MET_ValueEnumType MetaLandmark::
ElementType() const208 ElementType() const
209 {
210 return m_ElementType;
211 }
212
213 void MetaLandmark::
ElementType(MET_ValueEnumType _elementType)214 ElementType(MET_ValueEnumType _elementType)
215 {
216 m_ElementType = _elementType;
217 }
218
219
220 void MetaLandmark::
M_SetupWriteFields()221 M_SetupWriteFields()
222 {
223 strcpy(m_ObjectTypeName,"Landmark");
224 MetaObject::M_SetupWriteFields();
225
226 MET_FieldRecordType * mF;
227
228 char s[255];
229 mF = new MET_FieldRecordType;
230 MET_TypeToString(m_ElementType, s);
231 MET_InitWriteField(mF, "ElementType", MET_STRING, strlen(s), s);
232 m_Fields.push_back(mF);
233
234 if(strlen(m_PointDim)>0)
235 {
236 mF = new MET_FieldRecordType;
237 MET_InitWriteField(mF, "PointDim", MET_STRING,
238 strlen(m_PointDim),m_PointDim);
239 m_Fields.push_back(mF);
240 }
241
242 m_NPoints = (int)m_PointList.size();
243 mF = new MET_FieldRecordType;
244 MET_InitWriteField(mF, "NPoints", MET_INT,m_NPoints);
245 m_Fields.push_back(mF);
246
247 mF = new MET_FieldRecordType;
248 MET_InitWriteField(mF, "Points", MET_NONE);
249 m_Fields.push_back(mF);
250
251 }
252
253
254
255 bool MetaLandmark::
M_Read()256 M_Read()
257 {
258 if(META_DEBUG) std::cout << "MetaLandmark: M_Read: Loading Header" << std::endl;
259
260 if(!MetaObject::M_Read())
261 {
262 std::cout << "MetaLandmark: M_Read: Error parsing file" << std::endl;
263 return false;
264 }
265
266 if(META_DEBUG) std::cout << "MetaLandmark: M_Read: Parsing Header" << std::endl;
267
268 MET_FieldRecordType * mF;
269
270 mF = MET_GetFieldRecord("NPoints", &m_Fields);
271 if(mF->defined)
272 {
273 m_NPoints= (int)mF->value[0];
274 }
275
276 mF = MET_GetFieldRecord("ElementType", &m_Fields);
277 if(mF->defined)
278 {
279 MET_StringToType((char *)(mF->value), &m_ElementType);
280 }
281
282
283 mF = MET_GetFieldRecord("PointDim", &m_Fields);
284 if(mF->defined)
285 {
286 strcpy(m_PointDim,(char *)(mF->value));
287 }
288
289 int* posDim= new int[m_NDims];
290 int i;
291 for(i= 0; i < m_NDims; i++)
292 {
293 posDim[i] = -1;
294 }
295
296 int pntDim;
297 char** pntVal = nullptr;
298 MET_StringToWordArray(m_PointDim, &pntDim, &pntVal);
299
300
301 int j;
302 for(j = 0; j < pntDim; j++)
303 {
304 if(!strcmp(pntVal[j], "x") || !strcmp(pntVal[j], "X"))
305 {
306 posDim[0] = j;
307 }
308 if(!strcmp(pntVal[j], "y") || !strcmp(pntVal[j], "Y"))
309 {
310 posDim[1] = j;
311 }
312 if(!strcmp(pntVal[j], "z") || !strcmp(pntVal[j], "Z"))
313 {
314 posDim[2] = j;
315 }
316
317 }
318
319 for(i=0;i<pntDim;i++)
320 {
321 delete [] pntVal[i];
322 }
323 delete [] pntVal;
324
325 float v[16];
326
327 if(m_BinaryData)
328 {
329 int elementSize;
330 MET_SizeOfType(m_ElementType, &elementSize);
331 std::streamsize readSize = m_NPoints*(m_NDims+4)*elementSize;
332
333 char* _data = new char[static_cast<size_t>(readSize)];
334 m_ReadStream->read((char *)_data, readSize);
335
336 std::streamsize gc = m_ReadStream->gcount();
337 if(gc != readSize)
338 {
339 std::cout << "MetaLandmark: m_Read: data not read completely"
340 << std::endl;
341 std::cout << " ideal = " << readSize << " : actual = " << gc << std::endl;
342 delete [] _data;
343 delete [] posDim;
344 return false;
345 }
346
347 i=0;
348 int d;
349 unsigned int k;
350 for(j=0; j<(int)m_NPoints; j++)
351 {
352 LandmarkPnt* pnt = new LandmarkPnt(m_NDims);
353
354 for(d=0; d<m_NDims; d++)
355 {
356 float td;
357 char * const num = (char *)(&td);
358 for(k=0;k<sizeof(float);k++)
359 {
360 num[k] = _data[i+k];
361 }
362 MET_SwapByteIfSystemMSB(&td,MET_FLOAT);
363 i+=sizeof(float);
364 pnt->m_X[d] = (float)td;
365 }
366
367 for(d=0; d<4; d++)
368 {
369 float td;
370 char * const num = (char *)(&td);
371 for(k=0;k<sizeof(float);k++)
372 {
373 num[k] = _data[i+k];
374 }
375 MET_SwapByteIfSystemMSB(&td,MET_FLOAT);
376 i+=sizeof(float);
377 pnt->m_Color[d] = (float)td;
378 }
379
380 m_PointList.push_back(pnt);
381 }
382 delete [] _data;
383 }
384 else
385 {
386 for(j=0; j<(int)m_NPoints; j++)
387 {
388 LandmarkPnt* pnt = new LandmarkPnt(m_NDims);
389
390 for(int k=0; k<pntDim; k++)
391 {
392 *m_ReadStream >> v[k];
393 m_ReadStream->get();
394 }
395
396 int d;
397 for(d=0; d<m_NDims; d++)
398 {
399 pnt->m_X[d] = v[posDim[d]];
400 }
401
402 for(d=0; d<4; d++)
403 {
404 pnt->m_Color[d] = v[d+m_NDims];
405 }
406
407 m_PointList.push_back(pnt);
408 }
409
410
411 char c = ' ';
412 while( (c!='\n') && (!m_ReadStream->eof()))
413 {
414 c = static_cast<char>(m_ReadStream->get());// to avoid unrecognize charactere
415 }
416 }
417
418 delete [] posDim;
419 return true;
420 }
421
422
423 bool MetaLandmark::
M_Write()424 M_Write()
425 {
426
427 if(!MetaObject::M_Write())
428 {
429 std::cout << "MetaLandmark: M_Read: Error parsing file" << std::endl;
430 return false;
431 }
432
433 /** Then copy all points */
434 if(m_BinaryData)
435 {
436 PointListType::const_iterator it = m_PointList.begin();
437 PointListType::const_iterator itEnd = m_PointList.end();
438 int elementSize;
439 MET_SizeOfType(m_ElementType, &elementSize);
440
441 char* data = new char[(m_NDims+4)*m_NPoints*elementSize];
442 int i=0;
443 int d;
444 while(it != itEnd)
445 {
446 for(d = 0; d < m_NDims; d++)
447 {
448 float x = (*it)->m_X[d];
449 MET_SwapByteIfSystemMSB(&x,MET_FLOAT);
450 MET_DoubleToValue((double)x,m_ElementType,data,i++);
451 }
452
453 for(d = 0; d < 4; d++)
454 {
455 float c = (*it)->m_Color[d];
456 MET_SwapByteIfSystemMSB(&c,MET_FLOAT);
457 MET_DoubleToValue((double)c,m_ElementType,data,i++);
458 }
459 ++it;
460 }
461 m_WriteStream->write((char *)data,(m_NDims+4)*m_NPoints*elementSize);
462 m_WriteStream->write("\n",1);
463 delete [] data;
464 }
465 else
466 {
467 PointListType::const_iterator it = m_PointList.begin();
468 PointListType::const_iterator itEnd = m_PointList.end();
469
470 int d;
471 while(it != itEnd)
472 {
473 for(d = 0; d < m_NDims; d++)
474 {
475 *m_WriteStream << (*it)->m_X[d] << " ";
476 }
477
478 for(d = 0; d < 4; d++)
479 {
480 *m_WriteStream << (*it)->m_Color[d] << " ";
481 }
482
483 *m_WriteStream << std::endl;
484 ++it;
485 }
486 }
487
488 return true;
489
490 }
491
492 #if (METAIO_USE_NAMESPACE)
493 };
494 #endif
495