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   while (!m_XmlReader->isEndElement() || value != "Images") {
  77     m_XmlReader->readNext();
  78     value = m_XmlReader->qualifiedName().toString().toStdString();
  79     if (m_XmlReader->isStartElement()) {
  80       if (value == "Image") value = ReadImage();
  81     }
  82   }
  83
  84   if (m_XmlReader->hasError())
  85     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
  86 }
  87 //------------------------------------------------------------------------------
  88
  89
  90 //------------------------------------------------------------------------------
  91 std::string  vvReadState::ReadImage()
  92 {
  93   std::string value;
  94   int current_index = -1;
  95   std::vector<std::string> files(1);
  96
  97   QXmlStreamAttributes attributes = m_XmlReader->attributes();
  98   if (!m_XmlReader->hasError())
  99     current_index = attributes.value("Index").toString().toInt();
 100
 101   current_index += m_TreeItemCount;
 102
 103   while (!m_XmlReader->isEndElement() || value != "Image") {
 104     m_XmlReader->readNext();
 105     value = m_XmlReader->qualifiedName().toString().toStdString();
 106     if (m_XmlReader->isStartElement()) {
 107       if (value == "FileName") {
 108         files[0] = m_XmlReader->readElementText().toStdString();
 109         if (!m_XmlReader->hasError()) {
 110           m_Window->LoadImages(files, vvImageReader::IMAGE);
 111         }
 112       }
 113       else if (current_index >= 0) {
 114         vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[current_index];
 115         if (value == "Preset") {
 116           double vali = m_XmlReader->readElementText().toInt();
 117           if (!m_XmlReader->hasError())
 118             slicerManager->SetPreset(vali);
 119         }
 120         else if (value == "Window") {
 121           double vald = m_XmlReader->readElementText().toDouble();
 122           if (!m_XmlReader->hasError())
 123             slicerManager->SetColorWindow(vald);
 124         }
 125         else if (value == "Level") {
 126           double vald = m_XmlReader->readElementText().toDouble();
 127           if (!m_XmlReader->hasError())
 128             slicerManager->SetColorLevel(vald);
 129         }
 130         else if (value == "Fusion")
 131           value = ReadFusion(current_index);
 132         else if (value == "Overlay")
 133           value = ReadOverlay(current_index);
 134         else if (value == "Vector")
 135           value = ReadVector(current_index);
 136       }
 137     }
 138   }
 139
 140   if (!m_XmlReader->hasError())
 141     m_NumImages++;
 142
 143   return value;
 144 }
 145 //------------------------------------------------------------------------------
 146
 147
 148 //------------------------------------------------------------------------------
 149 std::string vvReadState::ReadFusion(int index)
 150 {
 151   std::string file, value;
 152   int vali;
 153   double vald;
 154   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 155   while (!m_XmlReader->isEndElement() || value != "Fusion") {
 156     m_XmlReader->readNext();
 157     value = m_XmlReader->qualifiedName().toString().toStdString();
 158     if (m_XmlReader->isStartElement()) {
 159       if (value == "FileName") {
 160         file = m_XmlReader->readElementText().toStdString();
 161         if (!m_XmlReader->hasError())
 162           m_Window->AddFusionImage(index, file.c_str());
 163       }
 164       if (value == "FusionOpacity") {
 165         vali = m_XmlReader->readElementText().toInt();
 166         if (!m_XmlReader->hasError())
 167           slicerManager->SetFusionOpacity(vali);
 168       }
 169       if (value == "FusionThresholdOpacity") {
 170         vali = m_XmlReader->readElementText().toInt();
 171         if (!m_XmlReader->hasError())
 172           slicerManager->SetFusionThresholdOpacity(vali);
 173       }
 174       if (value == "FusionColorMap") {
 175         vali = m_XmlReader->readElementText().toInt();
 176         if (!m_XmlReader->hasError())
 177           slicerManager->SetFusionColorMap(vali);
 178       }
 179       if (value == "FusionWindow") {
 180         vald = m_XmlReader->readElementText().toDouble();
 181         if (!m_XmlReader->hasError())
 182           slicerManager->SetFusionWindow(vald);
 183       }
 184       if (value == "FusionLevel") {
 185         vald = m_XmlReader->readElementText().toDouble();
 186         if (!m_XmlReader->hasError())
 187           slicerManager->SetFusionLevel(vald);
 188       }
 189     }
 190   }
 191   m_Window->ImageInfoChanged();
 192   return value;
 193 }
 194 //------------------------------------------------------------------------------
 195
 196
 197 //------------------------------------------------------------------------------
 198 std::string vvReadState::ReadOverlay(int index)
 199 {
 200   std::string file, value;
 201   int vali;
 202   double vald;
 203   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 204   while (!m_XmlReader->isEndElement() || value != "Overlay") {
 205     m_XmlReader->readNext();
 206     value = m_XmlReader->qualifiedName().toString().toStdString();
 207     if (m_XmlReader->isStartElement()) {
 208       if (value == "FileName") {
 209         file = m_XmlReader->readElementText().toStdString();
 210         if (!m_XmlReader->hasError()) {
 211           // TODO: manage sequence of images
 212           std::vector<std::string> vec;
 213           vec.push_back(file.c_str());
 214           m_Window->AddOverlayImage(index, vec, vvImageReader::IMAGE);
 215         }
 216       }
 217       if (value == "OverlayColorWindow") {
 218         vald = m_XmlReader->readElementText().toDouble();
 219         if (!m_XmlReader->hasError())
 220           slicerManager->SetOverlayColorWindow(vald);
 221       }
 222       if (value == "OverlayColorLevel") {
 223         vald = m_XmlReader->readElementText().toDouble();
 224         if (!m_XmlReader->hasError())
 225           slicerManager->SetOverlayColorLevel(vald);
 226       }
 227       if (value == "LinkOverlayWindowLevel") {
 228         vali = m_XmlReader->readElementText().toInt();
 229         if (!m_XmlReader->hasError())
 230           slicerManager->SetLinkOverlayWindowLevel(vali);
 231       }
 232       if (value == "OverlayColor") {
 233         vali = m_XmlReader->readElementText().toInt();
 234         if (!m_XmlReader->hasError())
 235           slicerManager->SetOverlayColor(vali);
 236       }
 237     }
 238   }
 239   m_Window->ImageInfoChanged();
 240   return value;
 241 }
 242 //------------------------------------------------------------------------------
 243
 244
 245 //------------------------------------------------------------------------------
 246 std::string vvReadState::ReadVector(int index)
 247 {
 248   std::string file, value;
 249   while (!m_XmlReader->isEndElement() || value != "Vector") {
 250     m_XmlReader->readNext();
 251     value = m_XmlReader->qualifiedName().toString().toStdString();
 252     if (m_XmlReader->isStartElement()) {
 253       if (value == "FileName") {
 254         file = m_XmlReader->readElementText().toStdString();
 255         if (!m_XmlReader->hasError())
 256           m_Window->AddField(file.c_str(), index);
 257       }
 258     }
 259   }
 260   return value;
 261 }
 262 //------------------------------------------------------------------------------
 263
 264
 265 //------------------------------------------------------------------------------
 266 void vvReadState::ReadGUI()
 267 {
 268
 269 }
 270 //------------------------------------------------------------------------------
 271
 272
 273 //------------------------------------------------------------------------------
 274 void vvReadState::ReadTools()
 275 {
 276   std::string value;
 277
 278   while ((!m_XmlReader->hasError()) && (!m_XmlReader->isEndElement() || value != "Tools")) {
 279     m_XmlReader->readNext();
 280     value = m_XmlReader->qualifiedName().toString().toStdString();
 281     if (value != "Tools") {
 282       if (m_XmlReader->isStartElement()) {
 283         ReadTool(value);
 284       }
 285     }
 286   }
 287
 288   if (m_XmlReader->hasError())
 289     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 290 }
 291 //------------------------------------------------------------------------------
 292
 293
 294 //------------------------------------------------------------------------------
 295 void vvReadState::ReadTool(const std::string & toolname)
 296 {
 297   // Find name into vvToolManager::GetInstance()->GetListOfTools();
 298   vvToolCreatorBase * v = vvToolManager::GetInstance()->GetToolCreatorFromName(toolname.c_str());
 299   if (v == NULL) {
 300     std::cerr << "Error, I do not know the tool named '" << toolname << "' ; ignored." << std::endl;
 301     std::string value="";
 302     while (!m_XmlReader->isEndElement() || value != toolname) {
 303       m_XmlReader->readNext();
 304       value = m_XmlReader->qualifiedName().toString().toStdString();
 305       if (m_XmlReader->hasError()) {
 306         std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 307         return;
 308       }
 309     }
 310     return;
 311   }
 312
 313   // CreateTool
 314   // std::vector<vvToolBaseBase*> & tools = v->GetListOfTool();
 315   v->m_XmlReader = m_XmlReader;
 316   v->mReadStateFlag = true;
 317   v->mImageIndex = m_TreeItemCount;
 318   v->MenuSpecificToolSlot();
 319   v->mReadStateFlag = false;
 320   m_XmlReader = v->m_XmlReader; // Need because auto_ptr operator= release on the right.
 321 }
 322 //------------------------------------------------------------------------------