Medical Imaging Interaction Toolkit  2018.4.99-3e3f1a6e
Medical Imaging Interaction Toolkit
mitkSliceNavigationController.cpp
Go to the documentation of this file.
1 /*============================================================================
2 
3 The Medical Imaging Interaction Toolkit (MITK)
4 
5 Copyright (c) German Cancer Research Center (DKFZ)
6 All rights reserved.
7 
8 Use of this source code is governed by a 3-clause BSD license that can be
9 found in the LICENSE file.
10 
11 ============================================================================*/
12 
14 #include "mitkAction.h"
15 #include "mitkBaseRenderer.h"
17 #include "mitkInteractionConst.h"
18 #include "mitkOperation.h"
19 #include "mitkOperationActor.h"
20 #include "mitkPlaneGeometry.h"
23 #include "mitkRenderingManager.h"
24 #include "mitkSlicedGeometry3D.h"
25 #include "mitkVtkPropRenderer.h"
26 
27 #include "mitkImage.h"
29 #include "mitkInteractionConst.h"
31 #include "mitkOperationEvent.h"
32 #include "mitkPixelTypeMultiplex.h"
33 #include "mitkPlaneOperation.h"
34 #include "mitkPointOperation.h"
35 #include "mitkStatusBar.h"
36 #include "mitkUndoController.h"
37 
39 
40 #include "mitkMemoryUtilities.h"
41 
42 #include <itkCommand.h>
43 
44 namespace mitk
45 {
47  : BaseController(),
48  m_InputWorldGeometry3D( mitk::BaseGeometry::ConstPointer() ),
49  m_InputWorldTimeGeometry( mitk::TimeGeometry::ConstPointer() ),
50  m_CreatedWorldGeometry( mitk::TimeGeometry::Pointer() ),
51  m_ViewDirection(Axial),
52  m_DefaultViewDirection(Axial),
53  m_RenderingManager( mitk::RenderingManager::Pointer() ),
54  m_Renderer( nullptr ),
55  m_Top(false),
56  m_FrontSide(false),
57  m_Rotated(false),
58  m_BlockUpdate(false),
59  m_SliceLocked(false),
60  m_SliceRotationLocked(false),
61  m_OldPos(0)
62  {
63  typedef itk::SimpleMemberCommand<SliceNavigationController> SNCCommandType;
64  SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
65 
66  sliceStepperChangedCommand = SNCCommandType::New();
67  timeStepperChangedCommand = SNCCommandType::New();
68 
69  sliceStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendSlice);
70 
71  timeStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendTime);
72 
73  m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
74  m_Time->AddObserver(itk::ModifiedEvent(), timeStepperChangedCommand);
75 
76  m_Slice->SetUnitName("mm");
77  m_Time->SetUnitName("ms");
78 
79  m_Top = false;
80  m_FrontSide = false;
81  m_Rotated = false;
82  }
83 
86  {
87  if ( geometry != nullptr )
88  {
89  if (geometry->GetBoundingBox()->GetDiagonalLength2() < eps)
90  {
91  itkWarningMacro("setting an empty bounding-box");
92  geometry = nullptr;
93  }
94  }
95  if (m_InputWorldGeometry3D != geometry)
96  {
97  m_InputWorldGeometry3D = geometry;
99  this->Modified();
100  }
101  }
102 
104  {
105  if ( geometry != nullptr )
106  {
107  if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() < eps)
108  {
109  itkWarningMacro("setting an empty bounding-box");
110  geometry = nullptr;
111  }
112  }
113  if (m_InputWorldTimeGeometry != geometry)
114  {
115  m_InputWorldTimeGeometry = geometry;
117  this->Modified();
118  }
119  }
120 
123  {
124  const char *viewDirectionString;
125  switch (m_ViewDirection)
126  {
128  viewDirectionString = "Axial";
129  break;
130 
132  viewDirectionString = "Sagittal";
133  break;
134 
136  viewDirectionString = "Coronal";
137  break;
138 
140  viewDirectionString = "Original";
141  break;
142 
143  default:
144  viewDirectionString = "No View Direction Available";
145  break;
146  }
147  return viewDirectionString;
148  }
149 
151  {
152  if (!m_BlockUpdate)
153  {
154  if (m_ViewDirection == Sagittal)
155  {
156  this->Update(Sagittal, true, true, false);
157  }
158  else if (m_ViewDirection == Frontal)
159  {
160  this->Update(Frontal, false, true, false);
161  }
162  else if (m_ViewDirection == Axial)
163  {
164  this->Update(Axial, false, false, true);
165  }
166  else
167  {
168  this->Update(m_ViewDirection);
169  }
170  }
171  }
172 
174  bool top,
175  bool frontside,
176  bool rotated)
177  {
179 
180  if (m_BlockUpdate || (m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull()) ||
181  ((worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0)))
182  {
183  return;
184  }
185 
186  m_BlockUpdate = true;
187 
188  if (m_InputWorldTimeGeometry.IsNotNull() && m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
189  {
190  Modified();
191  }
192  if (m_InputWorldGeometry3D.IsNotNull() && m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime())
193  {
194  Modified();
195  }
196  this->SetViewDirection(viewDirection);
197  this->SetTop(top);
198  this->SetFrontSide(frontside);
199  this->SetRotated(rotated);
200 
201  if (m_LastUpdateTime < GetMTime())
202  {
203  m_LastUpdateTime = GetMTime();
204 
205  // initialize the viewplane
208  if (m_InputWorldTimeGeometry.IsNotNull())
209  if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
210  currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
211  else
212  currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
213  else
214  currentGeometry = m_InputWorldGeometry3D;
215 
217  switch (viewDirection)
218  {
219  case Original:
220  if (worldTimeGeometry.IsNotNull())
221  {
222  m_CreatedWorldGeometry = worldTimeGeometry->Clone();
223 
224  worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
225 
226  slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
227  m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
228 
229  if (slicedWorldGeometry.IsNotNull())
230  {
231  break;
232  }
233  }
234  else
235  {
236  const auto *worldSlicedGeometry =
237  dynamic_cast<const SlicedGeometry3D *>(currentGeometry.GetPointer());
238 
239  if ( worldSlicedGeometry != nullptr )
240  {
241  slicedWorldGeometry = static_cast<SlicedGeometry3D *>(currentGeometry->Clone().GetPointer());
242  break;
243  }
244  }
245  slicedWorldGeometry = SlicedGeometry3D::New();
246  slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::None, top, frontside, rotated);
247  slicedWorldGeometry->SetSliceNavigationController(this);
248  break;
249 
250  case Axial:
251  slicedWorldGeometry = SlicedGeometry3D::New();
252  slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Axial, top, frontside, rotated);
253  slicedWorldGeometry->SetSliceNavigationController(this);
254  break;
255 
256  case Frontal:
257  slicedWorldGeometry = SlicedGeometry3D::New();
258  slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Frontal, top, frontside, rotated);
259  slicedWorldGeometry->SetSliceNavigationController(this);
260  break;
261 
262  case Sagittal:
263  slicedWorldGeometry = SlicedGeometry3D::New();
264  slicedWorldGeometry->InitializePlanes(currentGeometry, PlaneGeometry::Sagittal, top, frontside, rotated);
265  slicedWorldGeometry->SetSliceNavigationController(this);
266  break;
267  default:
268  itkExceptionMacro("unknown ViewDirection");
269  }
270 
271  m_Slice->SetPos(0);
272  m_Slice->SetSteps((int)slicedWorldGeometry->GetSlices());
273 
274  if ( worldTimeGeometry.IsNull() )
275  {
276  auto createdTimeGeometry = ProportionalTimeGeometry::New();
277  createdTimeGeometry->Initialize( slicedWorldGeometry, 1 );
278  m_CreatedWorldGeometry = createdTimeGeometry;
279 
280  m_Time->SetSteps(0);
281  m_Time->SetPos(0);
282  m_Time->InvalidateRange();
283  }
284  else
285  {
286  m_BlockUpdate = true;
287  m_Time->SetSteps(worldTimeGeometry->CountTimeSteps());
288  m_Time->SetPos(0);
289 
290  const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
291  m_Time->SetRange(timeBounds[0], timeBounds[1]);
292 
293  m_BlockUpdate = false;
294 
295  const auto currentTemporalPosition = this->GetTime()->GetPos();
296  assert( worldTimeGeometry->GetGeometryForTimeStep( currentTemporalPosition ).IsNotNull() );
297 
298  if ( dynamic_cast<const mitk::ProportionalTimeGeometry*>( worldTimeGeometry.GetPointer() ) != nullptr )
299  {
300  const TimePointType minimumTimePoint =
301  worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition );
302 
303  const TimePointType stepDuration =
304  worldTimeGeometry->TimeStepToTimePoint( currentTemporalPosition + 1 ) - minimumTimePoint;
305 
306  auto createdTimeGeometry = ProportionalTimeGeometry::New();
307  createdTimeGeometry->Initialize( slicedWorldGeometry, worldTimeGeometry->CountTimeSteps() );
308  createdTimeGeometry->SetFirstTimePoint( minimumTimePoint );
309  createdTimeGeometry->SetStepDuration( stepDuration );
310 
311  m_CreatedWorldGeometry = createdTimeGeometry;
312  }
313  else
314  {
315  auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
316  const TimeStepType numberOfTimeSteps = worldTimeGeometry->CountTimeSteps();
317  createdTimeGeometry->ReserveSpaceForGeometries( numberOfTimeSteps );
318 
319  for ( TimeStepType i = 0; i < numberOfTimeSteps; ++i )
320  {
321  const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone().GetPointer();
322  const auto bounds = worldTimeGeometry->GetTimeBounds( i );
323  createdTimeGeometry->AppendNewTimeStep( clonedGeometry,
324  bounds[0], bounds[1]);
325  }
326  createdTimeGeometry->Update();
327 
328  m_CreatedWorldGeometry = createdTimeGeometry;
329  }
330  }
331  }
332 
333  // unblock update; we may do this now, because if m_BlockUpdate was already
334  // true before this method was entered, then we will never come here.
335  m_BlockUpdate = false;
336 
337  // Send the geometry. Do this even if nothing was changed, because maybe
338  // Update() was only called to re-send the old geometry and time/slice data.
339  this->SendCreatedWorldGeometry();
340  this->SendSlice();
341  this->SendTime();
342 
343  // Adjust the stepper range of slice stepper according to geometry
344  this->AdjustSliceStepperRange();
345  }
346 
348  {
349  // Send the geometry. Do this even if nothing was changed, because maybe
350  // Update() was only called to re-send the old geometry.
351  if (!m_BlockUpdate)
352  {
353  this->InvokeEvent(GeometrySendEvent(m_CreatedWorldGeometry, 0));
354  }
355  }
356 
358  {
359  if (!m_BlockUpdate)
360  {
361  this->InvokeEvent(GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
362  }
363  }
364 
366  {
367  if (!m_BlockUpdate)
368  {
369  if (m_CreatedWorldGeometry.IsNotNull())
370  {
371  this->InvokeEvent(GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
373  }
374  }
375  }
376 
378  {
379  if (!m_BlockUpdate)
380  {
381  if (m_CreatedWorldGeometry.IsNotNull())
382  {
383  this->InvokeEvent(GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()));
385  }
386  }
387  }
388 
389  void SliceNavigationController::SetGeometry(const itk::EventObject &) {}
390  void SliceNavigationController::SetGeometryTime(const itk::EventObject &geometryTimeEvent)
391  {
392  if (m_CreatedWorldGeometry.IsNull())
393  {
394  return;
395  }
396 
397  const auto *timeEvent =
398  dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(&geometryTimeEvent);
399  assert( timeEvent != nullptr );
400 
401  TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
402  assert( timeGeometry != nullptr );
403 
404  auto timeStep = (int)timeEvent->GetPos();
405  ScalarType timeInMS;
406  timeInMS = timeGeometry->TimeStepToTimePoint(timeStep);
407  timeStep = m_CreatedWorldGeometry->TimePointToTimeStep(timeInMS);
408  this->GetTime()->SetPos(timeStep);
409  }
410 
411  void SliceNavigationController::SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
412  {
413  const auto *sliceEvent =
414  dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
415  assert(sliceEvent!=nullptr);
416 
417  this->GetSlice()->SetPos(sliceEvent->GetPos());
418  }
419 
421  {
422  if (m_CreatedWorldGeometry.IsNull())
423  {
424  return;
425  }
426 
427  //@todo add time to PositionEvent and use here!!
428  SlicedGeometry3D *slicedWorldGeometry = dynamic_cast<SlicedGeometry3D *>(
429  m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos()).GetPointer());
430 
431  if (slicedWorldGeometry)
432  {
433  int bestSlice = -1;
434  double bestDistance = itk::NumericTraits<double>::max();
435 
436  int s, slices;
437  slices = slicedWorldGeometry->GetSlices();
438  if (slicedWorldGeometry->GetEvenlySpaced())
439  {
440  mitk::PlaneGeometry *plane = slicedWorldGeometry->GetPlaneGeometry(0);
441 
442  const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
443 
444  Point3D projectedPoint;
445  plane->Project(point, projectedPoint);
446 
447  // Check whether the point is somewhere within the slice stack volume;
448  // otherwise, the default slice (0) will be selected
449  if (direction[0] * (point[0] - projectedPoint[0]) + direction[1] * (point[1] - projectedPoint[1]) +
450  direction[2] * (point[2] - projectedPoint[2]) >=
451  0)
452  {
453  bestSlice = (int)(plane->Distance(point) / slicedWorldGeometry->GetSpacing()[2] + 0.5);
454  }
455  }
456  else
457  {
458  Point3D projectedPoint;
459  for (s = 0; s < slices; ++s)
460  {
461  slicedWorldGeometry->GetPlaneGeometry(s)->Project(point, projectedPoint);
462  const Vector3D distance = projectedPoint - point;
463  ScalarType currentDistance = distance.GetSquaredNorm();
464 
465  if (currentDistance < bestDistance)
466  {
467  bestDistance = currentDistance;
468  bestSlice = s;
469  }
470  }
471  }
472  if (bestSlice >= 0)
473  {
474  this->GetSlice()->SetPos(bestSlice);
475  }
476  else
477  {
478  this->GetSlice()->SetPos(0);
479  }
481  // send crosshair event
482  SetCrosshairEvent.Send(point);
483  }
484  }
485 
487  {
488  if (m_CreatedWorldGeometry.IsNull())
489  {
490  return;
491  }
492 
493  PlaneOperation op(OpORIENT, point, normal);
494 
495  m_CreatedWorldGeometry->ExecuteOperation(&op);
496 
498  }
499 
501  const mitk::Vector3D &axisVec0,
502  const mitk::Vector3D &axisVec1)
503  {
505  {
506  PlaneOperation op(OpORIENT, point, axisVec0, axisVec1);
507  m_CreatedWorldGeometry->ExecuteOperation(&op);
508 
510  }
511  }
512 
515  {
516  if (m_CreatedWorldGeometry.IsNotNull())
517  {
518  return m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos());
519  }
520  else
521  {
522  return nullptr;
523  }
524  }
525 
527  {
528  const auto *slicedGeometry =
529  dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
530 
531  if (slicedGeometry)
532  {
533  const mitk::PlaneGeometry *planeGeometry = (slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos()));
534  return planeGeometry;
535  }
536  else
537  {
538  return nullptr;
539  }
540  }
541 
545  {
546  const auto *slicedGeometry =
547  dynamic_cast<const mitk::SlicedGeometry3D *>(this->GetCurrentGeometry3D());
548 
549  const Vector3D &direction = slicedGeometry->GetDirectionVector();
550 
551  int c = 0;
552  int i, k = 0;
553  for (i = 0; i < 3; ++i)
554  {
555  if (fabs(direction[i]) < 0.000000001)
556  {
557  ++c;
558  }
559  else
560  {
561  k = i;
562  }
563  }
564 
565  if (c == 2)
566  {
567  ScalarType min = slicedGeometry->GetOrigin()[k];
568  ScalarType max = min + slicedGeometry->GetExtentInMM(k);
569 
570  m_Slice->SetRange(min, max);
571  }
572  else
573  {
574  m_Slice->InvalidateRange();
575  }
576  }
577 
579  {
580  // switch on type
581  // - select best slice for a given point
582  // - rotate created world geometry according to Operation->SomeInfo()
583  if (!operation || m_CreatedWorldGeometry.IsNull())
584  {
585  return;
586  }
587 
588  switch (operation->GetOperationType())
589  {
590  case OpMOVE: // should be a point operation
591  {
592  if (!m_SliceLocked) // do not move the cross position
593  {
594  // select a slice
595  auto *po = dynamic_cast<PointOperation *>(operation);
596  if (po && po->GetIndex() == -1)
597  {
598  this->SelectSliceByPoint(po->GetPoint());
599  }
600  else if (po &&
601  po->GetIndex() != -1) // undo case because index != -1, index holds the old position of this slice
602  {
603  this->GetSlice()->SetPos(po->GetIndex());
604  }
605  }
606  break;
607  }
609  {
610  m_CreatedWorldGeometry->ExecuteOperation(operation);
611 
613 
614  break;
615  }
617  {
618  m_CreatedWorldGeometry->ExecuteOperation(operation);
619 
621 
622  break;
623  }
624  default:
625  {
626  // do nothing
627  break;
628  }
629  }
630  }
631 
632 } // namespace
virtual const mitk::TimeGeometry * GetCreatedWorldGeometry()
Access the created geometry.
virtual void SendCreatedWorldGeometry()
Send the created geometry to the connected observers (renderers)
mitk::Stepper * GetSlice()
Get the Stepper through the slices.
BoundingBox * GetBoundingBoxInWorld() const
Returns a bounding box that covers all time steps.
float k(1.0)
void SelectSliceByPoint(const mitk::Point3D &point)
Positions the SNC according to the specified point.
itk::FixedArray< ScalarType, 2 > TimeBounds
Standard typedef for time-bounds.
itk::SmartPointer< Self > Pointer
Baseclass for renderer slice-/camera-control.
Base class of all Operation-classes.
Definition: mitkOperation.h:29
static Pointer New()
void SetInputWorldTimeGeometry(const mitk::TimeGeometry *geometry)
double ScalarType
mitk::TimeGeometry::Pointer m_CreatedWorldGeometry
void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &normal)
Re-orients the slice stack. All slices will be oriented to the given normal vector. The given point (world coordinates) defines the selected slice. Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use ReorientSlices (const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1).
Organizes the rendering process.
virtual unsigned int GetSlices() const
Get the number of slices.
DataCollection - Class to facilitate loading/accessing structured data.
Constants for most interaction classes, due to the generic StateMachines.
virtual void SetRotated(bool _arg)
virtual const mitk::Vector3D & GetDirectionVector() const
virtual void SetFrontSide(bool _arg)
unsigned long m_LastUpdateTime
virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
Project a 3D point given in mm (pt3d_mm) onto the 2D geometry. The result is a 3D point in mm (projec...
void ExecuteOperation(Operation *operation) override
virtual bool GetEvenlySpaced() const
Set/Get whether the SlicedGeometry3D is evenly-spaced (m_EvenlySpaced)
virtual mitk::PlaneGeometry * GetPlaneGeometry(int s) const
Returns the PlaneGeometry of the slice (s).
virtual void SetTop(bool _arg)
virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent)
To connect multiple SliceNavigationController, we can act as an observer ourselves: implemented inter...
virtual void SendSlice()
Send the currently selected slice to the connected observers (renderers)
Manager for coordinating the rendering process.
static RenderingManager * GetInstance()
virtual void SetGeometry(const itk::EventObject &geometrySliceEvent)
To connect multiple SliceNavigationController, we can act as an observer ourselves: implemented inter...
ViewDirection
Possible view directions, Original will uses the PlaneGeometry instances in a SlicedGeometry3D provid...
Stepper::Pointer m_Slice
void SetRenderer(BaseRenderer *renderer)
Sets the BaseRenderer associated with this SNC (if any). While the BaseRenderer is not directly used ...
const mitk::PlaneGeometry * GetCurrentPlaneGeometry()
Returns the currently selected Plane in the current BaseGeometry (if existent).
virtual TimePointType TimeStepToTimePoint(TimeStepType timeStep) const =0
Converts a time step to a time point.
Operation that handles all actions on one Point.
Operation for setting a plane (defined by its origin and normal)
mitk::ScalarType TimePointType
std::vcl_size_t TimeStepType
virtual void SetPos(unsigned int pos)
Definition: mitkStepper.h:55
static T max(T x, T y)
Definition: svm.cpp:56
itk::SmartPointer< Self > Pointer
Describes the geometry of a data object consisting of slices.
virtual void SendCreatedWorldGeometryUpdate()
Tell observers to re-read the currently selected 2D geometry.
void AdjustSliceStepperRange()
Adjusts the numerical range of the slice stepper according to the current geometry orientation of thi...
static T min(T x, T y)
Definition: svm.cpp:53
const mitk::Vector3D GetSpacing() const
Get the spacing (size of a pixel).
mitk::BaseGeometry::ConstPointer m_InputWorldGeometry3D
mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry
itk::SmartPointer< const Self > ConstPointer
Stepper::Pointer m_Time
MITKCORE_EXPORT const ScalarType eps
ScalarType Distance(const Point3D &pt3d_mm) const
Distance of the point from the geometry (bounding-box not considered)
mitk::Stepper * GetTime()
Get the Stepper through the time.
virtual unsigned int GetPos() const
Describes a two-dimensional, rectangular plane.
const mitk::BaseGeometry * GetCurrentGeometry3D()
Returns the BaseGeometry of the currently selected time step.
virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent)
To connect multiple SliceNavigationController, we can act as an observer ourselves: implemented inter...
itk::SmartPointer< const Self > ConstPointer
BaseRenderer * GetRenderer() const
Gets the BaseRenderer associated with this SNC (if any). While the BaseRenderer is not directly used ...
OperationType GetOperationType()
void SetInputWorldGeometry3D(const mitk::BaseGeometry *geometry)
Set the input world geometry3D out of which the geometries for slicing will be created.
virtual void Update()
Do the actual creation and send it to the connected observers (renderers)
void RequestUpdateAll(RequestType type=REQUEST_UPDATE_ALL)
BaseGeometry Describes the geometry of a data object.
virtual const BoundingBoxType * GetBoundingBox()
virtual void SendTime()
Send the currently selected time to the connected observers (renderers)