Fraxinus  17.12-rc4
An IGT application
cxDataManagerImpl.cpp
Go to the documentation of this file.
1 /*=========================================================================
2 This file is part of CustusX, an Image Guided Therapy Application.
3 
4 Copyright (c) 2008-2014, SINTEF Department of Medical Technology
5 All rights reserved.
6 
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
9 
10 1. Redistributions of source code must retain the above copyright notice,
11  this list of conditions and the following disclaimer.
12 
13 2. Redistributions in binary form must reproduce the above copyright notice,
14  this list of conditions and the following disclaimer in the documentation
15  and/or other materials provided with the distribution.
16 
17 3. Neither the name of the copyright holder nor the names of its contributors
18  may be used to endorse or promote products derived from this software
19  without specific prior written permission.
20 
21 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
25 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 =========================================================================*/
32 
33 
34 #include "cxDataManagerImpl.h"
35 
36 #include <QtCore>
37 #include <QDomDocument>
38 #include <QFileInfo>
39 #include <QFile>
40 #include <QTextStream>
41 #include <QDir>
42 
43 #include "cxTransform3D.h"
45 #include "cxLogger.h"
46 #include "cxTypeConversions.h"
47 #include "cxUtilHelpers.h"
48 #include "cxVideoSource.h"
49 #include "cxDataLocations.h"
50 
51 #include "cxImageLUT2D.h"
52 #include "cxImageTF3D.h"
53 
54 #include "cxDataReaderWriter.h"
55 #include "cxSpaceProvider.h"
56 #include "cxDataFactory.h"
57 
58 #include "cxXmlOptionItem.h"
60 #include "cxProfile.h"
61 #include "cxSettings.h"
62 #include "cxDefinitionStrings.h"
63 #include "cxActiveData.h"
64 
65 
66 namespace cx
67 {
68 
70 {
71  DataManagerImplPtr retval;
72  retval.reset(new DataManagerImpl(activeData));
73  return retval;
74 }
75 
78  mActiveData(activeData)
79 {
83 
84  connect(settings(), SIGNAL(valueChangedFor(QString)), this, SLOT(settingsChangedSlot(QString)));
85  this->readClinicalView();
86 
87  this->clear();
88 }
89 
91 {
92 }
93 
95 {
96  mSpaceProvider = spaceProvider;
97 }
98 
100 {
101  mDataFactory = dataFactory;
102 }
103 
105 {
106  return mSpaceProvider;
107 }
108 
110 {
111  return mDataFactory;
112 }
113 
115 {
116  mData.clear();
117  mCenter = Vector3D(0, 0, 0);
118  mLandmarkProperties.clear();
119 
120  m_rMpr_History->clear();
121  mPatientLandmarks->clear();
122 
123  emit dataAddedOrRemoved();
124  emit centerChanged();
126 }
127 
129 {
130  return mPatientLandmarks;
131 }
132 
133 // streams
135 {
136  if (mStreams.count(uid))
137  return mStreams.find(uid)->second;
138  return VideoSourcePtr();
139 }
140 
142 {
143  return mStreams;
144 }
145 
147 {
148  if (!stream)
149  return;
150  mStreams[stream->getUid()] = stream;
151  emit streamLoaded();
152 }
153 
154 std::map<QString, VideoSourcePtr> mStreams;
155 
157 {
158  return mCenter;
159 }
161 {
162  if (similar(mCenter, center))
163  return;
164  mCenter = center;
165  emit centerChanged();
166 }
167 
169 {
170  mOperatingTable = ot;
171  emit operatingTableChanged();
172 }
173 
175 {
176  return mOperatingTable;
177 }
178 
179 
180 void DataManagerImpl::setLandmarkNames(std::vector<QString> names)
181 {
182  mLandmarkProperties.clear();
183  for (unsigned i = 0; i < names.size(); ++i)
184  {
185  LandmarkProperty prop(qstring_cast(i + 1), names[i]); // generate 1-indexed uids (keep users happy)
186  mLandmarkProperties[prop.getUid()] = prop;
187  }
189 }
190 
192 {
193  int max = 0;
194  std::map<QString, LandmarkProperty>::iterator iter;
195  for (iter = mLandmarkProperties.begin(); iter != mLandmarkProperties.end(); ++iter)
196  {
197  //max = std::max(max, qstring_cast(iter->second.getName()).toInt());
198  max = std::max(max, qstring_cast(iter->first).toInt());
199  }
200  QString uid = qstring_cast(max + 1);
202 
204  return uid;
205 }
206 
208 {
209  mLandmarkProperties.clear();
211 }
212 
213 void DataManagerImpl::setLandmarkName(QString uid, QString name)
214 {
215  mLandmarkProperties[uid].setName(name);
217 }
218 
219 std::map<QString, LandmarkProperty> DataManagerImpl::getLandmarkProperties() const
220 {
221  return mLandmarkProperties;
222 }
223 
224 void DataManagerImpl::setLandmarkActive(QString uid, bool active)
225 {
226  mLandmarkProperties[uid].setActive(active);
228 }
229 
230 DataPtr DataManagerImpl::loadData(const QString& uid, const QString& path)
231 {
232  if (mData.count(uid)) // dont load same image twice
233  return mData[uid];
234 
235  QString type = DataReaderWriter().findDataTypeFromFile(path);
236  if(!mDataFactory)
237  reportError("DataManagerImpl::loadData() Got no DataFactory");
238  DataPtr data = mDataFactory->create(type, uid);
239 
240  if (!data)
241  {
242  reportError("Failed to find loaded for: [" + path + "]");
243  return DataPtr();
244  }
245 
246  bool loaded = data->load(path);
247 
248  if (!loaded)
249  {
250  reportError("Failed to load file: [" + path + "]");
251  return DataPtr();
252  }
253 
254  this->loadData(data);
255  return data;
256 }
257 
259 {
260  if (data->getUid().contains('%'))
261  {
262  QString uid = data->getUid();
263  QString name = data->getName();
264  this->generateUidAndName(&uid, &name);
265  data->setName(name);
266  data->setUid(uid);
267  }
268 
269  if (data)
270  {
271  if (mData.count(data->getUid()) && mData[data->getUid()]!=data)
272  reportError(QString("Overwriting Data with uid=%1 with new object into PasM").arg(data->getUid()));
273 // this->verifyParentFrame(data);
274  mData[data->getUid()] = data;
275  emit dataAddedOrRemoved();
276  }
277 }
278 
279 DataPtr DataManagerImpl::getData(const QString& uid) const
280 {
281  DataMap::const_iterator iter = mData.find(uid);
282  if (iter == mData.end())
283  return DataPtr();
284  return iter->second;
285 }
286 
287 std::map<QString, DataPtr> DataManagerImpl::getData() const
288 {
289  return mData;
290 }
291 
292 std::map<QString, ImagePtr> DataManagerImpl::getImages() const
293 {
294  std::map<QString, ImagePtr> retval;
295  for (DataMap::const_iterator iter = mData.begin(); iter != mData.end(); ++iter)
296  {
297  ImagePtr image = this->getImage(iter->first);
298  if (!image)
299  continue;
300  retval[iter->first] = image;
301  }
302  return retval;
303 }
304 
305 std::map<QString, MeshPtr> DataManagerImpl::getMeshes() const
306 {
307  std::map<QString, MeshPtr> retval;
308  for (DataMap::const_iterator iter = mData.begin(); iter != mData.end(); ++iter)
309  {
310  MeshPtr mesh = this->getMesh(iter->first);
311  if (!mesh)
312  continue;
313  retval[iter->first] = mesh;
314  }
315  return retval;
316 }
317 
318 void DataManagerImpl::addXml(QDomNode& parentNode)
319 {
320  QDomDocument doc = parentNode.ownerDocument();
321  QDomElement dataManagerNode = doc.createElement("datamanager");
322  parentNode.appendChild(dataManagerNode);
323 
324  m_rMpr_History->addXml(dataManagerNode);
325 
326  QDomElement landmarkPropsNode = doc.createElement("landmarkprops");
327  LandmarkPropertyMap::iterator it = mLandmarkProperties.begin();
328  for (; it != mLandmarkProperties.end(); ++it)
329  {
330  QDomElement landmarkPropNode = doc.createElement("landmarkprop");
331  it->second.addXml(landmarkPropNode);
332  landmarkPropsNode.appendChild(landmarkPropNode);
333  }
334  dataManagerNode.appendChild(landmarkPropsNode);
335 
336  QDomElement landmarksNode = doc.createElement("landmarks");
337  mPatientLandmarks->addXml(landmarksNode);
338  dataManagerNode.appendChild(landmarksNode);
339 
340  QDomElement centerNode = doc.createElement("center");
341  centerNode.appendChild(doc.createTextNode(qstring_cast(mCenter)));
342  dataManagerNode.appendChild(centerNode);
343 
344  QDomElement otNode = doc.createElement("operatingTable");
345  otNode.appendChild(doc.createTextNode(qstring_cast(mOperatingTable.rMot)));
346  dataManagerNode.appendChild(otNode);
347 
348  for (DataMap::const_iterator iter = mData.begin(); iter != mData.end(); ++iter)
349  {
350  QDomElement dataNode = doc.createElement("data");
351  dataManagerNode.appendChild(dataNode);
352  iter->second->addXml(dataNode);
353  }
354 }
355 
356 void DataManagerImpl::parseXml(QDomNode& dataManagerNode, QString rootPath)
357 {
358  // look in the toolmanager, for backwards compatibility (2014-02-21)
359  QDomNode toolManagerNode = dataManagerNode.parentNode().namedItem("toolManager");
360 
361  QDomNode registrationHistory = dataManagerNode.namedItem("registrationHistory");
362  if (registrationHistory.isNull())
363  registrationHistory = toolManagerNode.namedItem("registrationHistory");
364  m_rMpr_History->parseXml(registrationHistory);
365 
366  QDomNode landmarksNode = dataManagerNode.namedItem("landmarkprops");
367  QDomElement landmarkNode = landmarksNode.firstChildElement("landmarkprop");
368  for (; !landmarkNode.isNull(); landmarkNode = landmarkNode.nextSiblingElement("landmarkprop"))
369  {
370  LandmarkProperty landmarkProp;
371  landmarkProp.parseXml(landmarkNode);
372  mLandmarkProperties[landmarkProp.getUid()] = landmarkProp;
373  //std::cout << "Loaded landmarkprop with name: " << landmarkProp.getName() << std::endl;
375  }
376 
377  QDomNode patientLandmarksNode = dataManagerNode.namedItem("landmarks");
378  if (patientLandmarksNode.isNull())
379  patientLandmarksNode = toolManagerNode.namedItem("landmarks");
380  mPatientLandmarks->parseXml(patientLandmarksNode);
381 
382  // All images must be created from the DataManager, so the image nodes are parsed here
383  std::map<DataPtr, QDomNode> datanodes;
384 
385  QDomNode child = dataManagerNode.firstChild();
386  for (; !child.isNull(); child = child.nextSibling())
387  {
388  if (child.nodeName() == "data")
389  {
390  DataPtr data = this->loadData(child.toElement(), rootPath);
391  if (data)
392  datanodes[data] = child.toElement();
393  }
394  }
395 
396  // parse xml data separately: we want to first load all data
397  // because there might be interdependencies (cx::DistanceMetric)
398  for (std::map<DataPtr, QDomNode>::iterator iter = datanodes.begin(); iter != datanodes.end(); ++iter)
399  {
400  iter->first->parseXml(iter->second);
401  }
402 
403  emit dataAddedOrRemoved();
404 
405  //we need to make sure all images are loaded before we try to set an active image
406  child = dataManagerNode.firstChild();
407  while (!child.isNull())
408  {
409  if (child.toElement().tagName() == "center")
410  {
411  const QString centerString = child.toElement().text();
412  if (!centerString.isEmpty())
413  {
414  Vector3D center = Vector3D::fromString(centerString);
415  this->setCenter(center);
416  }
417  }
418  if (child.toElement().tagName() == "operatingTable")
419  {
420  const QString ot = child.toElement().text();
421  if (!ot.isEmpty())
422  {
423  Transform3D tr = Transform3D::fromString(ot);
424  OperatingTable t(tr);
425  this->setOperatingTable(t);
426  }
427  }
428  child = child.nextSibling();
429  }
430 }
431 
432 DataPtr DataManagerImpl::loadData(QDomElement node, QString rootPath)
433 {
434  QString uid = node.toElement().attribute("uid");
435  QString name = node.toElement().attribute("name");
436  QString type = node.toElement().attribute("type");
437 
438  QDir relativePath = this->findRelativePath(node, rootPath);
439  QString absolutePath = this->findAbsolutePath(relativePath, rootPath);
440 
441  if (mData.count(uid)) // dont load same image twice
442  return mData[uid];
443 
444  DataPtr data = mDataFactory->create(type, uid, name);
445  if (!data)
446  {
447  reportWarning(QString("Unknown type: %1 for file %2").arg(type).arg(absolutePath));
448  return DataPtr();
449  }
450  bool loaded = data->load(absolutePath);
451 
452  if (!loaded)
453  {
454  reportWarning("Unknown file: " + absolutePath);
455  return DataPtr();
456  }
457 
458  if (!name.isEmpty())
459  data->setName(name);
460  data->setFilename(relativePath.path());
461 
462  this->loadData(data);
463 
464  // conversion for change in format 2013-10-29
465  QString newPath = rootPath+"/"+data->getFilename();
466  if (QDir::cleanPath(absolutePath) != QDir::cleanPath(newPath))
467  {
468  reportWarning(QString("Detected old data format, converting from %1 to %2").arg(absolutePath).arg(newPath));
469  data->save(rootPath);
470  }
471 
472  return data;
473 }
474 
475 QDir DataManagerImpl::findRelativePath(QDomElement node, QString rootPath)
476 {
477  QString path = this->findPath(node);
478  QDir relativePath = QDir(QString(path));
479 
480  QDir patientDataDir(rootPath);
481  relativePath.setPath(patientDataDir.relativeFilePath(relativePath.path()));
482 
483  return relativePath;
484 }
485 
486 QString DataManagerImpl::findPath(QDomElement node)
487 {
488  QDomElement filePathNode = node.namedItem("filePath").toElement();
489 
490  if (filePathNode.isNull())
491  return QString();
492 
493  QString path = filePathNode.text();
494  if (path.isEmpty())
495  return QString();
496  return path;
497 }
498 
499 QString DataManagerImpl::findAbsolutePath(QDir relativePath, QString rootPath)
500 {
501  QString absolutePath = relativePath.path();
502  if (!rootPath.isEmpty())
503  absolutePath = rootPath + "/" + relativePath.path();
504  return absolutePath;
505 }
506 
508 {
509  return mClinicalApplication;
510 }
511 
512 void DataManagerImpl::setClinicalApplication(CLINICAL_VIEW application)
513 {
514  if (mClinicalApplication == application)
515  return;
516  mClinicalApplication = application;
517 
518  QString val = enum2string<CLINICAL_VIEW>(mClinicalApplication);
519  settings()->setValue("View/clinicalView", val);
520 
522 }
523 
524 void DataManagerImpl::settingsChangedSlot(QString key)
525 {
526  if (key == "View/clinicalView")
527  {
528  this->readClinicalView();
529  }
530 }
531 
533 {
534  QString defVal = enum2string<CLINICAL_VIEW>(mdNEUROLOGICAL);
535  QString val = settings()->value("View/clinicalView", defVal).toString();
536  CLINICAL_VIEW view = string2enum<CLINICAL_VIEW>(val);
537 
538  this->setClinicalApplication(view);
539 }
540 
541 
542 int DataManagerImpl::findUniqueUidNumber(QString uidBase) const
543 {
544  if (!uidBase.contains("%"))
545  return -1;
546  // Find an uid that is not used before
547  size_t numMatches = 1;
548  int recNumber = 0;
549 
550  if (numMatches != 0)
551  {
552  while (numMatches != 0)
553  {
554  QString newId = qstring_cast(uidBase).arg(++recNumber);
555  numMatches = mData.count(qstring_cast(newId));
556  }
557  }
558  return recNumber;
559 }
560 
565 void DataManagerImpl::generateUidAndName(QString* _uid, QString* _name)
566 {
567  QString& uid = *_uid;
568  QString& name = *_name;
569 
570  int recNumber = this->findUniqueUidNumber(uid);
571 
572  if (uid.contains("%"))
573  {
574  uid = uid.arg(recNumber);
575  }
576 
577  if (name.contains("%"))
578  {
579  if (recNumber == 1)
580  name = name.arg("");
581  else
582  name = name.arg(recNumber);
583  }
584 }
585 
586 void DataManagerImpl::removeData(const QString& uid, QString basePath)
587 {
588  DataPtr dataToBeRemoved = this->getData(uid);
589  mActiveData->remove(dataToBeRemoved);
590 
591  mData.erase(uid);
592 
593  this->deleteFiles(dataToBeRemoved, basePath);
594 
595  emit dataAddedOrRemoved(); // this should alert everybody interested in the data as a collection.
596  report("Removed data [" + uid + "].");
597 }
598 
599 void DataManagerImpl::deleteFiles(DataPtr data, QString basePath)
600 {
601  if (!data)
602  return;
603  ImagePtr image = boost::dynamic_pointer_cast<Image>(data);
604  QStringList files;
605  if (!data->getFilename().isEmpty())
606  {
607  files << QDir(basePath).absoluteFilePath(data->getFilename());
608  if (image)
609  files << changeExtension(files[0], "raw");
610  }
611 
612  for (int i=0; i<files.size(); ++i)
613  {
614  if (!QFileInfo(files[i]).exists())
615  continue;
616  report(QString("Removing %1 from disk").arg(files[i]));
617  QFile(files[i]).remove();
618  }
619 }
620 
622 {
623  return m_rMpr_History->getCurrentRegistration().mValue;
624 }
625 
627 {
628  m_rMpr_History->setRegistration(val);
629 }
630 
632 {
633  return m_rMpr_History;
634 }
635 
637 {
639  XmlOptionFile preset(DataLocations::findConfigFilePath("presets.xml", "/transferFunctions"));
640  XmlOptionFile custom = profile()->getXmlSettings().descend("presetTransferFunctions");
641 
643  mPresetTransferFunctions3D.reset(new TransferFunctions3DPresets(preset, custom));
644 
646 }
647 
648 } // namespace cx
649 
boost::shared_ptr< class SpaceProvider > SpaceProviderPtr
QString qstring_cast(const T &val)
DataFactoryPtr mDataFactory
cxResource_EXPORT ProfilePtr profile()
Definition: cxProfile.cpp:181
void rMprChanged()
emitted when the transformation between patient reference and (data) reference is set ...
int findUniqueUidNumber(QString uidBase) const
virtual void removeData(const QString &uid, QString basePath)
remove data from datamanger, emit signal
void reportError(QString msg)
Definition: cxLogger.cpp:92
virtual CLINICAL_VIEW getClinicalApplication() const
boost::shared_ptr< class RegistrationHistory > RegistrationHistoryPtr
Definition: cxDataManager.h:58
std::map< QString, VideoSourcePtr > mStreams
QString findDataTypeFromFile(QString filename)
void operatingTableChanged()
OperatingTable getOperatingTable() const
Transform3D Transform3D
Transform3D is a representation of an affine 3D transform.
OperatingTable mOperatingTable
virtual std::map< QString, LandmarkProperty > getLandmarkProperties() const
boost::shared_ptr< class TransferFunctions3DPresets > PresetTransferFunctions3DPtr
Definition: cxDataManager.h:57
virtual void setLandmarkName(QString uid, QString name)
QString getUid() const
Definition: cxLandmark.cpp:195
boost::shared_ptr< class Image > ImagePtr
Definition: cxDicomWidget.h:48
virtual VideoSourcePtr getStream(const QString &uid) const
boost::shared_ptr< class DataManagerImpl > DataManagerImplPtr
void deleteFiles(DataPtr data, QString basePath)
virtual void generateUidAndName(QString *_uid, QString *_name)
virtual MeshPtr getMesh(const QString &uid) const
boost::shared_ptr< class ActiveData > ActiveDataPtr
Definition: cxColorWidget.h:42
void landmarkPropertiesChanged()
emitted when global info about a landmark changed
QVariant value(const QString &key, const QVariant &defaultValue=QVariant()) const
Definition: cxSettings.cpp:87
void centerChanged()
emitted when center is changed.
ActiveDataPtr mActiveData
virtual LandmarksPtr getPatientLandmarks()
virtual void addXml(QDomNode &parentNode)
adds xml information about the datamanger and its variabels
boost::shared_ptr< class Landmarks > LandmarksPtr
Definition: cxData.h:61
PresetTransferFunctions3DPtr mPresetTransferFunctions3D
void setValue(const QString &key, const QVariant &value)
Definition: cxSettings.cpp:79
boost::shared_ptr< class Data > DataPtr
DataManagerImpl(ActiveDataPtr activeData)
virtual void parseXml(QDomNode &datamangerNode, QString absolutePath=QString())
Use a XML node to load data.
virtual StreamMap getStreams() const
static DataManagerImplPtr create(ActiveDataPtr activeData)
virtual std::map< QString, ImagePtr > getImages() const
virtual void setLandmarkNames(std::vector< QString > names)
void reportWarning(QString msg)
Definition: cxLogger.cpp:91
virtual void setClinicalApplication(CLINICAL_VIEW application)
std::map< QString, DataPtr > getData() const
void dataAddedOrRemoved()
A volumetric data set.
Definition: cxImage.h:66
void parseXml(QDomNode &dataNode)
Definition: cxLandmark.cpp:216
virtual PresetTransferFunctions3DPtr getPresetTransferFunctions3D() const
boost::shared_ptr< class VideoSource > VideoSourcePtr
virtual Transform3D get_rMpr() const
get the patient registration transform
Read or write vtk or ssc data objects from/to file.
static QString findConfigFilePath(QString fileName, QString pathRelativeToConfigRoot, QString alternativeAbsolutePath="")
RegistrationHistoryPtr m_rMpr_History
transform from the patient reference to the reference, along with historical data.
Settings * settings()
Shortcut for accessing the settings instance.
Definition: cxSettings.cpp:42
virtual void setLandmarkActive(QString uid, bool active)
static LandmarksPtr create()
Definition: cxLandmark.cpp:116
Transform3D rMot
Transform from OT to reference space.
void setOperatingTable(const OperatingTable &ot)
virtual void deleteLandmarks()
LandmarksPtr mPatientLandmarks
in space patient reference.
virtual Vector3D getCenter() const
current common center point for user viewing.
Eigen::Vector3d Vector3D
Vector3D is a representation of a point or vector in 3D.
Definition: cxVector3D.h:63
virtual void setCenter(const Vector3D &center)
virtual ImagePtr getImage(const QString &uid) const
QString changeExtension(QString name, QString ext)
void report(QString msg)
Definition: cxLogger.cpp:90
bool similar(const CameraInfo &lhs, const CameraInfo &rhs, double tol)
void setDataFactory(DataFactoryPtr dataFactory)
mdNEUROLOGICAL
Definition: cxDefinitions.h:76
virtual SpaceProviderPtr getSpaceProvider()
virtual void set_rMpr(const Transform3D &val)
set the transform from patient to reference space
virtual std::map< QString, MeshPtr > getMeshes() const
virtual QString addLandmark()
CLINICAL_VIEW mClinicalApplication
The OperatingTable class.
LandmarkPropertyMap mLandmarkProperties
uid and name
SpaceProviderPtr mSpaceProvider
boost::shared_ptr< class DataFactory > DataFactoryPtr
Definition: cxDataManager.h:60
boost::shared_ptr< class Mesh > MeshPtr
void loadData(DataPtr data)
void clinicalApplicationChanged()
virtual void loadStream(VideoSourcePtr stream)
A history of registration events.
void setSpaceProvider(SpaceProviderPtr spaceProvider)
Helper class for xml files used to store ssc/cx data.
Handles transfer function presets.
virtual void clear()
remove all stuff from manager
virtual DataFactoryPtr getDataFactory()
virtual RegistrationHistoryPtr get_rMpr_History() const
Namespace for all CustusX production code.
std::map< QString, VideoSourcePtr > StreamMap
Definition: cxDataManager.h:76