CustusX  2021.09.21-dev+develop.e3cd0
An IGT application
cxViewGroupData.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) SINTEF Department of Medical Technology.
5 All rights reserved.
6 
7 CustusX is released under a BSD 3-Clause license.
8 
9 See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
10 =========================================================================*/
11 
12 #include "cxViewGroupData.h"
13 
14 #include <QMenu>
15 #include "vtkCamera.h"
16 
17 #include "cxPatientModelService.h"
18 #include "cxMesh.h"
19 #include "cxTypeConversions.h"
20 #include "cxCameraControl.h"
21 #include "cxImageAlgorithms.h"
22 #include "cxDataMetric.h"
23 #include "cxView.h"
24 #include "cxImage.h"
25 #include "cxTrackedStream.h"
26 #include "cxInteractiveClipper.h"
27 #include "boost/bind.hpp"
28 #include "cxXMLNodeWrapper.h"
29 #include "cxSyncedValue.h"
30 #include "cxCoreServices.h"
31 #include "cxLogger.h"
32 #include "cxStringListProperty.h"
33 #include "cxSharedOpenGLContext.h"
34 
35 namespace cx
36 {
37 
39 {
40  this->clear();
41 }
42 
43 CameraStyleData::CameraStyleData(CAMERA_STYLE_TYPE style)
44 {
45  this->setCameraStyle(style);
46 }
47 
48 void CameraStyleData::setCameraStyle(CAMERA_STYLE_TYPE style)
49 {
50  this->clear();
51 
52  if (style==cstDEFAULT_STYLE)
53  {
54  }
55  if (style==cstTOOL_STYLE)
56  {
57  mCameraFollowTool = true;
58  mFocusFollowTool = true;
59  }
60  if (style==cstANGLED_TOOL_STYLE)
61  {
62  mCameraFollowTool = true;
63  mFocusFollowTool = true;
64  mElevation = 20.0/180.0*M_PI;
65  }
66  if (style==cstUNICAM_STYLE)
67  {
68  mUniCam = true;
69  }
70 }
71 
72 CAMERA_STYLE_TYPE CameraStyleData::getStyle()
73 {
74  for (unsigned int i=0; i<cstCOUNT; ++i)
75  {
76  CAMERA_STYLE_TYPE current = static_cast<CAMERA_STYLE_TYPE>(i);
77  if (CameraStyleData(current)==*this)
78  return current;
79  }
80  return cstCOUNT;
81 }
82 
83 
85 {
86  mCameraViewAngle = 30.0/180*M_PI;
87  mCameraFollowTool = false;
88  mFocusFollowTool = false;
89  mCameraLockToTooltip = false;
92  mTableLock = false;
93  mElevation = 0;
94  mUniCam = false;
95  mAutoZoomROI = "";
96  mFocusROI = "";
97 }
98 
99 void CameraStyleData::addXml(QDomNode &dataNode)
100 {
101  QDomElement elem = dataNode.toElement();
102  elem.setAttribute("cameraViewAngle", mCameraViewAngle);
103  elem.setAttribute("cameraFollowTool", mCameraFollowTool);
104  elem.setAttribute("focusFollowTool", mFocusFollowTool);
105  elem.setAttribute("cameraOnTooltip", mCameraLockToTooltip);
106  elem.setAttribute("cameraTooltipOffset", mCameraTooltipOffset);
107  elem.setAttribute("cameraNotBehindROI", mCameraNotBehindROI);
108  elem.setAttribute("tableLock", mTableLock);
109  elem.setAttribute("elevation", mElevation);
110  elem.setAttribute("uniCam", mUniCam);
111  elem.setAttribute("autoZoomROI", mAutoZoomROI);
112  elem.setAttribute("focusROI", mFocusROI);
113 }
114 
115 void CameraStyleData::parseXml(QDomNode dataNode)
116 {
117  QDomElement elem = dataNode.toElement();
118  mCameraViewAngle = elem.attribute("cameraViewAngle", QString::number(mCameraViewAngle)).toDouble();
119  mCameraFollowTool = elem.attribute("cameraFollowTool", QString::number(mCameraFollowTool)).toInt();
120  mFocusFollowTool = elem.attribute("focusFollowTool", QString::number(mFocusFollowTool)).toInt();
121  mCameraLockToTooltip = elem.attribute("cameraOnTooltip", QString::number(mCameraLockToTooltip)).toInt();
122  mCameraTooltipOffset = elem.attribute("cameraTooltipOffset", QString::number(mCameraTooltipOffset)).toDouble();
123  mCameraNotBehindROI = elem.attribute("cameraNotBehindROI", mCameraNotBehindROI);
124  mTableLock = elem.attribute("tableLock", QString::number(mTableLock)).toInt();
125  mElevation = elem.attribute("elevation", QString::number(mElevation)).toDouble();
126  mUniCam = elem.attribute("uniCam", QString::number(mUniCam)).toInt();
127  mAutoZoomROI = elem.attribute("autoZoomROI", mAutoZoomROI);
128  mFocusROI = elem.attribute("focusROI", mFocusROI);
129 }
130 
131 bool operator==(const CameraStyleData& lhs, const CameraStyleData& rhs)
132 {
133  return ((lhs.mCameraViewAngle==rhs.mCameraViewAngle) &&
135  (lhs.mFocusFollowTool==rhs.mFocusFollowTool) &&
139  (lhs.mTableLock==rhs.mTableLock) &&
140  similar(lhs.mElevation, rhs.mElevation) &&
141  (lhs.mUniCam==rhs.mUniCam) &&
142  (lhs.mAutoZoomROI==rhs.mAutoZoomROI) &&
143  (lhs.mFocusROI==rhs.mFocusROI)
144  );
145 }
146 
147 
148 
149 
151 {
152  DataViewProperties retval;
153  retval.mVolume3D = true;
154  retval.mSlice3D = false;
155  retval.mSlice2D = true;
156  return retval;
157 }
159 {
160  DataViewProperties retval;
161  retval.mVolume3D = true;
162  retval.mSlice3D = true;
163  retval.mSlice2D = true;
164  return retval;
165 }
166 
168 {
169  DataViewProperties retval;
170  retval.mVolume3D = true;
171  retval.mSlice3D = false;
172  retval.mSlice2D = false;
173  return retval;
174 }
175 
177 {
178  DataViewProperties retval;
179  retval.mVolume3D = false;
180  retval.mSlice3D = true;
181  retval.mSlice2D = false;
182  return retval;
183 }
184 
186 {
187  DataViewProperties retval;
188  retval.mVolume3D = false;
189  retval.mSlice3D = false;
190  retval.mSlice2D = true;
191  return retval;
192 }
193 
195 {
196  DataViewProperties retval;
197  retval.mVolume3D = true;
198  retval.mSlice3D = true;
199  retval.mSlice2D = false;
200  return retval;
201 }
202 
203 
204 void DataViewProperties::addXml(QDomNode& dataNode)
205 {
206  QDomElement elem = dataNode.toElement();
207  elem.setAttribute("volume3D", mVolume3D);
208  elem.setAttribute("slice3D", mSlice3D);
209  elem.setAttribute("slice2D", mSlice2D);
210 }
211 
212 void DataViewProperties::parseXml(QDomNode dataNode)
213 {
214  QDomElement elem = dataNode.toElement();
215  mVolume3D = elem.attribute("volume3D", QString::number(mVolume3D)).toInt();
216  mSlice3D = elem.attribute("slice3D", QString::number(mSlice3D)).toInt();
217  mSlice2D = elem.attribute("slice2D", QString::number(mSlice2D)).toInt();
218 }
219 
221 {
222  return !(mVolume3D || mSlice3D || mSlice2D);
223 }
224 
226 {
227  DataViewProperties retval;
228  retval.mSlice2D = mSlice2D || rhs.mSlice2D;
229  retval.mSlice3D = mSlice3D || rhs.mSlice3D;
230  retval.mVolume3D = mVolume3D || rhs.mVolume3D;
231  return retval;
232 }
233 
235 {
236  DataViewProperties retval;
237  retval.mSlice2D = mSlice2D && !rhs.mSlice2D;
238  retval.mSlice3D = mSlice3D && !rhs.mSlice3D;
239  retval.mVolume3D = mVolume3D && !rhs.mVolume3D;
240  return retval;
241 }
242 
244 {
245  if (required.mSlice2D && mSlice2D) return true;
246  if (required.mSlice3D && mSlice3D) return true;
247  if (required.mVolume3D && mVolume3D) return true;
248  return false;
249 }
250 
251 
252 
256 
257 bool dataTypeSort(const DataPtr data1, const DataPtr data2)
258 {
259  return getPriority(data1) < getPriority(data2);
260 }
261 
263 {
264  if (data->getType()==Mesh::getTypeName())
265  return 6;
266  DataMetricPtr metric = boost::dynamic_pointer_cast<DataMetric>(data);
267  if (metric)
268  return 7;
269 
270  ImagePtr image = boost::dynamic_pointer_cast<Image>(data);
271  if (image)
272  {
273  if (image->getModality() == imUS)
274  {
275  if (image->getImageType() == istUSBMODE)
276  return 4;
277  else // angio types
278  return 5;
279  }
280  else if (image->getModality() == imMR)
281  {
282  // MR, CT, SC, others
283  return 2;
284  }
285  else if (image->getModality() == imCT)
286  {
287  // MR, CT, SC, others
288  return 1;
289  }
290  else
291  {
292  return 0;
293  }
294  }
295 
296  return 3;
297 }
298 
302 
304  mShowLandmarks(false), mShowPointPickerProbe(false),
305  mPickerGlyph(new Mesh("PickerGlyph"))
306 {
307 }
308 
310  mUid(uid),
311  mServices(services),
312  mCamera3D(CameraData::create())
313 {
314  if(mServices)
315  connect(mServices->patient().get(), &PatientModelService::dataAddedOrRemoved, this, &ViewGroupData::purgeDataNotExistingInPatientModelService);
316  mVideoSource = "active";
317  mGroup2DZoom = SyncedValue::create(1);
318  mGlobal2DZoom = mGroup2DZoom;
319 
320  this->createSliceDefinitionProperty();
321 }
322 
323 //Remove all data, and wait to emit signals until all data is removed
324 void ViewGroupData::purgeDataNotExistingInPatientModelService()
325 {
326  QStringList purged;
327  for (unsigned i = 0; i < mData.size(); )
328  {
329  QString uid = mData[i].first;
330  if (!mServices->patient()->getData(uid))
331  {
332  if (this->contains(uid))
333  {
334  purged << uid;
335  mData.erase(std::find_if(mData.begin(), mData.end(), data_equals(uid)));
336  }
337  }
338  else
339  ++i;
340  }
341  //Emit delayed signals
342  for(int i = 0; i < purged.size(); ++i)
343  emit dataViewPropertiesChanged(purged[i]);
344 }
345 
346 
348 {
349  emit initialized();
350 }
351 
352 void ViewGroupData::addData(QString uid)
353 {
354  DataViewProperties properties = this->getProperties(uid);
355  properties = properties.addFlagsIn(DataViewProperties::createDefault());
356  this->setProperties(uid, properties);
357 }
358 
360 {
361  if (this->contains(uid))
362  return;
363 
365  DataAndViewPropertiesPair item(uid, properties);
366 
367  for (int i=int(mData.size())-1; i>=0; --i)
368  {
369  if (!dataTypeSort(this->getData(uid), this->getData(mData[i].first)))
370  {
371  this->insertData(mData.begin()+i+1, item);
372  break;
373  }
374  }
375  if (!this->contains(uid))
376  this->insertData(mData.begin(), item);
377  emit dataViewPropertiesChanged(uid);
378 }
379 
380 void ViewGroupData::insertData(std::vector<DataAndViewPropertiesPair>::iterator iter, DataAndViewPropertiesPair &item)
381 {
382  //this->upload3DTextureIfImageToSharedContext(item.first);
383  this->mData.insert(iter, item);
384 }
385 
386 /*
387 //TODO remove? maybe it is better to do this in the proxy?
388 void ViewGroupData::upload3DTextureIfImageToSharedContext(QString uid)
389 {
390  CX_LOG_DEBUG() << "upload3DTextureIfImageToSharedContext: " << uid;
391  ImagePtr image = mServices->patient()->getData<Image>(uid);
392  if(image)
393  {
394  if(mSharedOpenGLContext)
395  mSharedOpenGLContext->upload3DTexture(image);
396  else
397  CX_LOG_ERROR() << "ViewGroupData::uploadIfImageToSharedContext: Got no shared OpenGL context";
398  }
399 }
400 */
401 
403 {
404  if (this->contains(uid))
405  return std::find_if(mData.begin(), mData.end(), data_equals(uid))->second;
406  return DataViewProperties();
407 }
408 
410 {
411  if (uid.isEmpty())
412  return;
413 
414  if (properties.empty())
415  {
416  this->removeData(uid);
417  return;
418  }
419 
420  if (!this->contains(uid))
421  {
422  DataAndViewPropertiesPair item(uid, properties);
423 // mData.push_back(item);
424  this->insertData(mData.end(), item);
425  }
426  else
427  {
428  std::find_if(mData.begin(), mData.end(), data_equals(uid))->second = properties;
429  }
430 
431  emit dataViewPropertiesChanged(uid);
432 }
433 
434 bool ViewGroupData::contains(QString uid) const
435 {
436  return std::count_if(mData.begin(), mData.end(), data_equals(uid));
437 }
438 
439 bool ViewGroupData::removeData(QString uid)
440 {
441  if (!this->contains(uid))
442  return false;
443  mData.erase(std::find_if(mData.begin(), mData.end(), data_equals(uid)));
444  emit dataViewPropertiesChanged(uid);
445  return true;
446 }
447 
449 {
450  while (!mData.empty())
451  this->removeData(mData.front().first);
452  this->setVideoSource("active");
453 
454  mGroup2DZoom->set(1.0);
455  mGlobal2DZoom->set(1.0);
456 }
457 
458 DataPtr ViewGroupData::getData(QString uid) const
459 {
460  DataPtr data = mServices->patient()->getData(uid);
461  if (!data)
462  {
463  reportError("Couldn't find the data: [" + uid + "] in the datamanager.");
464  return DataPtr();
465  }
466  return data;
467 }
468 
470 {
471  if (mVideoSource==uid)
472  return;
473  mVideoSource = uid;
474  emit videoSourceChanged(mVideoSource);
475 }
476 
478 {
479  return mVideoSource;
480 }
481 
482 std::vector<DataPtr> ViewGroupData::getData(DataViewProperties properties) const
483 {
484  return this->getDataOfType<Data>(properties);
485 }
486 
487 
488 template<class DATA_TYPE>
489 std::vector<boost::shared_ptr<DATA_TYPE> > ViewGroupData::getDataOfType(DataViewProperties requiredProperties) const
490 {
491  // speed optimization: call getdatas() instead of getdata() in for loop
492  std::map<QString, DataPtr> alldata = mServices->patient()->getDatas();
493 
494  typedef boost::shared_ptr<DATA_TYPE> DATA_PTR;
495  std::vector<DATA_PTR> retval;
496  for (unsigned i = 0; i < mData.size(); ++i)
497  {
498  DATA_PTR data = boost::dynamic_pointer_cast<DATA_TYPE>(alldata[mData[i].first]);
499  if (!data)
500  continue;
501  DataViewProperties properties = mData[i].second;
502  if (!properties.containsAnyFlagsIn(requiredProperties))
503  continue;
504  retval.push_back(data);
505  }
506  return retval;
507 }
508 
509 std::vector<ImagePtr> ViewGroupData::getImages(DataViewProperties properties) const
510 {
511  return this->getDataOfType<Image>(properties);
512 }
513 
514 std::vector<MeshPtr> ViewGroupData::getMeshes(DataViewProperties properties) const
515 {
516  return this->getDataOfType<Mesh>(properties);
517 }
518 
519 std::vector<TrackedStreamPtr> ViewGroupData::getTrackedStreams(DataViewProperties properties) const
520 {
521  return this->getDataOfType<TrackedStream>(properties);
522 }
523 
524 std::vector<ImagePtr> ViewGroupData::getImagesAndChangingImagesFromTrackedStreams(DataViewProperties properties, bool include2D) const
525 {
526  std::vector<ImagePtr> images = this->getImages(properties);
527  std::vector<TrackedStreamPtr> streams = this->getTrackedStreams(properties);
528 
529  for(unsigned i = 0; i < streams.size(); ++i)
530  {
531  ImagePtr changingImage = streams[i]->getChangingImage();
532  if(streams[i]->is3D())
533  images.push_back(changingImage);
534  if(include2D && streams[i]->is2D())
535  images.push_back(changingImage);
536  }
537  return images;
538 }
539 
541 {
542  return mOptions;
543 }
544 
546 {
547  mOptions = options;
548  emit optionsChanged();
549 }
550 
552 {
553  mGlobal2DZoom = val;
554 }
555 
557 {
558  return mGroup2DZoom;
559 }
561 {
562  return mGlobal2DZoom;
563 }
564 
565 void ViewGroupData::zoomCamera3D(int zoomFactor)
566 {
567  CameraDataPtr cameraData = this->getCamera3D();
568  if(!cameraData)
569  return;
570 
571  vtkCameraPtr camera = cameraData->getCamera();
572  if(!camera)
573  return;
574 
575  camera->Dolly(zoomFactor);
576 }
577 
578 void ViewGroupData::createSliceDefinitionProperty()
579 {
580  QStringList slicedefs;
581  for (int i=0; i<ptCOUNT; ++i)
582  slicedefs << enum2string(PLANE_TYPE(i));
583  QStringList slicedefaults;
585  mSliceDefinitionProperty = StringListProperty::initialize("slice_definition_3D",
586  "3D Slices",
587  "Select slice planes to view in 3D",
588  slicedefaults,
589  slicedefs);
590  connect(mSliceDefinitionProperty.get(), &Property::changed, this, &ViewGroupData::optionsChanged);
591 }
592 
594 {
595  QStringList val = mSliceDefinitionProperty->getValue();
596  return PlaneTypeCollection::fromString(val.join("/"));
597 }
598 
600 {
601  QStringList val_list = val.toString().split("/");
602  mSliceDefinitionProperty->setValue(val_list);
603 }
604 
606 {
607  return mSliceDefinitionProperty;
608 }
609 
610 void ViewGroupData::addXml(QDomNode& dataNode)
611 {
612  XMLNodeAdder base(dataNode);
613 
614  for (unsigned i = 0; i < mData.size(); ++i)
615  {
616  QDomElement elem;
617  elem = base.addTextToElement("data", mData[i].first);
618  mData[i].second.addXml(elem);
619  }
620 
621  base.addObjectToElement("camera3D", this->getCamera3D());
622  base.addTextToElement("slicesPlanes3D", this->getSliceDefinitions().toString());
623 
624  Options options = this->getOptions();
625  base.addObjectToElement("cameraStyle", &options.mCameraStyle);
626 }
627 
628 void ViewGroupData::parseXml(QDomNode dataNode)
629 {
630  XMLNodeParser base(dataNode);
631 
632  QString sliceText = base.parseTextFromElement("slicesPlanes3D");
634 
635  std::vector<QDomElement> dataElems = base.getDuplicateElements("data");
636  for (unsigned i=0; i<dataElems.size(); ++i)
637  {
638  QDomElement elem = dataElems[i];
639  QString uid = elem.text();
641  properties.parseXml(elem);
642 
643  this->addData(uid);
644  this->setProperties(uid, properties);
645  }
646 
647  base.parseObjectFromElement("camera3D", this->getCamera3D());
648 
649  Options options = this->getOptions();
650  base.parseObjectFromElement("cameraStyle", &options.mCameraStyle);
651  this->setOptions(options);
652 }
653 
654 void ViewGroupData::setRegistrationMode(REGISTRATION_STATUS mode)
655 {
656  ViewGroupData::Options options = this->getOptions();
657 
658  options.mShowLandmarks = false;
659  options.mShowPointPickerProbe = false;
660 
661  if (mode == rsIMAGE_REGISTRATED)
662  {
663  options.mShowLandmarks = true;
664  options.mShowPointPickerProbe = true;
665  }
666  if (mode == rsPATIENT_REGISTRATED)
667  {
668  options.mShowLandmarks = true;
669  options.mShowPointPickerProbe = false;
670  }
671 
672  this->setOptions(options);
673 }
674 
675 
677 {
678  return mControllingTool;
679 }
681 {
682  mControllingTool = tool;
683 }
684 
685 } // namespace cx
int getPriority(DataPtr data)
static DataViewProperties createSlice3D()
ptCORONAL
a slice seen from the front of the patient
Definition: cxDefinitions.h:39
void reportError(QString msg)
Definition: cxLogger.cpp:71
void initializeGlobal2DZoom(SyncedValuePtr val)
A mesh data set.
Definition: cxMesh.h:45
CameraDataPtr getCamera3D()
void addXml(QDomNode &dataNode)
static DataViewProperties createDefault()
boost::shared_ptr< class CameraData > CameraDataPtr
Definition: cxViewWrapper.h:36
PlaneTypeCollection getSliceDefinitions()
std::string toString(T const &value)
converts any type to a string
Definition: catch.hpp:755
imMR
boost::shared_ptr< DataMetric > DataMetricPtr
Definition: cxDataMetric.h:73
void parseXml(QDomNode dataNode)
std::vector< QDomElement > getDuplicateElements(QString name)
boost::shared_ptr< class Image > ImagePtr
Definition: cxDicomWidget.h:27
std::vector< ImagePtr > getImagesAndChangingImagesFromTrackedStreams(DataViewProperties properties, bool include2D=false) const
CAMERA_STYLE_TYPE getStyle()
SyncedValuePtr getGroup2DZoom()
void parseXml(QDomNode dataNode)
SyncedValuePtr getGlobal2DZoom()
DataViewProperties getProperties(QString uid)
ptAXIAL
a slice seen from the top of the patient
Definition: cxDefinitions.h:39
cstTOOL_STYLE
Definition: cxViewService.h:34
ViewGroupData(CoreServicesPtr services, QString uid)
void setProperties(QString uid, DataViewProperties properties)
static DataViewProperties createSlice2D()
static StringListPropertyPtr initialize(const QString &uid, QString name, QString help, QStringList value, QStringList range, QDomNode root=QDomNode())
istUSBMODE
void addObjectToElement(QString name, T object)
cstDEFAULT_STYLE
Definition: cxViewService.h:34
static DataViewProperties create3D()
boost::shared_ptr< class Data > DataPtr
std::vector< MeshPtr > getMeshes(DataViewProperties properties) const
ptSAGITTAL
a slice seen from the side of the patient
Definition: cxDefinitions.h:39
static PlaneTypeCollection fromString(QString input, PlaneTypeCollection defVal=PlaneTypeCollection())
void setCameraStyle(CAMERA_STYLE_TYPE style)
void addData(QString uid)
void addDataSorted(QString uid)
add data in a predefined ordering: CT/MR/SC/US/USA/Mesh/Metrics
static SyncedValuePtr create(QVariant val=QVariant())
ToolPtr getControllingTool()
A volumetric data set.
Definition: cxImage.h:45
cstANGLED_TOOL_STYLE
Definition: cxViewService.h:34
QDomElement addTextToElement(QString name, QString text)
Options getOptions() const
void addXml(QDomNode &dataNode)
bool containsAnyFlagsIn(DataViewProperties required) const
static DataViewProperties createFull()
std::vector< ImagePtr > getImages(DataViewProperties properties) const
void parseXml(QDomNode dataNode)
std::vector< TrackedStreamPtr > getTrackedStreams(DataViewProperties properties) const
void dataViewPropertiesChanged(QString uid)
void changed()
emit when the underlying data value is changed: The user interface will be updated.
static DataViewProperties createVolume3D()
void zoomCamera3D(int zoomFactor)
bool dataTypeSort(const DataPtr data1, const DataPtr data2)
bool removeData(QString uid)
boost::shared_ptr< class StringListProperty > StringListPropertyPtr
bool operator==(const RegistrationTransform &lhs, const RegistrationTransform &rhs)
imUS
QString parseTextFromElement(QString name)
bool similar(const CameraInfo &lhs, const CameraInfo &rhs, double tol)
void setVideoSource(QString uid)
boost::shared_ptr< class CoreServices > CoreServicesPtr
Definition: cxCameraStyle.h:37
DataViewProperties removeFlagsIn(DataViewProperties rhs) const
void parseObjectFromElement(QString name, T object)
cstUNICAM_STYLE
Definition: cxViewService.h:34
DataViewProperties addFlagsIn(DataViewProperties rhs) const
static QString getTypeName()
Definition: cxMesh.h:67
void setControllingTool(ToolPtr tool)
void videoSourceChanged(QString uid)
boost::shared_ptr< class SyncedValue > SyncedValuePtr
Definition: cxViewGroup.h:30
void setRegistrationMode(REGISTRATION_STATUS mode)
imCT
StringListPropertyPtr getSliceDefinitionProperty()
void addXml(QDomNode &dataNode)
std::vector< DataPtr > getData(DataViewProperties properties=DataViewProperties::createFull()) const
Base class for all Data Metrics.
Definition: cxDataMetric.h:43
void setSliceDefinitions(PlaneTypeCollection val)
QString enum2string(const ENUM &val)
QString getVideoSource() const
void setOptions(Options options)
#define M_PI
vtkSmartPointer< class vtkCamera > vtkCameraPtr
rsIMAGE_REGISTRATED
Namespace for all CustusX production code.
boost::shared_ptr< class Tool > ToolPtr