Fraxinus  22.09
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  TrackedStreamPtr trackedStream = boost::dynamic_pointer_cast<TrackedStream>(this->getData(uid));
445  if (trackedStream)
446  trackedStream->deleteImageToStopEmittingFrames();
447  emit dataViewPropertiesChanged(uid);
448  return true;
449 }
450 
452 {
453  while (!mData.empty())
454  this->removeData(mData.front().first);
455  this->setVideoSource("active");
456 
457  mGroup2DZoom->set(1.0);
458  mGlobal2DZoom->set(1.0);
459 }
460 
461 DataPtr ViewGroupData::getData(QString uid) const
462 {
463  DataPtr data = mServices->patient()->getData(uid);
464  if (!data)
465  {
466  reportError("Couldn't find the data: [" + uid + "] in the datamanager.");
467  return DataPtr();
468  }
469  return data;
470 }
471 
473 {
474  if (mVideoSource==uid)
475  return;
476  mVideoSource = uid;
477  emit videoSourceChanged(mVideoSource);
478 }
479 
481 {
482  return mVideoSource;
483 }
484 
485 std::vector<DataPtr> ViewGroupData::getData(DataViewProperties properties) const
486 {
487  return this->getDataOfType<Data>(properties);
488 }
489 
490 
491 template<class DATA_TYPE>
492 std::vector<boost::shared_ptr<DATA_TYPE> > ViewGroupData::getDataOfType(DataViewProperties requiredProperties) const
493 {
494  // speed optimization: call getdatas() instead of getdata() in for loop
495  std::map<QString, DataPtr> alldata = mServices->patient()->getDatas();
496 
497  typedef boost::shared_ptr<DATA_TYPE> DATA_PTR;
498  std::vector<DATA_PTR> retval;
499  for (unsigned i = 0; i < mData.size(); ++i)
500  {
501  DATA_PTR data = boost::dynamic_pointer_cast<DATA_TYPE>(alldata[mData[i].first]);
502  if (!data)
503  continue;
504  DataViewProperties properties = mData[i].second;
505  if (!properties.containsAnyFlagsIn(requiredProperties))
506  continue;
507  retval.push_back(data);
508  }
509  return retval;
510 }
511 
512 std::vector<ImagePtr> ViewGroupData::getImages(DataViewProperties properties) const
513 {
514  return this->getDataOfType<Image>(properties);
515 }
516 
517 std::vector<MeshPtr> ViewGroupData::getMeshes(DataViewProperties properties) const
518 {
519  return this->getDataOfType<Mesh>(properties);
520 }
521 
522 std::vector<TrackedStreamPtr> ViewGroupData::getTrackedStreams(DataViewProperties properties) const
523 {
524  return this->getDataOfType<TrackedStream>(properties);
525 }
526 
527 std::vector<ImagePtr> ViewGroupData::getImagesAndChangingImagesFromTrackedStreams(DataViewProperties properties, bool include2D) const
528 {
529  std::vector<ImagePtr> images = this->getImages(properties);
530  std::vector<TrackedStreamPtr> streams = this->getTrackedStreams(properties);
531 
532  for(unsigned i = 0; i < streams.size(); ++i)
533  {
534  ImagePtr changingImage = streams[i]->getChangingImage();
535  if(streams[i]->is3D())
536  images.push_back(changingImage);
537  if(include2D && streams[i]->is2D())
538  images.push_back(changingImage);
539  }
540  return images;
541 }
542 
544 {
545  return mOptions;
546 }
547 
549 {
550  mOptions = options;
551  emit optionsChanged();
552 }
553 
555 {
556  mGlobal2DZoom = val;
557 }
558 
560 {
561  return mGroup2DZoom;
562 }
564 {
565  return mGlobal2DZoom;
566 }
567 
568 void ViewGroupData::zoomCamera3D(int zoomFactor)
569 {
570  CameraDataPtr cameraData = this->getCamera3D();
571  if(!cameraData)
572  return;
573 
574  vtkCameraPtr camera = cameraData->getCamera();
575  if(!camera)
576  return;
577 
578  camera->Dolly(zoomFactor);
579 }
580 
581 void ViewGroupData::createSliceDefinitionProperty()
582 {
583  QStringList slicedefs;
584  for (int i=0; i<ptCOUNT; ++i)
585  slicedefs << enum2string(PLANE_TYPE(i));
586  QStringList slicedefaults;
588  mSliceDefinitionProperty = StringListProperty::initialize("slice_definition_3D",
589  "3D Slices",
590  "Select slice planes to view in 3D",
591  slicedefaults,
592  slicedefs);
593  connect(mSliceDefinitionProperty.get(), &Property::changed, this, &ViewGroupData::optionsChanged);
594 }
595 
597 {
598  QStringList val = mSliceDefinitionProperty->getValue();
599  return PlaneTypeCollection::fromString(val.join("/"));
600 }
601 
603 {
604  QStringList val_list = val.toString().split("/");
605  mSliceDefinitionProperty->setValue(val_list);
606 }
607 
609 {
610  return mSliceDefinitionProperty;
611 }
612 
613 void ViewGroupData::addXml(QDomNode& dataNode)
614 {
615  XMLNodeAdder base(dataNode);
616 
617  for (unsigned i = 0; i < mData.size(); ++i)
618  {
619  QDomElement elem;
620  elem = base.addTextToElement("data", mData[i].first);
621  mData[i].second.addXml(elem);
622  }
623 
624  base.addObjectToElement("camera3D", this->getCamera3D());
625  base.addTextToElement("slicesPlanes3D", this->getSliceDefinitions().toString());
626 
627  Options options = this->getOptions();
628  base.addObjectToElement("cameraStyle", &options.mCameraStyle);
629 }
630 
631 void ViewGroupData::parseXml(QDomNode dataNode)
632 {
633  XMLNodeParser base(dataNode);
634 
635  QString sliceText = base.parseTextFromElement("slicesPlanes3D");
637 
638  std::vector<QDomElement> dataElems = base.getDuplicateElements("data");
639  for (unsigned i=0; i<dataElems.size(); ++i)
640  {
641  QDomElement elem = dataElems[i];
642  QString uid = elem.text();
644  properties.parseXml(elem);
645 
646  this->addData(uid);
647  this->setProperties(uid, properties);
648  }
649 
650  base.parseObjectFromElement("camera3D", this->getCamera3D());
651 
652  Options options = this->getOptions();
653  base.parseObjectFromElement("cameraStyle", &options.mCameraStyle);
654  this->setOptions(options);
655 }
656 
657 void ViewGroupData::setRegistrationMode(REGISTRATION_STATUS mode)
658 {
659  ViewGroupData::Options options = this->getOptions();
660 
661  options.mShowLandmarks = false;
662  options.mShowPointPickerProbe = false;
663 
664  if (mode == rsIMAGE_REGISTRATED)
665  {
666  options.mShowLandmarks = true;
667  options.mShowPointPickerProbe = true;
668  }
669  if (mode == rsPATIENT_REGISTRATED)
670  {
671  options.mShowLandmarks = true;
672  options.mShowPointPickerProbe = false;
673  }
674 
675  this->setOptions(options);
676 }
677 
678 
680 {
681  return mControllingTool;
682 }
684 {
685  mControllingTool = tool;
686  emit controllingToolChanged();
687 }
688 
689 } // 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
boost::shared_ptr< class TrackedStream > TrackedStreamPtr
PlaneTypeCollection getSliceDefinitions()
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
A data set for video streams (2D/3D).
cstTOOL_STYLE
Definition: cxViewService.h:34
ViewGroupData(CoreServicesPtr services, QString uid)
void setProperties(QString uid, DataViewProperties properties)
static DataViewProperties createSlice2D()
void controllingToolChanged()
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)
void deleteImageToStopEmittingFrames()
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