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           // TODO: manage sequence of images
 196           std::vector<std::string> vec;
 197           vec.push_back(file.c_str());
 198           m_Window->AddOverlayImage(index, vec, vvImageReader::IMAGE);
 199         }
 200       }
 201       if (value == "OverlayColorWindow") {
 202         vald = m_XmlReader->readElementText().toDouble();
 203         if (!m_XmlReader->hasError())
 204           slicerManager->SetOverlayColorWindow(vald);
 205       }
 206       if (value == "OverlayColorLevel") {
 207         vald = m_XmlReader->readElementText().toDouble();
 208         if (!m_XmlReader->hasError())
 209           slicerManager->SetOverlayColorLevel(vald);
 210       }
 211       if (value == "LinkOverlayWindowLevel") {
 212         vali = m_XmlReader->readElementText().toInt();
 213         if (!m_XmlReader->hasError())
 214           slicerManager->SetLinkOverlayWindowLevel(vali);
 215       }
 216       if (value == "OverlayColor") {
 217         vali = m_XmlReader->readElementText().toInt();
 218         if (!m_XmlReader->hasError())
 219           slicerManager->SetOverlayColor(vali);
 220       }
 221     }
 222   }
 223   m_Window->ImageInfoChanged();
 224   return value;
 225 }
 226 //------------------------------------------------------------------------------
 227
 228
 229 //------------------------------------------------------------------------------
 230 std::string vvReadState::ReadVector(int index)
 231 {
 232   std::string file, value;
 233   while (!m_XmlReader->isEndElement() || value != "Vector") {
 234     m_XmlReader->readNext();
 235     value = m_XmlReader->qualifiedName().toString().toStdString();
 236     if (m_XmlReader->isStartElement()) {
 237       if (value == "FileName") {
 238         file = m_XmlReader->readElementText().toStdString();
 239         if (!m_XmlReader->hasError())
 240           m_Window->AddField(file.c_str(), index);
 241       }
 242     }
 243   }
 244   return value;
 245 }
 246 //------------------------------------------------------------------------------
 247
 248
 249 //------------------------------------------------------------------------------
 250 void vvReadState::ReadGUI()
 251 {
 252
 253 }
 254 //------------------------------------------------------------------------------
 255
 256
 257 //------------------------------------------------------------------------------
 258 void vvReadState::ReadTools()
 259 {
 260   std::string value;
 261
 262   while ((!m_XmlReader->hasError()) && (!m_XmlReader->isEndElement() || value != "Tools")) {
 263     m_XmlReader->readNext();
 264     value = m_XmlReader->qualifiedName().toString().toStdString();
 265     if (value != "Tools") {
 266       if (m_XmlReader->isStartElement()) {
 267         ReadTool(value);
 268       }
 269     }
 270   }
 271
 272   if (m_XmlReader->hasError())
 273     std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 274 }
 275 //------------------------------------------------------------------------------
 276
 277
 278 //------------------------------------------------------------------------------
 279 void vvReadState::ReadTool(const std::string & toolname)
 280 {
 281   // Find name into vvToolManager::GetInstance()->GetListOfTools();
 282   vvToolCreatorBase * v = vvToolManager::GetInstance()->GetToolCreatorFromName(toolname.c_str());
 283   if (v == NULL) {
 284     std::cerr << "Error, I do not know the tool named '" << toolname << "' ; ignored." << std::endl;
 285     std::string value="";
 286     while (!m_XmlReader->isEndElement() || value != toolname) {
 287       m_XmlReader->readNext();
 288       value = m_XmlReader->qualifiedName().toString().toStdString();
 289       if (m_XmlReader->hasError()) {
 290         std::cout << "Error " << m_XmlReader->error() << " XML " << std::endl;
 291         return;
 292       }
 293     }
 294     return;
 295   }
 296
 297   // CreateTool
 298   // std::vector<vvToolBaseBase*> & tools = v->GetListOfTool();
 299   v->m_XmlReader = m_XmlReader;
 300   v->mReadStateFlag = true;
 301   v->mImageIndex = m_TreeItemCount;
 302   v->MenuSpecificToolSlot();
 303   v->mReadStateFlag = false;
 304   m_XmlReader = v->m_XmlReader; // Need because auto_ptr operator= release on the right.
 305 }
 306 //------------------------------------------------------------------------------