vv/vvReadState.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://www.centreleonberard.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17   ===========================================================================**/
  18
  19 #include "vvReadState.h"
  20 #include "vvMainWindow.h"
  21 #include "vvSlicerManager.h"
  22 #include "vvToolCreatorBase.h"
  23 #include "vvToolBaseBase.h"
  24
  25 #include <qtreewidget.h>
  26
  27 #include <QFile>
  28 #include <QXmlStreamReader>
  29
  30 #include <cassert>
  31 #include <string>
  32
  33 //------------------------------------------------------------------------------
  34 vvReadState::vvReadState() : m_XmlReader(new QXmlStreamReader), m_File(new QFile)
  35 {
  36   m_NumImages = 0;
  37 }
  38 //------------------------------------------------------------------------------
  39
  40
  41 //------------------------------------------------------------------------------
  42 vvReadState::~vvReadState()
  43 {
  44 }
  45 //------------------------------------------------------------------------------
  46
  47
  48 //------------------------------------------------------------------------------
  49 void vvReadState::Run(vvMainWindow* vvWindow, const std::string& file)
  50 {
  51   assert(vvWindow);
  52
  53   m_NumImages = 0;
  54   m_File->setFileName(file.c_str());
  55   m_File->open(QIODevice::ReadOnly);
  56   m_XmlReader->setDevice(m_File.get());
  57   m_Window = vvWindow;
  58   QTreeWidget* tree = m_Window->GetTree();
  59
  60   // Get the number of images already loaded
  61   m_TreeItemCount = tree->topLevelItemCount();
  62
  63   // Read elements
  64   ReadGUI();
  65   ReadTree();
  66   ReadTools();
  67 }
  68 //------------------------------------------------------------------------------
  69
  70
  71 //------------------------------------------------------------------------------
  72 void vvReadState::ReadTree()
  73 {
  74   std::string value;
  75
  76   // read images
  77   while (!m_XmlReader->isEndElement() || value != "Images") {
  78     m_XmlReader->readNext();
  79     value = m_XmlReader->qualifiedName().toString().toStdString();
  80     if (m_XmlReader->isStartElement()) {
  81       if (value == "Image") value = ReadImage();
  82     }
  83   }
  84
  85   // read links
  86   while (!m_XmlReader->isEndElement() || value != "Links") {
  87     m_XmlReader->readNext();
  88     value = m_XmlReader->qualifiedName().toString().toStdString();
  89     if (m_XmlReader->isStartElement()) {
  90       if (value == "LinkedFrom") value = ReadLink();
  91     }
  92   }
  93
  94   if (m_XmlReader->hasError())
  95     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
  96 }
  97 //------------------------------------------------------------------------------
  98
  99
 100 //------------------------------------------------------------------------------
 101 std::string  vvReadState::ReadImage()
 102 {
 103   std::string value;
 104   int current_index = -1;
 105   std::vector<std::string> files(1);
 106
 107   QXmlStreamAttributes attributes = m_XmlReader->attributes();
 108   if (!m_XmlReader->hasError())
 109     current_index = attributes.value("Index").toString().toInt();
 110
 111   current_index += m_TreeItemCount;
 112
 113   while (!m_XmlReader->isEndElement() || value != "Image") {
 114     m_XmlReader->readNext();
 115     value = m_XmlReader->qualifiedName().toString().toStdString();
 116     if (m_XmlReader->isStartElement()) {
 117       if (value == "FileName") {
 118         files[0] = m_XmlReader->readElementText().toStdString();
 119         if (!m_XmlReader->hasError()) {
 120           m_Window->LoadImages(files, vvImageReader::IMAGE);
 121         }
 122       }
 123       else if (current_index >= 0) {
 124         vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[current_index];
 125         if (value == "Preset") {
 126           double vali = m_XmlReader->readElementText().toInt();
 127           if (!m_XmlReader->hasError())
 128             slicerManager->SetPreset(vali);
 129         }
 130         else if (value == "Window") {
 131           double vald = m_XmlReader->readElementText().toDouble();
 132           if (!m_XmlReader->hasError())
 133             slicerManager->SetColorWindow(vald);
 134         }
 135         else if (value == "Level") {
 136           double vald = m_XmlReader->readElementText().toDouble();
 137           if (!m_XmlReader->hasError())
 138             slicerManager->SetColorLevel(vald);
 139         }
 140         else if (value == "Fusion")
 141           value = ReadFusion(current_index);
 142         else if (value == "Overlay")
 143           value = ReadOverlay(current_index);
 144         else if (value == "Vector")
 145           value = ReadVector(current_index);
 146       }
 147     }
 148   }
 149
 150   if (!m_XmlReader->hasError())
 151     m_NumImages++;
 152
 153   return value;
 154 }
 155 //------------------------------------------------------------------------------
 156
 157
 158 //------------------------------------------------------------------------------
 159 std::string vvReadState::ReadFusion(int index)
 160 {
 161   std::string file, value;
 162   int vali;
 163   double vald;
 164   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 165   while (!m_XmlReader->isEndElement() || value != "Fusion") {
 166     m_XmlReader->readNext();
 167     value = m_XmlReader->qualifiedName().toString().toStdString();
 168     if (m_XmlReader->isStartElement()) {
 169       if (value == "FileName") {
 170         file = m_XmlReader->readElementText().toStdString();
 171         if (!m_XmlReader->hasError())
 172           m_Window->AddFusionImage(index, file.c_str());
 173       }
 174       if (value == "FusionOpacity") {
 175         vali = m_XmlReader->readElementText().toInt();
 176         if (!m_XmlReader->hasError())
 177           slicerManager->SetFusionOpacity(vali);
 178       }
 179       if (value == "FusionThresholdOpacity") {
 180         vali = m_XmlReader->readElementText().toInt();
 181         if (!m_XmlReader->hasError())
 182           slicerManager->SetFusionThresholdOpacity(vali);
 183       }
 184       if (value == "FusionColorMap") {
 185         vali = m_XmlReader->readElementText().toInt();
 186         if (!m_XmlReader->hasError())
 187           slicerManager->SetFusionColorMap(vali);
 188       }
 189       if (value == "FusionWindow") {
 190         vald = m_XmlReader->readElementText().toDouble();
 191         if (!m_XmlReader->hasError())
 192           slicerManager->SetFusionWindow(vald);
 193       }
 194       if (value == "FusionLevel") {
 195         vald = m_XmlReader->readElementText().toDouble();
 196         if (!m_XmlReader->hasError())
 197           slicerManager->SetFusionLevel(vald);
 198       }
 199     }
 200   }
 201   m_Window->ImageInfoChanged();
 202   return value;
 203 }
 204 //------------------------------------------------------------------------------
 205
 206
 207 //------------------------------------------------------------------------------
 208 std::string vvReadState::ReadOverlay(int index)
 209 {
 210   std::string file, value;
 211   int vali;
 212   double vald;
 213   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 214   while (!m_XmlReader->isEndElement() || value != "Overlay") {
 215     m_XmlReader->readNext();
 216     value = m_XmlReader->qualifiedName().toString().toStdString();
 217     if (m_XmlReader->isStartElement()) {
 218       if (value == "FileName") {
 219         file = m_XmlReader->readElementText().toStdString();
 220         if (!m_XmlReader->hasError()) {
 221           // TODO: manage sequence of images
 222           std::vector<std::string> vec;
 223           vec.push_back(file.c_str());
 224           m_Window->AddOverlayImage(index, vec, vvImageReader::IMAGE);
 225         }
 226       }
 227       if (value == "OverlayColorWindow") {
 228         vald = m_XmlReader->readElementText().toDouble();
 229         if (!m_XmlReader->hasError())
 230           slicerManager->SetOverlayColorWindow(vald);
 231       }
 232       if (value == "OverlayColorLevel") {
 233         vald = m_XmlReader->readElementText().toDouble();
 234         if (!m_XmlReader->hasError())
 235           slicerManager->SetOverlayColorLevel(vald);
 236       }
 237       if (value == "LinkOverlayWindowLevel") {
 238         vali = m_XmlReader->readElementText().toInt();
 239         if (!m_XmlReader->hasError())
 240           slicerManager->SetLinkOverlayWindowLevel(vali);
 241       }
 242       if (value == "OverlayColor") {
 243         vali = m_XmlReader->readElementText().toInt();
 244         if (!m_XmlReader->hasError())
 245           slicerManager->SetOverlayColor(vali);
 246       }
 247     }
 248   }
 249   m_Window->ImageInfoChanged();
 250   return value;
 251 }
 252 //------------------------------------------------------------------------------
 253
 254
 255 //------------------------------------------------------------------------------
 256 std::string vvReadState::ReadVector(int index)
 257 {
 258   std::string file, value;
 259   while (!m_XmlReader->isEndElement() || value != "Vector") {
 260     m_XmlReader->readNext();
 261     value = m_XmlReader->qualifiedName().toString().toStdString();
 262     if (m_XmlReader->isStartElement()) {
 263       if (value == "FileName") {
 264         file = m_XmlReader->readElementText().toStdString();
 265         if (!m_XmlReader->hasError())
 266           m_Window->AddField(file.c_str(), index);
 267       }
 268     }
 269   }
 270   return value;
 271 }
 272 //------------------------------------------------------------------------------
 273
 274
 275 //------------------------------------------------------------------------------
 276 std::string  vvReadState::ReadLink()
 277 {
 278   std::string id_from, id_to, value;
 279
 280   QXmlStreamAttributes attributes = m_XmlReader->attributes();
 281   if (!m_XmlReader->hasError()) {
 282     id_from = attributes.value("Id").toString().toStdString();
 283   }
 284
 285   while (!m_XmlReader->isEndElement() || value != "LinkedFrom") {
 286     m_XmlReader->readNext();
 287     value = m_XmlReader->qualifiedName().toString().toStdString();
 288     if (m_XmlReader->isStartElement()) {
 289       if (value == "LinkedTo") {
 290         id_to = m_XmlReader->readElementText().toStdString();
 291         if (!m_XmlReader->hasError()) {
 292           m_Window->AddLink(id_from.c_str(), id_to.c_str(), false);
 293         }
 294       }
 295     }
 296   }
 297
 298   return value;
 299 }
 300 //------------------------------------------------------------------------------
 301
 302 //------------------------------------------------------------------------------
 303 void vvReadState::ReadGUI()
 304 {
 305
 306 }
 307 //------------------------------------------------------------------------------
 308
 309
 310 //------------------------------------------------------------------------------
 311 void vvReadState::ReadTools()
 312 {
 313   std::string value;
 314
 315   while ((!m_XmlReader->hasError()) && (!m_XmlReader->isEndElement() || value != "Tools")) {
 316     m_XmlReader->readNext();
 317     value = m_XmlReader->qualifiedName().toString().toStdString();
 318     if (value != "Tools") {
 319       if (m_XmlReader->isStartElement()) {
 320         ReadTool(value);
 321       }
 322     }
 323   }
 324
 325   if (m_XmlReader->hasError())
 326     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 327 }
 328 //------------------------------------------------------------------------------
 329
 330
 331 //------------------------------------------------------------------------------
 332 void vvReadState::ReadTool(const std::string & toolname)
 333 {
 334   // Find name into vvToolManager::GetInstance()->GetListOfTools();
 335   vvToolCreatorBase * v = vvToolManager::GetInstance()->GetToolCreatorFromName(toolname.c_str());
 336   if (v == NULL) {
 337     std::cerr << "Error, I do not know the tool named '" << toolname << "' ; ignored." << std::endl;
 338     std::string value="";
 339     while (!m_XmlReader->isEndElement() || value != toolname) {
 340       m_XmlReader->readNext();
 341       value = m_XmlReader->qualifiedName().toString().toStdString();
 342       if (m_XmlReader->hasError()) {
 343         std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 344         return;
 345       }
 346     }
 347     return;
 348   }
 349
 350   // CreateTool
 351   // std::vector<vvToolBaseBase*> & tools = v->GetListOfTool();
 352   v->m_XmlReader = m_XmlReader;
 353   v->mReadStateFlag = true;
 354   v->mImageIndex = m_TreeItemCount;
 355   v->MenuSpecificToolSlot();
 356   v->mReadStateFlag = false;
 357   m_XmlReader = v->m_XmlReader; // Need because auto_ptr operator= release on the right.
 358 }
 359 //------------------------------------------------------------------------------