creaImageIO_lib
creaImageIOWxDescriptorPanel.cpp
Go to the documentation of this file.
1 /*
2 # ---------------------------------------------------------------------
3 #
4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
5 # pour la Santé)
6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
9 #
10 # This software is governed by the CeCILL-B license under French law and
11 # abiding by the rules of distribution of free software. You can use,
12 # modify and/ or redistribute the software under the terms of the CeCILL-B
13 # license as circulated by CEA, CNRS and INRIA at the following URL
14 # http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
15 # or in the file LICENSE.txt.
16 #
17 # As a counterpart to the access to the source code and rights to copy,
18 # modify and redistribute granted by the license, users are provided only
19 # with a limited warranty and the software's author, the holder of the
20 # economic rights, and the successive licensors have only limited
21 # liability.
22 #
23 # The fact that you are presently reading this means that you have had
24 # knowledge of the CeCILL-B license and that you accept its terms.
25 # ------------------------------------------------------------------------
26 */
27 
28 
29 #include "creaImageIOWxDescriptorPanel.h"
30 #include <creaImageIOSystem.h>
31 #if defined(USE_GDCM)
32 #include <gdcmGlobal.h>
33 #include <gdcmDictSet.h>
34 #endif
35 
36 #if defined(USE_GDCM2)
37 #include <gdcmGlobal.h>
38 #include <gdcmDicts.h>
39 #include <gdcmDict.h>
40 #endif
41 #include <boost/algorithm/string.hpp>
42 
43 namespace creaImageIO
44 {
45  // CTor
46 
47  WxDescriptorPanel::WxDescriptorPanel(wxWindow *parent, const std::string path)
48  : wxDialog(parent, -1,_T("Descriptor Creation"), wxDefaultPosition, wxSize(550,550)) , m_path(path)
49 {
50 
51 
52  GimmickDebugMessage(1,"WxDescriptorPanel::WxDescriptorPanel"
53  <<std::endl);
54 
55  lv = 0;
56  ownatt["FullFileName"] = "Full_File_Name";
57  ownatt["FullFileDirectory"] = "Full_File_Directory";
58 
59 
60  // START BUTTONS
61  wxButton *NewDescriptor = new wxButton(this, -1,_T("Create a new descriptor"), wxPoint(10,7) );
62  Connect( NewDescriptor->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnNew );
63 
64  wxButton *LoadDescriptor = new wxButton(this, -1,_T("Load a descriptor"), wxPoint(150,7) );
65  Connect( LoadDescriptor->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnLoad );
66 
68  wxStaticLine *line1 = new wxStaticLine(this, -1, wxPoint(5,40), wxSize(540,2));
69 
70  // LEVEL
72  wxStaticText * LevelText=new wxStaticText(this,-1,_T(" Level: "), wxPoint(5,50));
73  LevelCtrl=new wxTextCtrl(this, ID_GR_CTRL,_T("patient"), wxPoint(50,50), wxSize(50,25));
74  wxButton *addLevel = new wxButton(this, ID_LEVEL_ADD,_T("add a level"), wxPoint(150,50) );
75  Connect( addLevel->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnAddLevel );
76 
78  wxStaticLine *line2 = new wxStaticLine(this, -1, wxPoint(5,75), wxSize(540,2));
79 
80  // ATTRIBUTES
81 
83  wxStaticText * GR=new wxStaticText(this,-1,_T(" DICOM Group: "), wxPoint(5,110));
84  GRCtrl=new wxTextCtrl(this, ID_GR_CTRL,_T("0x0010"), wxPoint(82,110), wxSize(50,25));
85  Connect( GRCtrl->GetId(), wxEVT_COMMAND_TEXT_UPDATED , (wxObjectEventFunction) &WxDescriptorPanel::OnDicomAttribute );
86 
88  wxStaticText * EL=new wxStaticText(this,-1,_T(" DICOM Element: "), wxPoint(140,110));
89  ELCtrl=new wxTextCtrl(this, ID_EL_CTRL,_T("0x0010"), wxPoint(230,110), wxSize(50,25));
90  Connect( ELCtrl->GetId(), wxEVT_COMMAND_TEXT_UPDATED , (wxObjectEventFunction) &WxDescriptorPanel::OnDicomAttribute );
91 
92  wxString choices[3];
93  choices[0] = _T("Unknow Attribute");
94  std::map<std::string, std::string>::iterator it_att =ownatt.begin();
95  for(int i = 1; it_att != ownatt.end(); it_att++, i++)
96  {
97  choices[i] = crea::std2wx(it_att->second);
98  }
99 
100 
101  AttributeCombo = new wxComboBox(this, ID_ATTRIBUTE_CTRL,_T(""),wxPoint(300,110), wxSize(120,25),3,choices, wxCB_READONLY);
102  AttributeCombo->SetSelection(0);
103 
104 
105  wxButton *addAttribute = new wxButton(this, ID_ATTRIBUTE_ADD,_T("add an attribute"), wxPoint(440,110) );
106  Connect( addAttribute->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnAddAttribute );
108  wxStaticLine *line3 = new wxStaticLine(this, -1, wxPoint(5,140), wxSize(540,2));
109 
110  // RESULT
111 
112  ResultCtrl=new wxTextCtrl(this, ID_EL_CTRL,_T(""), wxPoint(5,150), wxSize(250,310), wxTE_READONLY| wxMac | wxTE_MULTILINE | wxTE_RICH );
113  wxButton *RemoveCtrl = new wxButton(this, ID_REMOVE_ADD,_T("Remove an entry"), wxPoint(280,200) );
114  Connect( RemoveCtrl->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnRemove );
115 
117  wxStaticLine *line4 = new wxStaticLine(this, -1, wxPoint(5,470), wxSize(540,2));
118  // VALIDATION BUTTON
119  wxButton *Ok = new wxButton(this, -1,_T("OK"), wxPoint(10,480) );
120  Connect( Ok->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnOK );
121 
122  wxButton *Apply = new wxButton(this, -1,_T("APPLY"), wxPoint(150,480) );
123  Connect( Apply->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxDescriptorPanel::OnApply );
124 
126  wxButton *Cancel = new wxButton(this, wxID_CANCEL,_T("CANCEL"), wxPoint(250,480) );
127 // Connect( Cancel->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxCloseEvent) &wxWindow::Close );
128 
129  Layout();
130  CreateDescriptor(0);
131  }
132 
134  WxDescriptorPanel::~WxDescriptorPanel()
135  {
136  GimmickDebugMessage(1,"WxCustomizeConfigPanel::~WxCustomizeConfigPanel"
137  <<std::endl);
138  }
139 
141  // Add an attribute //
142  // @param event : Wxevent //
143  // @return : - //
145  void WxDescriptorPanel::OnAddAttribute(wxCommandEvent& event)
146  {
147  std::string name_lv;
148  std::string name_att;
149  if (AttributeCombo->GetSelection() == 0)
150  {
151  name_att = "D" + crea::wx2std(GRCtrl->GetValue()) + "_" + crea::wx2std(ELCtrl->GetValue());
152  }
153  else
154  {
155  wxString wd = AttributeCombo->GetValue();
156  std::string st = crea::wx2std(wd);
157  name_att = OwnAttribute(st);
158  }
159  onAddAttribute(crea::wx2std(AttributeCombo->GetValue()), name_att);
160  }
162  // add an attribute //
163  // @param att : attribute //
164  // @param name_att : 's name //
165  // @param level : level to add the attribute //
166  // @return : - //
168  void WxDescriptorPanel::onAddAttribute( const std::string &att, const std::string &name_att,std::string level )
169  {
170  if(lv == 0)
171  {
172  wxMessageBox(_T("Need a level first!"),crea::std2wx("WARNING"),wxOK,this);
173  }
174  else
175  {
176  if( !att.empty() )
177  {
178  // Find Name of level
179  if(level.empty())
180  {
181  level = findLevel();
182  }
183 
184  if (!addAtribute(level, name_att))
185  {
186  wxMessageBox(_T("Attribute already used in this level"),crea::std2wx("WARNING"),wxOK,this);
187  }
188  else
189  {
190  ResultCtrl->SetInsertionPoint(InsertPt);
191  for (int i = 1; i<=lv;i++)
192  {
193  ResultCtrl->WriteText(_T(" "));
194  }
195  ResultCtrl->WriteText(_T("| - "));
196  ResultCtrl->WriteText(crea::std2wx(att));
197  wxTextAttr ResultAttr(ResultCtrl->GetDefaultStyle());
198  ResultAttr.SetTextColour(*wxWHITE);
199  ResultCtrl->SetDefaultStyle(ResultAttr);
200  std::string text = " ";
201  ResultCtrl->WriteText(crea::std2wx(" " + name_att));
202  ResultAttr.SetTextColour(*wxBLACK);
203  ResultCtrl->SetDefaultStyle(ResultAttr);
204  ResultCtrl->WriteText(_T("\n"));
205  }
206  InsertPt = ResultCtrl->GetInsertionPoint();
207  }
208  }
209  }
210 
212  // add a level //
213  // @param event : Wxevent //
214  // @return : - //
216  void WxDescriptorPanel::OnAddLevel(wxCommandEvent& event)
217  {
218  if( !LevelCtrl->GetValue().IsEmpty() )
219  {
220  onAddLevel(crea::wx2std(LevelCtrl->GetValue()));
221  }
222  }
223 
225  // add a level //
226  // @param level : level's name //
227  // @return : - //
229  void WxDescriptorPanel::onAddLevel(const std::string &level)
230  {
231  if(addLevel(level))
232  {
233  wxMessageBox(_T("Level already used"),crea::std2wx(("WARNING")),wxOK,this);
234  return;
235  }
236 
237  lv++;
238  ResultCtrl->SetInsertionPoint(InsertPt);
239  for (int i = 1; i<lv;i++)
240  {
241  ResultCtrl->WriteText(_T(" "));
242  }
243  if(lv>1)
244  { ResultCtrl->WriteText(_T("| \n"));
245  for (int i = 1; i<lv;i++)
246  {
247  ResultCtrl->WriteText(_T(" "));
248  }
249  ResultCtrl->WriteText(_T("|_"));
250  }
251 
252  wxTextAttr ResultAttr(ResultCtrl->GetDefaultStyle());
253  ResultAttr.SetTextColour(*wxRED);
254  ResultCtrl->SetDefaultStyle(ResultAttr);
255  ResultCtrl->WriteText(crea::std2wx(level));
256  ResultAttr.SetTextColour(*wxBLACK);
257  ResultCtrl->SetDefaultStyle(ResultAttr);
258  ResultCtrl->WriteText(_T("\n"));
259  InsertPt = ResultCtrl->GetInsertionPoint();
260 
261  }
262 
264  // Find a DICOM attribute from group and element values //
265  // @param event : Wxevent //
266  // @return : - //
268  void WxDescriptorPanel::OnDicomAttribute(wxCommandEvent& event)
269  {
270  //int i = 0;
271  if(!GRCtrl->GetValue().IsEmpty() && !ELCtrl->GetValue().IsEmpty()
272  && GRCtrl->GetValue().Len() == 6 && ELCtrl->GetValue().Len() == 6 && AttributeCombo->GetSelection() == 0)
273  {
274 
275  std::string gr = crea::wx2std(GRCtrl->GetValue());
276  std::string el = crea::wx2std(ELCtrl->GetValue());
277  std::stringstream val;
278 
279  unsigned short group;
280  unsigned short element;
281  val << std::dec << gr ;
282  val >> std::hex >> group;
283  val.clear();
284  val << std::dec << el ;
285  val >> std::hex >> element;
286 #if defined(USE_GDCM)
287  // Retrieve the name from gdcm dict
288  GDCM_NAME_SPACE::DictEntry* entry = GDCM_NAME_SPACE::Global::GetDicts()->GetDefaultPubDict()->GetEntry(group, element);
289  // AttributeCombo->Clear();
290  if(entry)
291  {
292  AttributeCombo->Delete(0);
293  AttributeCombo->Insert(crea::std2wx(entry->GetName()), 0);
294  }
295  else
296  {
297  AttributeCombo->Delete(0);
298  AttributeCombo->Insert(_T("Unknown Attribute"),0);
299  }
300 #endif
301  AttributeCombo->SetSelection(0);
302 
303  }
304 
305  }
306 
307 
309  // determine values for own attributes //
310  // @param name : attribute's name //
311  // @param key : indicates key map or not //
312  // @return : - //
314  std::string WxDescriptorPanel::OwnAttribute(const std::string name)
315  {
316  std::string result;
317 
318  std::map<std::string, std::string>::iterator it_att = ownatt.begin();
319  for(; it_att != ownatt.end(); it_att++)
320  {
321  if(it_att->second == name)
322  {
323  result = it_att->first.c_str();
324  break;
325  }
326  }
327  return result;
328  }
329 
331  // Find a level in function of position in Return Ctrl //
332  // @param - : //
333  // @return : - //
335  std::string WxDescriptorPanel::findLevel()
336  {
337  long column;
338  long line;
339 
340  ResultCtrl->PositionToXY( ResultCtrl->GetInsertionPoint(),&column, &line);
341  std::string tx(crea::wx2std(ResultCtrl->GetRange(0, ResultCtrl->XYToPosition(0,line+1))).c_str());
342  std::string::size_type level_pos_start = tx.rfind("|_");
343  if(level_pos_start == -1)
344  {
345  level_pos_start = 0;
346  }
347  else
348  {
349  level_pos_start += 2;
350  }
351 
352  std::string::size_type level_pos_end = tx.find_first_of("\n",level_pos_start);
353  return tx.substr(level_pos_start,level_pos_end - level_pos_start);
354  }
355 
357  // Remove an item //
358  // @param event : Wxevent //
359  // @return : - //
361  void WxDescriptorPanel::OnRemove(wxCommandEvent& event)
362  {
363  long line;
364  long column;
365  long pos_start;
366  long pos_end;
367 
368  pos_start = ResultCtrl->GetInsertionPoint();
369  ResultCtrl->PositionToXY( pos_start,&column, &line);
370  if (line == 0)
371  {
372  std::string name("root");
373  RemoveLevel(name);
374  ResultCtrl->Clear();
375  lv = 0;
376  }
377  else
378  {
379  wxString text = ResultCtrl->GetLineText(line);
380  if ( text.Find(_T("|_")) == -1)
381  {
382  std::string level = findLevel();
383  // find GR and EL values to remove
384  std::string tx = crea::wx2std(text);
385  std::string::size_type EL_start_pos = tx.find_last_of(" ");
386  RemoveAttribute(level, tx.substr(EL_start_pos+1,tx.size() - EL_start_pos));
387  ResultCtrl->Remove( ResultCtrl->XYToPosition(0,line), ResultCtrl->XYToPosition(0,line+1));
388  }
389  else
390  {
391  RemoveLevel(crea::wx2std(text.AfterFirst('_')));
392  lv = text.Find(_T("|"))/3;
393  pos_start= ResultCtrl->XYToPosition(0,line-1);
394  ResultCtrl->SetInsertionPointEnd();
395  pos_end = ResultCtrl->GetInsertionPoint();
396  ResultCtrl->Remove(pos_start, pos_end);
397  }
398  }
399 
400  }
402  // create a descriptor structure //
403  // @param name : level's name to add //
404  // @return : boolean result //
406  void WxDescriptorPanel::CreateDescriptor(int type)
407  {
408  if(type == 0) // First initialization
409  {
410  outDscp.clear();
411  outDscp += "<level>";
412  outDscp += "\n";
413  outDscp += "root";
414  outDscp += "\n";
415  outDscp += "O Name Name 4";
416  outDscp += "\n";
417  }
418  if(type == 1)
419  {
420  if(lv > 1)
421  {
422  outDscp += "O NumberOfChildren ";
423  outDscp += crea::wx2std(LevelCtrl->GetValue());
424  outDscp += "s";
425  outDscp += "\n";
426  }
427  outDscp += "<level>";
428  outDscp += "\n";
429  outDscp += crea::wx2std(LevelCtrl->GetValue());
430  outDscp += "\n";
431 
432  }
433  if(type == 2)
434  {
435  outDscp += "D";
436  outDscp += " ";
437  outDscp += crea::wx2std(GRCtrl->GetValue());
438  outDscp += " ";
439  outDscp += crea::wx2std(ELCtrl->GetValue());
440  outDscp += " ";
441  outDscp += "3";
442  outDscp += "\n";
443  }
444 
445 
446  }
447 
448 
450  // add a level //
451  // @param name : level's name to add //
452  // @return : boolean result //
454  bool WxDescriptorPanel::addLevel(const std::string &name)
455  {
456  bool bfound = false;
457  std::map<std::string, std::vector <std::string> >::iterator it_tree = DscpTree.begin();
458  for (;it_tree != DscpTree.end(); it_tree++)
459  {
460  if(it_tree->first == name)
461  {
462  bfound = true;
463  break;
464  }
465  }
466  if(!bfound)
467  {
468  lvlist[lv] = name;
469  std::vector <std::string> branch;
470  DscpTree[name] = branch;
471  }
472  return bfound;
473  }
474 
476  // remove a level //
477  // @param name : level's name to remove //
478  // @return : boolean result //
480  bool WxDescriptorPanel::RemoveLevel(const std::string &name)
481  {
482  bool bresult = false;
483  std::map<int, std::string>::iterator it_list= lvlist.begin();
484  for(; it_list != lvlist.end(); it_list++)
485  {
486  if(it_list->second == name)
487  {
488  break;
489  }
490  }
491  std::map<int, std::string>::iterator it_list2 = it_list;
492  for(;it_list != lvlist.end(); it_list++)
493  {
494  std::map<std::string, std::vector <std::string> >::iterator it_tree = DscpTree.begin();
495  for (;it_tree != DscpTree.end(); it_tree++)
496  {
497  if(it_tree->first == name)
498  {
499  DscpTree.erase(it_tree);
500  break;
501  }
502  }
503  }
504  lvlist.erase(it_list2, lvlist.end());
505  return bresult;
506  }
507 
508 
510  // add an attribute in a level //
511  // @param level : level's name to add attribute //
512  // @param name : attribute's name //
513  // @return : boolean result //
515  bool WxDescriptorPanel::addAtribute(const std::string &level, const std::string &name)
516  {
517  bool bresult = true;
518  std::map<std::string, std::vector <std::string> >::iterator it_tree = DscpTree.begin();
519  for (;it_tree != DscpTree.end(); it_tree++)
520  {
521  if (it_tree->first.c_str() == level)
522  {
523  std::vector<std::string>::iterator it_branch = it_tree->second.begin();
524  for(;it_branch != it_tree->second.end(); it_branch++)
525  {
526  if(it_branch->c_str() == name)
527  {
528  bresult = false;
529  }
530  }
531  if(bresult)
532  {
533  it_tree->second.push_back(name);
534  break;
535  }
536  }
537  }
538  return bresult;
539  }
540 
542  // remove an attribute from a level //
543  // @param level : level's name to remove attribute //
544  // @param name : attribute's name //
545  // @return : boolean result //
547  bool WxDescriptorPanel::RemoveAttribute(const std::string &level, const std::string &name)
548  {
549  bool bresult = false;
550  std::map<std::string, std::vector <std::string> >::iterator it_tree = DscpTree.begin();
551  for (;it_tree != DscpTree.end(); it_tree++)
552  {
553  if(it_tree->first == level)
554  {
555  std::vector<std::string>::iterator it_branch = it_tree->second.begin();
556  cout << it_tree->second.size();
557  for(;it_branch != it_tree->second.end(); it_branch++)
558  {
559  if(it_branch->c_str() == name)
560  {
561  bresult = true;
562  it_tree->second.erase(it_branch);
563  break;
564  }
565  }
566  }
567  }
568  return bresult;
569  }
570 
572  // create a new descriptor //
573  // @param event : WxEvent //
574  // @return : - //
576  void WxDescriptorPanel::OnNew(wxCommandEvent &Event)
577  {
578  LevelCtrl->SetValue(_T("patient"));
579  ResultCtrl->Clear();
580  DscpTree.clear();
581  lv = 0;
582  }
583 
585  // Load a descriptor file //
586  // @param event : WxEvent //
587  // @return : - //
589  void WxDescriptorPanel::OnLoad(wxCommandEvent &Event)
590  {
591  long style = wxOPEN | wxFILE_MUST_EXIST;
592  LevelCtrl->SetValue(_T("patient"));
593  ResultCtrl->Clear();
594  DscpTree.clear();
595  lv = 0;
596 
597  std::string wc("*.dscp");
598  wxFileDialog* FD = new wxFileDialog( 0,
599  _T("Select file"),
600  crea::std2wx(m_path),
601  _T(""),
602  crea::std2wx(wc),
603  style,
604  wxDefaultPosition);
605  if (FD->ShowModal()==wxID_OK)
606  {
607  loadDescriptor(crea::wx2std(FD->GetPath()).c_str());
608  }
609 
610  }
611 
613  // Save a descriptor //
614  // @param event : WxEvent //
615  // @return : - //
617  void WxDescriptorPanel::OnOK(wxCommandEvent &Event)
618  {
619  saveDescriptor();
620  wxWindow::Close();
621  }
622 
624  // Save a descriptor and apply it (create a new DB//
625  // @param event : WxEvent //
626  // @return : - //
628  void WxDescriptorPanel::OnApply(wxCommandEvent &Event)
629  {
630  m_DscpFile = saveDescriptor();
631  wxWindow::Close();
632  SetReturnCode(ID_DSCP_APPLY);
633  }
634 
635  const std::string WxDescriptorPanel::saveDescriptor()
636  {
637  std::string file = "";
638  long style = wxSAVE;
639  std::string wc("*.dscp");
640  wxFileDialog* FD = new wxFileDialog( 0,
641  _T("Select file"),
642  _T(""),
643  _T(""),
644  crea::std2wx(wc),
645  style,
646  wxDefaultPosition);
647 
648 
649  if (FD->ShowModal()==wxID_OK)
650  {
651  createDescriptorFile();
652  file = crea::wx2std(FD->GetPath()).c_str();
653  std::ofstream ofs(file.c_str());
654  ofs.clear();
655  ofs << outDscp;
656  ofs.close();
657  }
658  return file.c_str();
659  }
660 
662  // Cancel action //
663  // @param event : WxEvent //
664  // @return : - //
666 
667  void WxDescriptorPanel::OnCancel(wxCommandEvent& event)
668  {
669  }
670 
672  // create a descriptor file //
673  // @param - : //
674  // @return : - //
676  void WxDescriptorPanel::createDescriptorFile()
677  {
678 
679  outDscp.clear();
680  outDscp += "<level>";
681  outDscp += "\n";
682  outDscp += "Root";
683  outDscp += "\n";
684  outDscp += "O Name Name 4";
685  outDscp += "\n";
686  std::map<std::string, std::vector <std::string> >::iterator it_tree = DscpTree.begin();
687  std::map<int, std::string >::iterator it_lv_nb = lvlist.begin();
688  std::map<int, std::string >::iterator it_lv = lvlist.begin();
689  it_lv_nb++;
690  for (;it_lv != lvlist.end(); it_lv++)
691  {
692  outDscp +="<level>";
693  outDscp += "\n";
694  outDscp += it_lv->second.c_str();
695  outDscp += "\n";
696  if(it_lv_nb != lvlist.end())
697  {
698  outDscp += "O NumberOfChildren ";
699  outDscp += it_lv_nb->second.c_str();
700  outDscp += "s";
701  outDscp += "\n";
702  it_lv_nb++;
703  }
704  std::vector<std::string>::iterator it_branch = DscpTree[it_lv->second.c_str()].begin();
705  for(;it_branch != DscpTree[it_lv->second.c_str()].end(); it_branch++)
706  {
707  std::string att = it_branch->c_str();
708  if(att[0] == 'D' && att[7] == '_' && att.size() == 14)
709  {
710  outDscp += "D ";
711  outDscp += att.substr(1,6) + " "; // GR
712  outDscp += att.substr(8,6) + " ";// EL
713  outDscp += "3";
714  outDscp += "\n";
715  }
716  else
717  {
718  outDscp += "O ";
719  outDscp += it_branch->c_str();
720  outDscp += " ";
721  outDscp += ownatt[att];
722  outDscp += " ";
723  outDscp += "2";
724  outDscp += "\n";
725  }
726  }
727 
728  }
729  }
730 
731 
733  // load a descriptor //
734  // @param i_name : file name to load //
735  // @return : - //
737  void WxDescriptorPanel::loadDescriptor(const std::string i_name)
738  {
739  std::ifstream i_file(i_name.c_str());
740  std::stringstream buffer;
741  buffer << i_file.rdbuf();
742  std::string line;
743  std::string level;
744 
745 #if defined(USE_GDCM2)
746  const gdcm::Global& g = gdcm::Global::GetInstance(); // sum of all knowledge !
747  const gdcm::Dicts &dicts = g.GetDicts();
748  const gdcm::Dict &dict = dicts.GetPublicDict(); // Part 6
749 #endif
750 
751 
752  bool bname;
753  int ilevel = -1;
754 
755 
756  while(std::getline(buffer, line))
757  {
758  if(line =="<level>")
759  { //increment levels.
760  ilevel++;
761  bname = true;
762  }
763  else if(bname)
764  {
765  // For each level, a name to describe it
766  level = line;
767  if(ilevel>0)
768  {
769  onAddLevel(level);
770  }
771  bname = false;
772  }
773  else
774  {
775  // split line to find all tags
776  std::vector<std::string> descriptors;
777  std::string separator = " ";
778  std::string::size_type last_pos = line.find_first_not_of(separator);
779  //find first separator
780  std::string::size_type pos = line.find_first_of(separator, last_pos);
781  while(std::string::npos != pos || std::string::npos != last_pos)
782  {
783  descriptors.push_back(line.substr(last_pos, pos - last_pos));
784  last_pos = line.find_first_not_of(separator, pos);
785  pos = line.find_first_of(separator, last_pos);
786  }
787 
788  // By default, the last tag is at zero and not recorded but if take in count
789  unsigned int flag = 0;
790  if(descriptors.size() == 4)
791  {
792  std::stringstream val;
793  val << std::dec << descriptors[3];
794  val>> flag;
795  }
796 
797  // if Dicom tag, use "group" and "element" descriptor
798  if(descriptors[0] == "D")
799  { std::stringstream val, val2;
800  unsigned short group;
801  unsigned short element;
802  val << std::dec << descriptors[1] ;
803  val >> std::hex >> group;
804  val2 << std::dec << descriptors[2];
805  val2 >> std::hex >> element;
806  std::string compose = "D";
807  compose += descriptors[1];
808  compose += "_";
809  compose += descriptors[2];
810 #if defined(USE_GDCM)
811  GDCM_NAME_SPACE::DictEntry* entry = GDCM_NAME_SPACE::Global::GetDicts()->GetDefaultPubDict()->GetEntry(group, element);
812  if(ilevel>0)
813  {
814  onAddAttribute( entry->GetName(),compose, level);
815  }
816 #endif
817 
818 #if defined(USE_GDCM2)
819  gdcm::DictEntry dictentry = dict.GetDictEntry(gdcm::Tag(group, element));
820  if(ilevel>0)
821  {
822  onAddAttribute( dictentry.GetName(),compose, level);
823  }
824 
825 
826 #endif
827  }
828  else if(descriptors[0].find("#") != -1)
829  {
830  // commented line continue to next line
831  }
832  else // "O" means if user's own tag.
833  {
834  boost::algorithm::replace_all(descriptors[2],"_"," ");
835  if(ilevel>0 && descriptors[1] != "NumberOfChildren" )
836  {
837  onAddAttribute( descriptors[2].c_str(),descriptors[1].c_str(), level);
838  }
839  }
840  }
841  }
842  }
843 
844 //======================================================================
845 
846 //======================================================================
847 
848 } // EO namespace creaImageIO
849 
850