Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
mitkOverwriteSliceImageFilter.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,
6 Division of Medical and Biological Informatics.
7 All rights reserved.
8 
9 This software is distributed WITHOUT ANY WARRANTY; without
10 even the implied warranty of MERCHANTABILITY or FITNESS FOR
11 A PARTICULAR PURPOSE.
12 
13 See LICENSE.txt or http://www.mitk.org for details.
14 
15 ===================================================================*/
16 
17 #include "mitkOverwriteSliceImageFilter.h"
18 #include "mitkApplyDiffImageOperation.h"
19 #include "mitkDiffImageApplier.h"
20 #include "mitkImageAccessByItk.h"
21 #include "mitkImageCast.h"
22 #include "mitkImageTimeSelector.h"
23 #include "mitkInteractionConst.h"
24 #include "mitkOperationEvent.h"
25 #include "mitkSegmentationInterpolationController.h"
26 #include "mitkUndoController.h"
27 
28 #include <itkImageRegionIterator.h>
29 #include <itkImageSliceIteratorWithIndex.h>
30 
31 mitk::OverwriteSliceImageFilter::OverwriteSliceImageFilter()
32  : m_SliceIndex(0),
33  m_SliceDimension(0),
34  m_TimeStep(0),
35  m_Dimension0(0),
36  m_Dimension1(1),
37  m_CreateUndoInformation(false)
38 {
39  MITK_WARN << "Class is deprecated! Use mitkVtkImageOverwrite instead.";
40 }
41 
42 mitk::OverwriteSliceImageFilter::~OverwriteSliceImageFilter()
43 {
44 }
45 
46 void mitk::OverwriteSliceImageFilter::GenerateData()
47 {
48  //
49  // this is the place to implement the major part of undo functionality (bug #491)
50  // here we have to create undo/do operations
51  //
52  // WHO is the operation actor? This object may not be destroyed ever (design of undo stack)!
53  // -> some singleton method of this filter?
54  //
55  // neccessary additional objects:
56  // - something that executes the operations
57  // - the operation class (must hold a binary diff or something)
58  // - observer commands to know when the image is deleted (no further action then, perhaps even remove the operations
59  // from the undo stack)
60  //
61  Image::ConstPointer input = ImageToImageFilter::GetInput(0);
62  Image::Pointer input3D = ImageToImageFilter::GetInput(0);
63 
64  Image::ConstPointer slice = m_SliceImage;
65 
66  if (input.IsNull() || slice.IsNull())
67  return;
68 
69  switch (m_SliceDimension)
70  {
71  default:
72  case 2:
73  m_Dimension0 = 0;
74  m_Dimension1 = 1;
75  break;
76  case 1:
77  m_Dimension0 = 0;
78  m_Dimension1 = 2;
79  break;
80  case 0:
81  m_Dimension0 = 1;
82  m_Dimension1 = 2;
83  break;
84  }
85 
86  if (slice->GetDimension() < 2 || input->GetDimension() > 4 ||
87  slice->GetDimension(0) != input->GetDimension(m_Dimension0) ||
88  slice->GetDimension(1) != input->GetDimension(m_Dimension1) ||
89  m_SliceIndex >= input->GetDimension(m_SliceDimension))
90  {
91  itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
92  return;
93  }
94 
95  if (input->GetDimension() == 4)
96  {
97  ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
98  timeSelector->SetInput(input);
99  timeSelector->SetTimeNr(m_TimeStep);
100  timeSelector->UpdateLargestPossibleRegion();
101  input3D = timeSelector->GetOutput();
102  }
103 
104  if (m_SliceDifferenceImage.IsNull() || m_SliceDifferenceImage->GetDimension(0) != m_SliceImage->GetDimension(0) ||
105  m_SliceDifferenceImage->GetDimension(1) != m_SliceImage->GetDimension(1))
106  {
107  m_SliceDifferenceImage = mitk::Image::New();
108  mitk::PixelType pixelType(mitk::MakeScalarPixelType<short signed int>());
109  m_SliceDifferenceImage->Initialize(pixelType, 2, m_SliceImage->GetDimensions());
110  }
111 
112  // MITK_INFO << "Overwriting slice " << m_SliceIndex << " in dimension " << m_SliceDimension << " at time step " <<
113  // m_TimeStep << std::endl;
114  // this will do a long long if/else to find out both pixel types
115  AccessFixedDimensionByItk(input3D, ItkImageSwitch, 3);
116 
117  SegmentationInterpolationController *interpolator = SegmentationInterpolationController::InterpolatorForImage(input);
118  if (interpolator)
119  {
120  interpolator->BlockModified(true);
121  interpolator->SetChangedSlice(m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep);
122  }
123 
124  if (m_CreateUndoInformation)
125  {
126  // create do/undo operations (we don't execute the doOp here, because it has already been executed during
127  // calculation of the diff image
128  auto doOp = new ApplyDiffImageOperation(OpTEST,
129  const_cast<Image *>(input.GetPointer()),
130  m_SliceDifferenceImage,
131  m_TimeStep,
132  m_SliceDimension,
133  m_SliceIndex);
134  auto undoOp = new ApplyDiffImageOperation(OpTEST,
135  const_cast<Image *>(input.GetPointer()),
136  m_SliceDifferenceImage,
137  m_TimeStep,
138  m_SliceDimension,
139  m_SliceIndex);
140  undoOp->SetFactor(-1.0);
141  OperationEvent *undoStackItem =
142  new OperationEvent(DiffImageApplier::GetInstanceForUndo(),
143  doOp,
144  undoOp,
145  this->EventDescription(m_SliceDimension, m_SliceIndex, m_TimeStep));
146  OperationEvent::IncCurrObjectEventId();
147  UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
148  }
149 
150  // this image is modified (good to know for the renderer)
151  input->Modified();
152 
153  if (interpolator)
154  {
155  interpolator->BlockModified(false);
156  }
157 }
158 
159 // basically copied from mitk/Core/Algorithms/mitkImageAccessByItk.h
160 #define myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, pixeltype, dimension, itkimage2) \
161  if (typeId == MapPixelComponentType<pixeltype>::value) \
162  \
163 { \
164  typedef itk::Image<pixeltype, dimension> ImageType; \
165  typedef mitk::ImageToItk<ImageType> ImageToItkType; \
166  itk::SmartPointer<ImageToItkType> imagetoitk = ImageToItkType::New(); \
167  const mitk::Image *constImage = mitkImage; \
168  mitk::Image *nonConstImage = const_cast<mitk::Image *>(constImage); \
169  nonConstImage->Update(); \
170  imagetoitk->SetInput(nonConstImage); \
171  imagetoitk->Update(); \
172  itkImageTypeFunction(imagetoitk->GetOutput(), itkimage2); \
173  \
174 }
175 
176 #define myMITKOverwriteSliceImageFilterAccessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension, itkimage2) \
177  \
178 { \
179  myMITKOverwriteSliceImageFilterAccessByItk( \
180  mitkImage, \
181  itkImageTypeFunction, \
182  double, \
183  dimension, \
184  itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, \
185  itkImageTypeFunction, \
186  float, \
187  dimension, \
188  itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, int, dimension, itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned int, dimension, itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, \
189  itkImageTypeFunction, \
190  short, \
191  dimension, \
192  itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, itkImageTypeFunction, unsigned short, dimension, itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, \
193  itkImageTypeFunction, \
194  char, \
195  dimension, \
196  itkimage2) else myMITKOverwriteSliceImageFilterAccessByItk(mitkImage, \
197  itkImageTypeFunction, \
198  unsigned char, \
199  dimension, \
200  itkimage2) \
201  \
202 }
203 
204 template <typename TPixel, unsigned int VImageDimension>
205 void mitk::OverwriteSliceImageFilter::ItkImageSwitch(itk::Image<TPixel, VImageDimension> *itkImage)
206 {
207  const int typeId = m_SliceImage->GetPixelType().GetComponentType();
208 
209  myMITKOverwriteSliceImageFilterAccessAllTypesByItk(m_SliceImage, ItkImageProcessing, 2, itkImage);
210 }
211 
212 template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
213 void mitk::OverwriteSliceImageFilter::ItkImageProcessing(const itk::Image<TPixel1, VImageDimension1> *inputImage,
214  itk::Image<TPixel2, VImageDimension2> *outputImage)
215 {
216  typedef itk::Image<TPixel1, VImageDimension1> SliceImageType;
217  typedef itk::Image<short signed int, VImageDimension1> DiffImageType;
218  typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;
219 
220  typedef itk::ImageSliceIteratorWithIndex<VolumeImageType> OutputSliceIteratorType;
221  typedef itk::ImageRegionConstIterator<SliceImageType> InputSliceIteratorType;
222  typedef itk::ImageRegionIterator<DiffImageType> DiffSliceIteratorType;
223 
224  typename VolumeImageType::RegionType sliceInVolumeRegion;
225 
226  sliceInVolumeRegion = outputImage->GetLargestPossibleRegion();
227  sliceInVolumeRegion.SetSize(m_SliceDimension, 1); // just one slice
228  sliceInVolumeRegion.SetIndex(m_SliceDimension, m_SliceIndex); // exactly this slice, please
229 
230  OutputSliceIteratorType outputIterator(outputImage, sliceInVolumeRegion);
231  outputIterator.SetFirstDirection(m_Dimension0);
232  outputIterator.SetSecondDirection(m_Dimension1);
233 
234  InputSliceIteratorType inputIterator(inputImage, inputImage->GetLargestPossibleRegion());
235 
236  typename DiffImageType::Pointer diffImage;
237  CastToItkImage(m_SliceDifferenceImage, diffImage);
238  DiffSliceIteratorType diffIterator(diffImage, diffImage->GetLargestPossibleRegion());
239 
240  // iterate over output slice (and over input slice simultaneously)
241  outputIterator.GoToBegin();
242  inputIterator.GoToBegin();
243  diffIterator.GoToBegin();
244  while (!outputIterator.IsAtEnd())
245  {
246  while (!outputIterator.IsAtEndOfSlice())
247  {
248  while (!outputIterator.IsAtEndOfLine())
249  {
250  diffIterator.Set(static_cast<short signed int>(inputIterator.Get() -
251  outputIterator.Get())); // oh oh, not good for bigger values
252  outputIterator.Set((TPixel2)inputIterator.Get());
253  ++outputIterator;
254  ++inputIterator;
255  ++diffIterator;
256  }
257  outputIterator.NextLine();
258  }
259  outputIterator.NextSlice();
260  }
261 }
262 
263 std::string mitk::OverwriteSliceImageFilter::EventDescription(unsigned int sliceDimension,
264  unsigned int sliceIndex,
265  unsigned int timeStep)
266 {
267  std::stringstream s;
268 
269  s << "Changed slice (";
270 
271  switch (sliceDimension)
272  {
273  default:
274  case 2:
275  s << "T";
276  break;
277  case 1:
278  s << "C";
279  break;
280  case 0:
281  s << "S";
282  break;
283  }
284 
285  s << " " << sliceIndex << " " << timeStep << ")";
286 
287  return s.str();
288 }
mitk::OverwriteSliceImageFilter::ItkImageProcessing
void ItkImageProcessing(const itk::Image< TPixel1, VImageDimension1 > *itkImage1, itk::Image< TPixel2, VImageDimension2 > *itkImage2)
Definition: mitkOverwriteSliceImageFilter.cpp:213
mitk::ApplyDiffImageOperation
Operation, that holds information about some image difference.
Definition: mitkApplyDiffImageOperation.h:43
mitk::Pointer
itk::SmartPointer< Self > Pointer
Definition: mitkRenderingManager.h:389
AccessFixedDimensionByItk
#define AccessFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension)
Access a mitk-image with known dimension by an itk-image.
Definition: mitkImageAccessByItk.h:283
mitk::SegmentationInterpolationController::SetChangedSlice
void SetChangedSlice(const Image *sliceDiff, unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep)
Update after changing a single slice.
Definition: mitkSegmentationInterpolationController.cpp:200
mitkInteractionConst.h
Constants for most interaction classes, due to the generic StateMachines.
mitk::SegmentationInterpolationController::BlockModified
void BlockModified(bool)
Block reaction to an images Modified() events.
Definition: mitkSegmentationInterpolationController.cpp:90
myMITKOverwriteSliceImageFilterAccessAllTypesByItk
#define myMITKOverwriteSliceImageFilterAccessAllTypesByItk(mitkImage, itkImageTypeFunction, dimension, itkimage2)
Definition: mitkOverwriteSliceImageFilter.cpp:176
mitk::DiffImageApplier::GetInstanceForUndo
static DiffImageApplier * GetInstanceForUndo()
Definition: mitkDiffImageApplier.cpp:201
MITK_WARN
#define MITK_WARN
Definition: mitkLogMacros.h:23
mitk::OverwriteSliceImageFilter::EventDescription
std::string EventDescription(unsigned int sliceDimension, unsigned int sliceIndex, unsigned int timeStep)
Definition: mitkOverwriteSliceImageFilter.cpp:263
mitk::OverwriteSliceImageFilter::GenerateData
virtual void GenerateData() override
A version of GenerateData() specific for image processing filters.
Definition: mitkOverwriteSliceImageFilter.cpp:46
mitk::SegmentationInterpolationController::InterpolatorForImage
static SegmentationInterpolationController * InterpolatorForImage(const Image *)
Find interpolator for a given image.
Definition: mitkSegmentationInterpolationController.cpp:35
mitk::Image::New
static Pointer New()
mitk::ImageToImageFilter::GetInput
InputImageType * GetInput(void)
Definition: mitkImageToImageFilter.cpp:54
mitk::CastToItkImage
void MITKCORE_EXPORT CastToItkImage(const mitk::Image *mitkImage, itk::SmartPointer< ItkOutputImageType > &itkOutputImage)
Cast an mitk::Image to an itk::Image with a specific type.
mitk::UndoModel::SetOperationEvent
virtual bool SetOperationEvent(UndoStackItem *stackItem)=0
mitk::UndoController::GetCurrentUndoModel
static UndoModel * GetCurrentUndoModel()
gives access to the currently used UndoModel Introduced to access special functions of more specific ...
Definition: mitkUndoController.cpp:214
mitk::UndoStackItem::IncCurrObjectEventId
static void IncCurrObjectEventId()
Increases the current ObjectEventId For example if a button click generates operations the ObjectEven...
Definition: mitkOperationEvent.cpp:44
mitk::OverwriteSliceImageFilter::ItkImageSwitch
void ItkImageSwitch(itk::Image< TPixel, VImageDimension > *image)
Definition: mitkOverwriteSliceImageFilter.cpp:205
mitk::OperationEvent
Represents a pair of operations: undo and the according redo.
Definition: mitkOperationEvent.h:143
mitk::ImageTimeSelector::New
static Pointer New()
mitk::PixelType
Class for defining the data type of pixels.
Definition: mitkPixelType.h:55