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         if (value == "Fusion")
 115           value = ReadFusion(current_index);
 116         else if (value == "Overlay")
 117           value = ReadOverlay(current_index);
 118         else if (value == "Vector")
 119           value = ReadVector(current_index);
 120       }
 121     }
 122   }
 123
 124   if (!m_XmlReader->hasError())
 125     m_NumImages++;
 126
 127   return value;
 128 }
 129 //------------------------------------------------------------------------------
 130
 131
 132 //------------------------------------------------------------------------------
 133 std::string vvReadState::ReadFusion(int index)
 134 {
 135   std::string file, value;
 136   int vali;
 137   double vald;
 138   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 139   while (!m_XmlReader->isEndElement() || value != "Fusion") {
 140     m_XmlReader->readNext();
 141     value = m_XmlReader->qualifiedName().toString().toStdString();
 142     if (m_XmlReader->isStartElement()) {
 143       if (value == "FileName") {
 144         file = m_XmlReader->readElementText().toStdString();
 145         if (!m_XmlReader->hasError())
 146           m_Window->AddFusionImage(index, file.c_str());
 147       }
 148       if (value == "FusionOpacity") {
 149         vali = m_XmlReader->readElementText().toInt();
 150         if (!m_XmlReader->hasError())
 151           slicerManager->SetFusionOpacity(vali);
 152       }
 153       if (value == "FusionThresholdOpacity") {
 154         vali = m_XmlReader->readElementText().toInt();
 155         if (!m_XmlReader->hasError())
 156           slicerManager->SetFusionThresholdOpacity(vali);
 157       }
 158       if (value == "FusionColorMap") {
 159         vali = m_XmlReader->readElementText().toInt();
 160         if (!m_XmlReader->hasError())
 161           slicerManager->SetFusionColorMap(vali);
 162       }
 163       if (value == "FusionWindow") {
 164         vald = m_XmlReader->readElementText().toDouble();
 165         if (!m_XmlReader->hasError())
 166           slicerManager->SetFusionWindow(vald);
 167       }
 168       if (value == "FusionLevel") {
 169         vald = m_XmlReader->readElementText().toDouble();
 170         if (!m_XmlReader->hasError())
 171           slicerManager->SetFusionLevel(vald);
 172       }
 173     }
 174   }
 175   m_Window->ImageInfoChanged();
 176   return value;
 177 }
 178 //------------------------------------------------------------------------------
 179
 180
 181 //------------------------------------------------------------------------------
 182 std::string vvReadState::ReadOverlay(int index)
 183 {
 184   std::string file, value;
 185   int vali;
 186   double vald;
 187   vvSlicerManager* slicerManager = m_Window->GetSlicerManagers()[index];
 188   while (!m_XmlReader->isEndElement() || value != "Overlay") {
 189     m_XmlReader->readNext();
 190     value = m_XmlReader->qualifiedName().toString().toStdString();
 191     if (m_XmlReader->isStartElement()) {
 192       if (value == "FileName") {
 193         file = m_XmlReader->readElementText().toStdString();
 194         if (!m_XmlReader->hasError())
 195           m_Window->AddOverlayImage(index, file.c_str());
 196       }
 197       if (value == "OverlayColorWindow") {
 198         vald = m_XmlReader->readElementText().toDouble();
 199         if (!m_XmlReader->hasError())
 200           slicerManager->SetOverlayColorWindow(vald);
 201       }
 202       if (value == "OverlayColorLevel") {
 203         vald = m_XmlReader->readElementText().toDouble();
 204         if (!m_XmlReader->hasError())
 205           slicerManager->SetOverlayColorLevel(vald);
 206       }
 207       if (value == "LinkOverlayWindowLevel") {
 208         vali = m_XmlReader->readElementText().toInt();
 209         if (!m_XmlReader->hasError())
 210           slicerManager->SetLinkOverlayWindowLevel(vali);
 211       }
 212       if (value == "OverlayColor") {
 213         vali = m_XmlReader->readElementText().toInt();
 214         if (!m_XmlReader->hasError())
 215           slicerManager->SetOverlayColor(vali);
 216       }
 217     }
 218   }
 219   m_Window->ImageInfoChanged();
 220   return value;
 221 }
 222 //------------------------------------------------------------------------------
 223
 224
 225 //------------------------------------------------------------------------------
 226 std::string vvReadState::ReadVector(int index)
 227 {
 228   std::string file, value;
 229   while (!m_XmlReader->isEndElement() || value != "Vector") {
 230     m_XmlReader->readNext();
 231     value = m_XmlReader->qualifiedName().toString().toStdString();
 232     if (m_XmlReader->isStartElement()) {
 233       if (value == "FileName") {
 234         file = m_XmlReader->readElementText().toStdString();
 235         if (!m_XmlReader->hasError())
 236           m_Window->AddField(file.c_str(), index);
 237       }
 238     }
 239   }
 240   return value;
 241 }
 242 //------------------------------------------------------------------------------
 243
 244
 245 //------------------------------------------------------------------------------
 246 void vvReadState::ReadGUI()
 247 {
 248
 249 }
 250 //------------------------------------------------------------------------------
 251
 252
 253 //------------------------------------------------------------------------------
 254 void vvReadState::ReadTools()
 255 {
 256   std::string value;
 257
 258   while ((!m_XmlReader->hasError()) && (!m_XmlReader->isEndElement() || value != "Tools")) {
 259     m_XmlReader->readNext();
 260     value = m_XmlReader->qualifiedName().toString().toStdString();
 261     if (value != "Tools") {
 262       if (m_XmlReader->isStartElement()) {
 263         ReadTool(value);
 264       }
 265     }
 266   }
 267
 268   if (m_XmlReader->hasError())
 269     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 270 }
 271 //------------------------------------------------------------------------------
 272
 273
 274 //------------------------------------------------------------------------------
 275 void vvReadState::ReadTool(const std::string & toolname)
 276 {
 277   // Find name into vvToolManager::GetInstance()->GetListOfTools();
 278   vvToolCreatorBase * v = vvToolManager::GetInstance()->GetToolCreatorFromName(toolname.c_str());
 279   if (v == NULL) {
 280     std::cerr << "Error, I do not know the tool named '" << toolname << "' ; ignored." << std::endl;
 281     std::string value="";
 282     while (!m_XmlReader->isEndElement() || value != toolname) {
 283       m_XmlReader->readNext();
 284       value = m_XmlReader->qualifiedName().toString().toStdString();
 285       if (m_XmlReader->hasError()) {
 286         std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 287         return;
 288       }
 289     }
 290     return;
 291   }
 292
 293   // CreateTool
 294   // std::vector<vvToolBaseBase*> & tools = v->GetListOfTool();
 295   v->m_XmlReader = m_XmlReader;
 296   v->mReadStateFlag = true;
 297   v->mImageIndex = m_TreeItemCount;
 298   v->MenuSpecificToolSlot();
 299   v->mReadStateFlag = false;
 300   m_XmlReader = v->m_XmlReader; // Need because auto_ptr operator= release on the right.
 301 }
 302 //------------------------------------------------------------------------------