diff --git a/Core/Code/Algorithms/mitkOverwriteSliceFilter.cpp b/Core/Code/Algorithms/mitkOverwriteSliceFilter.cpp deleted file mode 100644 index fa8dc7c1d4..0000000000 --- a/Core/Code/Algorithms/mitkOverwriteSliceFilter.cpp +++ /dev/null @@ -1,107 +0,0 @@ -/*========================================================================= - -Program: Medical Imaging & Interaction Toolkit -Language: C++ -Date: $Date$ -Version: $Revision: $ - -Copyright (c) German Cancer Research Center, Division of Medical and -Biological Informatics. All rights reserved. -See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. - -This software is distributed WITHOUT ANY WARRANTY; without even -the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -PURPOSE. See the above copyright notices for more information. - -=========================================================================*/ -#include "mitkOverwriteSliceFilter.h" -#include - - -mitk::OverwriteSliceFilter::OverwriteSliceFilter(){ - m_TimeStep = 0; -} - -mitk::OverwriteSliceFilter::~OverwriteSliceFilter(){ - m_Slice = NULL; -} - -void mitk::OverwriteSliceFilter::SetInputSlice(mitk::Image* slice) -{ - this->m_Slice = slice->GetVtkImageData(); -} - -void mitk::OverwriteSliceFilter::GenerateInputRequestedRegion(){ - //As we want all pixel information fo the image in our plane, the requested region - //is set to the largest possible region in the image. - //This is needed because an oblique plane has a larger extent then the image - //and the in pipeline it is checked via PropagateResquestedRegion(). But the - //extent of the slice is actually fitting because it is oblique within the image. - ImageToImageFilter::InputImagePointer input = const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() ); - input->SetRequestedRegionToLargestPossibleRegion(); -} - - - -template -static void GetOverwritefunc(int dataType, void (**overwritefunc)(F *inPtr, F *outPtr, unsigned int *mapPtr, int todo)){ - - switch (dataType) - { - vtkTemplateAliasMacro(*((void (**)(VTK_TT *outPtr, VTK_TT *inPtr, - unsigned int *mapPtr, int todo))overwritefunc) = \ - &Overwrite); - default: - overwritefunc = 0; - } -} - - -template -static void Overwrite(T *inPtr, T *outPtr, unsigned int *mapPtr, int todo){ - - do{ - unsigned int shift = *mapPtr; - mapPtr++; - *(outPtr + shift) = *inPtr++; - }while(--todo); - -} - - - - -void mitk::OverwriteSliceFilter::GenerateData() -{ - vtkSmartPointer inputVolume = (const_cast< mitk::Image * >(ImageToImageFilter::GetInput()))->GetVtkImageData(m_TimeStep); - - void* inPtr = m_Slice->GetScalarPointer(); - - void* outPtr = inputVolume->GetScalarPointer(); - - - unsigned int* mapPtr = m_Map; - - - int* dimensions = m_Slice->GetDimensions(); - int todo = dimensions[0] * dimensions[1]; - - - void (*overwritefunc)(void *inPtr, void *outPtr, unsigned int *mapPtr, int todo); - GetOverwritefunc(m_Slice->GetScalarType(),&overwritefunc); - - overwritefunc(inPtr, outPtr, mapPtr, todo); - - //mitk::Image::Pointer resultImage = this->GetOutput(); - - ////initialize resultimage with the specs of the vtkImageData object returned from vtkImageReslice - //resultImage->Initialize(inputVolume); - - ////transfer the voxel data - //resultImage->SetVolume(inputVolume->GetScalarPointer()); - - this->GetInput()->Modified(); - - delete [] m_Map; - m_Map = NULL; -} diff --git a/Core/Code/Algorithms/mitkOverwriteSliceFilter.h b/Core/Code/Algorithms/mitkOverwriteSliceFilter.h deleted file mode 100644 index 5c588185d4..0000000000 --- a/Core/Code/Algorithms/mitkOverwriteSliceFilter.h +++ /dev/null @@ -1,68 +0,0 @@ -/*========================================================================= - -Program: Medical Imaging & Interaction Toolkit -Language: C++ -Date: $Date$ -Version: $Revision: $ - -Copyright (c) German Cancer Research Center, Division of Medical and -Biological Informatics. All rights reserved. -See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. - -This software is distributed WITHOUT ANY WARRANTY; without even -the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -PURPOSE. See the above copyright notices for more information. - -=========================================================================*/ - -#ifndef mitkOverwriteSliceFilter_h_Included -#define mitkOverwriteSliceFilter_h_Included - - -#include "MitkExports.h" -#include "mitkImageToImageFilter.h" -#include - - -#include - - -namespace mitk -{ - - class MITK_CORE_EXPORT OverwriteSliceFilter : public ImageToImageFilter - { - public: - - mitkClassMacro(OverwriteSliceFilter, ImageToImageFilter); - itkNewMacro(OverwriteSliceFilter); - - /** \brief Set the time step in the 4D volume */ - void SetTimeStep( unsigned int timestep){ this->m_TimeStep = timestep; } - unsigned int GetTimeStep(){ return this->m_TimeStep; } - - void SetInputSlice(vtkImageData* slice){ this->m_Slice = slice; } - void SetInputSlice(mitk::Image* slice); - - virtual void SetInputMap(unsigned int* map){ this->m_Map = map;} - - vtkImageData* GetInputSlice(){return this->m_Slice;} - - protected: - OverwriteSliceFilter(); - virtual ~OverwriteSliceFilter(); - - virtual void GenerateData(); - - virtual void GenerateInputRequestedRegion(); - - vtkSmartPointer m_Slice; - unsigned int* m_Map; - - unsigned int m_TimeStep; - - - }; -} - -#endif // mitkOverwriteSliceFilter_h_Included \ No newline at end of file diff --git a/Core/Code/Algorithms/mitkVtkImageMapReslice.cpp b/Core/Code/Algorithms/mitkVtkImageMapReslice.cpp deleted file mode 100644 index bb5bb6b250..0000000000 --- a/Core/Code/Algorithms/mitkVtkImageMapReslice.cpp +++ /dev/null @@ -1,927 +0,0 @@ -/*========================================================================= - - Program: Visualization Toolkit - Module: mitkVtkImageMapReslice.cxx - - Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen - All rights reserved. - See Copyright.txt or http://www.kitware.com/Copyright.htm for details. - - This software is distributed WITHOUT ANY WARRANTY; without even - the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR - PURPOSE. See the above copyright notice for more information. - -=========================================================================*/ -#include "mitkVtkImageMapReslice.h" - -#include "vtkImageData.h" -#include "vtkImageStencilData.h" -#include "vtkInformation.h" -#include "vtkInformationVector.h" -#include "vtkMath.h" -#include "vtkObjectFactory.h" -#include "vtkStreamingDemandDrivenPipeline.h" -#include "vtkTransform.h" -#include "vtkDataSetAttributes.h" -#include "vtkGarbageCollector.h" - -#include "vtkTemplateAliasMacro.h" -// turn off 64-bit ints when templating over all types -# undef VTK_USE_INT64 -# define VTK_USE_INT64 0 -# undef VTK_USE_UINT64 -# define VTK_USE_UINT64 0 - -#include -#include -#include - - -vtkStandardNewMacro(mitkVtkImageMapReslice); - - -static void* START_INDEX_MAP; -static void* START_INDEX_VOLUME; - - - -//-------------------------------------------------------------------------- -// The 'floor' function on x86 and mips is many times slower than these -// and is used a lot in this code, optimize for different CPU architectures -template -inline int vtkResliceFloor(double x, F &f) -{ -#if defined mips || defined sparc || defined __ppc__ - x += 2147483648.0; - unsigned int i = static_cast(x); - f = x - i; - return static_cast(i - 2147483648U); -#elif defined i386 || defined _M_IX86 - union { double d; unsigned short s[4]; unsigned int i[2]; } dual; - dual.d = x + 103079215104.0; // (2**(52-16))*1.5 - f = dual.s[0]*0.0000152587890625; // 2**(-16) - return static_cast((dual.i[1]<<16)|((dual.i[0])>>16)); -#elif defined ia64 || defined __ia64__ || defined IA64 - x += 103079215104.0; - long long i = static_cast(x); - f = x - i; - return static_cast(i - 103079215104LL); -#else - double y = floor(x); - f = x - y; - return static_cast(y); -#endif -} - -inline int vtkResliceRound(double x) -{ -#if defined mips || defined sparc || defined __ppc__ - return static_cast(static_cast(x + 2147483648.5) - 2147483648U); -#elif defined i386 || defined _M_IX86 - union { double d; unsigned int i[2]; } dual; - dual.d = x + 103079215104.5; // (2**(52-16))*1.5 - return static_cast((dual.i[1]<<16)|((dual.i[0])>>16)); -#elif defined ia64 || defined __ia64__ || defined IA64 - x += 103079215104.5; - long long i = static_cast(x); - return static_cast(i - 103079215104LL); -#else - return static_cast(floor(x+0.5)); -#endif -} - -mitkVtkImageMapReslice* Self; - -//---------------------------------------------------------------------------- -mitkVtkImageMapReslice::mitkVtkImageMapReslice() -{ - m_Map = NULL; - Self = this; -} - -//---------------------------------------------------------------------------- -mitkVtkImageMapReslice::~mitkVtkImageMapReslice() -{ - Self = NULL; - m_Map = NULL; - START_INDEX_MAP = NULL; - START_INDEX_VOLUME = NULL; - -} - - - - -//---------------------------------------------------------------------------- -// Interpolation subroutines and associated code -//---------------------------------------------------------------------------- - -// Three interpolation functions are supported: NearestNeighbor, Trilinear, -// and Tricubic. These routines have the following signature: -// -//int interpolate(T *&outPtr, -// const T *inPtr, -// const int inExt[6], -// const vtkIdType inInc[3], -// int numscalars, -// const F point[3], -// int mode, -// const T *background) -// -// where 'T' is any arithmetic type and 'F' is a float type -// -// The result of the interpolation is put in *outPtr, and outPtr is -// incremented. - -//---------------------------------------------------------------------------- -// constants for different boundary-handling modes - -#define VTK_RESLICE_BACKGROUND 0 // use background if out-of-bounds -#define VTK_RESLICE_WRAP 1 // wrap to opposite side of image -#define VTK_RESLICE_MIRROR 2 // mirror off of the boundary -#define VTK_RESLICE_BORDER 3 // use a half-voxel border -#define VTK_RESLICE_NULL 4 // do nothing to *outPtr if out-of-bounds - -//---------------------------------------------------------------------------- -// rounding functions for each type, where 'F' is a floating-point type - -#if (VTK_USE_INT8 != 0) -template -inline void vtkResliceRound(F val, vtkTypeInt8& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_UINT8 != 0) -template -inline void vtkResliceRound(F val, vtkTypeUInt8& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_INT16 != 0) -template -inline void vtkResliceRound(F val, vtkTypeInt16& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_UINT16 != 0) -template -inline void vtkResliceRound(F val, vtkTypeUInt16& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_INT32 != 0) -template -inline void vtkResliceRound(F val, vtkTypeInt32& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_UINT32 != 0) -template -inline void vtkResliceRound(F val, vtkTypeUInt32& rnd) -{ - rnd = vtkResliceRound(val); -} -#endif - -#if (VTK_USE_FLOAT32 != 0) -template -inline void vtkResliceRound(F val, vtkTypeFloat32& rnd) -{ - rnd = val; -} -#endif - -#if (VTK_USE_FLOAT64 != 0) -template -inline void vtkResliceRound(F val, vtkTypeFloat64& rnd) -{ - rnd = val; -} -#endif - -//---------------------------------------------------------------------------- -// clamping functions for each type - -#if (VTK_USE_INT8 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeInt8& clamp) -{ - if (val < -128.0) - { - val = -128.0; - } - if (val > 127.0) - { - val = 127.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_UINT8 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeUInt8& clamp) -{ - if (val < 0) - { - val = 0; - } - if (val > 255.0) - { - val = 255.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_INT16 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeInt16& clamp) -{ - if (val < -32768.0) - { - val = -32768.0; - } - if (val > 32767.0) - { - val = 32767.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_UINT16 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeUInt16& clamp) -{ - if (val < 0) - { - val = 0; - } - if (val > 65535.0) - { - val = 65535.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_INT32 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeInt32& clamp) -{ - if (val < -2147483648.0) - { - val = -2147483648.0; - } - if (val > 2147483647.0) - { - val = 2147483647.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_UINT32 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeUInt32& clamp) -{ - if (val < 0) - { - val = 0; - } - if (val > 4294967295.0) - { - val = 4294967295.0; - } - vtkResliceRound(val,clamp); -} -#endif - -#if (VTK_USE_FLOAT32 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeFloat32& clamp) -{ - clamp = val; -} -#endif - -#if (VTK_USE_FLOAT64 != 0) -template -inline void vtkResliceClamp(F val, vtkTypeFloat64& clamp) -{ - clamp = val; -} -#endif - -//---------------------------------------------------------------------------- -// Perform a wrap to limit an index to [0,range). -// Ensures correct behaviour when the index is negative. - -inline int vtkInterpolateWrap(int num, int range) -{ - if ((num %= range) < 0) - { - num += range; // required for some % implementations - } - return num; -} - -//---------------------------------------------------------------------------- -// Perform a mirror to limit an index to [0,range). - -inline int vtkInterpolateMirror(int num, int range) -{ - if (num < 0) - { - num = -num - 1; - } - int count = num/range; - num %= range; - if (count & 0x1) - { - num = range - num - 1; - } - return num; -} - -//---------------------------------------------------------------------------- -// If the value is within one half voxel of the range [0,inExtX), then -// set it to "0" or "inExtX-1" as appropriate. - -inline int vtkInterpolateBorder(int &inIdX0, int &inIdX1, int inExtX, - double fx) -{ - if (inIdX0 >= 0 && inIdX1 < inExtX) - { - return 0; - } - if (inIdX0 == -1 && fx >= 0.5) - { - inIdX1 = inIdX0 = 0; - return 0; - } - if (inIdX0 == inExtX - 1 && fx < 0.5) - { - inIdX1 = inIdX0; - return 0; - } - - return 1; -} - -inline int vtkInterpolateBorderCheck(int inIdX0, int inIdX1, int inExtX, - double fx) -{ - if ((inIdX0 >= 0 && inIdX1 < inExtX) || - (inIdX0 == -1 && fx >= 0.5) || - (inIdX0 == inExtX - 1 && fx < 0.5)) - { - return 0; - } - - return 1; -} - -//---------------------------------------------------------------------------- -// Do nearest-neighbor interpolation of the input data 'inPtr' of extent -// 'inExt' at the 'point'. The result is placed at 'outPtr'. -// If the lookup data is beyond the extent 'inExt', set 'outPtr' to -// the background color 'background'. -// The number of scalar components in the data is 'numscalars' -template -int vtkNearestNeighborInterpolation(T *&outPtr, const T *inPtr, - const int inExt[6], - const vtkIdType inInc[3], - int numscalars, const F point[3], - int mode, const T *background, mitkVtkImageMapReslice* self) -{ - unsigned int* map = self->GetMap(); - - int inIdX0 = vtkResliceRound(point[0]) - inExt[0]; - int inIdY0 = vtkResliceRound(point[1]) - inExt[2]; - int inIdZ0 = vtkResliceRound(point[2]) - inExt[4]; - - int inExtX = inExt[1] - inExt[0] + 1; - int inExtY = inExt[3] - inExt[2] + 1; - int inExtZ = inExt[5] - inExt[4] + 1; - - if (inIdX0 < 0 || inIdX0 >= inExtX || - inIdY0 < 0 || inIdY0 >= inExtY || - inIdZ0 < 0 || inIdZ0 >= inExtZ) - { - if (mode == VTK_RESLICE_WRAP) - { - inIdX0 = vtkInterpolateWrap(inIdX0, inExtX); - inIdY0 = vtkInterpolateWrap(inIdY0, inExtY); - inIdZ0 = vtkInterpolateWrap(inIdZ0, inExtZ); - } - else if (mode == VTK_RESLICE_MIRROR) - { - inIdX0 = vtkInterpolateMirror(inIdX0, inExtX); - inIdY0 = vtkInterpolateMirror(inIdY0, inExtY); - inIdZ0 = vtkInterpolateMirror(inIdZ0, inExtZ); - } - else if (mode == VTK_RESLICE_BACKGROUND || - mode == VTK_RESLICE_BORDER) - { - do - { - *outPtr++ = *background++; - } - while (--numscalars); - return 0; - } - else - { - return 0; - } - } - - inPtr += inIdX0*inInc[0]+inIdY0*inInc[1]+inIdZ0*inInc[2]; - - do - { - /* *outPtr++ = (int) (inPtr - ((T*)START_INDEX) ); - inPtr++;*/ - - unsigned int shiftVolumePtr = (unsigned int)(inPtr - ((T*) START_INDEX_VOLUME)); - unsigned int shiftMapPtr = (unsigned int)(outPtr - ((T*) START_INDEX_MAP)); //you don't have to care about race conditions - *(map + shiftMapPtr) = shiftVolumePtr; - *outPtr++ = *inPtr++; - } - while (--numscalars); - - return 1; -} - - -//-------------------------------------------------------------------------- -// get appropriate interpolation function according to interpolation mode -// and scalar type -template -void vtkGetResliceInterpFunc(mitkVtkImageMapReslice *self, - int (**interpolate)(void *&outPtr, - const void *inPtr, - const int inExt[6], - const vtkIdType inInc[3], - int numscalars, - const F point[3], - int mode, - const void *background, mitkVtkImageMapReslice* self)) -{ - int dataType = self->GetOutput()->GetScalarType(); - - switch (dataType) - { - vtkTemplateAliasMacro(*((int (**)(VTK_TT *&outPtr, const VTK_TT *inPtr, - const int inExt[6], - const vtkIdType inInc[3], - int numscalars, const F point[3], - int mode, - const VTK_TT *background, mitkVtkImageMapReslice* self))interpolate) = \ - &vtkNearestNeighborInterpolation); - default: - interpolate = 0; - } -} - - -//---------------------------------------------------------------------------- -// Some helper functions for 'RequestData' -//---------------------------------------------------------------------------- - -//-------------------------------------------------------------------------- -// pixel copy function, templated for different scalar types -template -struct vtkImageResliceSetPixels -{ -static void Set(void *&outPtrV, const void *inPtrV, int numscalars, int n) -{ - const T* inPtr = static_cast(inPtrV); - T* outPtr = static_cast(outPtrV); - for (int i = 0; i < n; i++) - { - const T *tmpPtr = inPtr; - int m = numscalars; - do - { - *outPtr++ = *tmpPtr++; - } - while (--m); - } - outPtrV = outPtr; -} - -// optimized for 1 scalar components -static void Set1(void *&outPtrV, const void *inPtrV, - int vtkNotUsed(numscalars), int n) -{ - const T* inPtr = static_cast(inPtrV); - T* outPtr = static_cast(outPtrV); - T val = *inPtr; - for (int i = 0; i < n; i++) - { - *outPtr++ = val; - } - outPtrV = outPtr; -} -}; - -// get a pixel copy function that is appropriate for the data type -void vtkGetSetPixelsFunc(mitkVtkImageMapReslice *self, - void (**setpixels)(void *&out, const void *in, - int numscalars, int n)) -{ - int dataType = self->GetOutput()->GetScalarType(); - int numscalars = self->GetOutput()->GetNumberOfScalarComponents(); - - switch (numscalars) - { - case 1: - switch (dataType) - { - vtkTemplateAliasMacro( - *setpixels = &vtkImageResliceSetPixels::Set1 - ); - default: - setpixels = 0; - } - default: - switch (dataType) - { - vtkTemplateAliasMacro( - *setpixels = &vtkImageResliceSetPixels::Set - ); - default: - setpixels = 0; - } - } -} - -//---------------------------------------------------------------------------- -// Convert background color from float to appropriate type -template -void vtkAllocBackgroundPixelT(mitkVtkImageMapReslice *self, - T **background_ptr, int numComponents) -{ - *background_ptr = new T[numComponents]; - T *background = *background_ptr; - - for (int i = 0; i < numComponents; i++) - { - if (i < 4) - { - vtkResliceClamp(self->GetBackgroundColor()[i], background[i]); - } - else - { - background[i] = 0; - } - } -} - -void vtkAllocBackgroundPixel(mitkVtkImageMapReslice *self, void **rval, - int numComponents) -{ - switch (self->GetOutput()->GetScalarType()) - { - vtkTemplateAliasMacro(vtkAllocBackgroundPixelT(self, (VTK_TT **)rval, - numComponents)); - } -} - -void vtkFreeBackgroundPixel(mitkVtkImageMapReslice *self, void **rval) -{ - switch (self->GetOutput()->GetScalarType()) - { - vtkTemplateAliasMacro(delete [] *((VTK_TT **)rval)); - } - - *rval = 0; -} - -//---------------------------------------------------------------------------- -// helper function for clipping of the output with a stencil -int vtkResliceGetNextExtent(vtkImageStencilData *stencil, - int &r1, int &r2, int rmin, int rmax, - int yIdx, int zIdx, - void *&outPtr, void *background, - int numscalars, - void (*setpixels)(void *&out, - const void *in, - int numscalars, - int n), - int &iter) -{ - // trivial case if stencil is not set - if (!stencil) - { - if (iter++ == 0) - { - r1 = rmin; - r2 = rmax; - return 1; - } - return 0; - } - - // for clearing, start at last r2 plus 1 - int clear1 = r2 + 1; - if (iter == 0) - { // if no 'last time', start at rmin - clear1 = rmin; - } - - int rval = stencil->GetNextExtent(r1, r2, rmin, rmax, yIdx, zIdx, iter); - int clear2 = r1 - 1; - if (rval == 0) - { - clear2 = rmax; - } - - setpixels(outPtr, background, numscalars, clear2 - clear1 + 1); - - return rval; -} - -//---------------------------------------------------------------------------- -// This function simply clears the entire output to the background color, -// for cases where the transformation places the output extent completely -// outside of the input extent. -void vtkImageResliceClearExecute(mitkVtkImageMapReslice *self, - vtkImageData *, void *, - vtkImageData *outData, void *outPtr, - int outExt[6], int id) -{ - int numscalars; - int idY, idZ; - vtkIdType outIncX, outIncY, outIncZ; - int scalarSize; - unsigned long count = 0; - unsigned long target; - void *background; - void (*setpixels)(void *&out, const void *in, int numscalars, int n); - - // for the progress meter - target = static_cast - ((outExt[5]-outExt[4]+1)*(outExt[3]-outExt[2]+1)/50.0); - target++; - - // Get Increments to march through data - outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ); - scalarSize = outData->GetScalarSize(); - numscalars = outData->GetNumberOfScalarComponents(); - - // allocate a voxel to copy into the background (out-of-bounds) regions - vtkAllocBackgroundPixel(self, &background, numscalars); - // get the appropriate function for pixel copying - vtkGetSetPixelsFunc(self, &setpixels); - - // Loop through output voxels - for (idZ = outExt[4]; idZ <= outExt[5]; idZ++) - { - for (idY = outExt[2]; idY <= outExt[3]; idY++) - { - if (id == 0) - { // update the progress if this is the main thread - if (!(count%target)) - { - self->UpdateProgress(count/(50.0*target)); - } - count++; - } - // clear the pixels to background color and go to next row - setpixels(outPtr, background, numscalars, outExt[1]-outExt[0]+1); - outPtr = static_cast( - static_cast(outPtr) + outIncY*scalarSize); - } - outPtr = static_cast( - static_cast(outPtr) + outIncZ*scalarSize); - } - - vtkFreeBackgroundPixel(self, &background); -} - -//---------------------------------------------------------------------------- -// This function executes the filter for any type of data. It is much simpler -// in structure than vtkImageResliceOptimizedExecute. -void vtkImageResliceExecute(mitkVtkImageMapReslice *self, - vtkImageData *inData, void *inPtr, - vtkImageData *outData, void *outPtr, - int outExt[6], int id) -{ - int numscalars; - int idX, idY, idZ; - int idXmin, idXmax, iter; - vtkIdType outIncX, outIncY, outIncZ; - int scalarSize; - int inExt[6]; - vtkIdType inInc[3]; - unsigned long count = 0; - unsigned long target; - double point[4]; - double f; - double *inSpacing, *inOrigin, *outSpacing, *outOrigin, inInvSpacing[3]; - void *background; - int (*interpolate)(void *&outPtr, const void *inPtr, - const int inExt[6], const vtkIdType inInc[3], - int numscalars, const double point[3], - int mode, const void *background, mitkVtkImageMapReslice* self); - void (*setpixels)(void *&out, const void *in, int numscalars, int n); - - // the 'mode' species what to do with the 'pad' (out-of-bounds) area - int mode = VTK_RESLICE_BACKGROUND; - if (self->GetMirror()) - { - mode = VTK_RESLICE_MIRROR; - } - else if (self->GetWrap()) - { - mode = VTK_RESLICE_WRAP; - } - else if (self->GetBorder()) - { - mode = VTK_RESLICE_BORDER; - } - - // the transformation to apply to the data - vtkAbstractTransform *transform = self->GetResliceTransform(); - vtkMatrix4x4 *matrix = self->GetResliceAxes(); - - // for conversion to data coordinates - inOrigin = inData->GetOrigin(); - inSpacing = inData->GetSpacing(); - outOrigin = outData->GetOrigin(); - outSpacing = outData->GetSpacing(); - - // save effor later: invert inSpacing - inInvSpacing[0] = 1.0/inSpacing[0]; - inInvSpacing[1] = 1.0/inSpacing[1]; - inInvSpacing[2] = 1.0/inSpacing[2]; - - // find maximum input range - inData->GetExtent(inExt); - - // for the progress meter - target = static_cast - ((outExt[5]-outExt[4]+1)*(outExt[3]-outExt[2]+1)/50.0); - target++; - - // Get Increments to march through data - inData->GetIncrements(inInc); - outData->GetContinuousIncrements(outExt, outIncX, outIncY, outIncZ); - scalarSize = outData->GetScalarSize(); - numscalars = inData->GetNumberOfScalarComponents(); - - // allocate a voxel to copy into the background (out-of-bounds) regions - vtkAllocBackgroundPixel(self, &background, numscalars); - - // get the appropriate functions for interpolation and pixel copying - vtkGetResliceInterpFunc(self, &interpolate); - vtkGetSetPixelsFunc(self, &setpixels); - - // get the stencil - vtkImageStencilData *stencil = self->GetStencil(); - - // Loop through output voxels - for (idZ = outExt[4]; idZ <= outExt[5]; idZ++) - { - for (idY = outExt[2]; idY <= outExt[3]; idY++) - { - if (id == 0) - { // update the progress if this is the main thread - if (!(count%target)) - { - self->UpdateProgress(count/(50.0*target)); - } - count++; - } - - iter = 0; // if there is a stencil, it is applied here - while (vtkResliceGetNextExtent(stencil, idXmin, idXmax, - outExt[0], outExt[1], idY, idZ, - outPtr, background, numscalars, - setpixels, iter)) - { - for (idX = idXmin; idX <= idXmax; idX++) - { - // convert to data coordinates - point[0] = idX*outSpacing[0] + outOrigin[0]; - point[1] = idY*outSpacing[1] + outOrigin[1]; - point[2] = idZ*outSpacing[2] + outOrigin[2]; - - // apply ResliceAxes matrix - if (matrix) - { - point[3] = 1.0; - matrix->MultiplyPoint(point, point); - f = 1.0/point[3]; - point[0] *= f; - point[1] *= f; - point[2] *= f; - } - - // apply ResliceTransform - if (transform) - { - transform->InternalTransformPoint(point, point); - } - - // convert back to voxel indices - point[0] = (point[0] - inOrigin[0])*inInvSpacing[0]; - point[1] = (point[1] - inOrigin[1])*inInvSpacing[1]; - point[2] = (point[2] - inOrigin[2])*inInvSpacing[2]; - - // interpolate output voxel from input data set - interpolate(outPtr, inPtr, inExt, inInc, numscalars, - point, mode, background, self); - } - } - outPtr = static_cast( - static_cast(outPtr) + outIncY*scalarSize); - } - outPtr = static_cast( - static_cast(outPtr) + outIncZ*scalarSize); - } - - vtkFreeBackgroundPixel(self, &background); -} - -void mitkVtkImageMapReslice::SetOutputExtent(int ex[]){ - this->SetOutputExtent(ex[0], ex[1], ex[2], ex[3], ex[4], ex[5]); } - -void mitkVtkImageMapReslice::SetOutputExtent(int xmin, int xmax,int ymin,int ymax,int zmin,int zmax){ - Superclass::SetOutputExtent(xmin, xmax, ymin, ymax, zmin, zmax); - //get the size of the map array - int numPixels = (xmax-xmin+1) * (ymax-ymin+1); - m_Map = new unsigned int[numPixels]; -} - - -//---------------------------------------------------------------------------- -// This method is passed a input and output region, and executes the filter -// algorithm to fill the output from the input. -// It just executes a switch statement to call the correct function for -// the regions data types. -void mitkVtkImageMapReslice::ThreadedRequestData( - vtkInformation *vtkNotUsed(request), - vtkInformationVector **vtkNotUsed(inputVector), - vtkInformationVector *vtkNotUsed(outputVector), - vtkImageData ***inData, - vtkImageData **outData, - int outExt[6], int id) -{ - - vtkDebugMacro(<< "Execute: inData = " << inData[0][0] - << ", outData = " << outData[0]); - - // this filter expects that input is the same type as output. - if (inData[0][0]->GetScalarType() != outData[0]->GetScalarType()) - { - vtkErrorMacro(<< "Execute: input ScalarType, " - << inData[0][0]->GetScalarType() - << ", must match out ScalarType " - << outData[0]->GetScalarType()); - return; - } - - int inExt[6]; - inData[0][0]->GetExtent(inExt); - // check for empty input extent - if (inExt[1] < inExt[0] || - inExt[3] < inExt[2] || - inExt[5] < inExt[4]) - { - return; - } - - // Get the output pointer - void *outPtr = outData[0]->GetScalarPointerForExtent(outExt); - - if (this->HitInputExtent == 0) - { - vtkImageResliceClearExecute(this, inData[0][0], 0, outData[0], outPtr, - outExt, id); - return; - } - - // Now that we know that we need the input, get the input pointer - void *inPtr = inData[0][0]->GetScalarPointerForExtent(inExt); - - START_INDEX_MAP = outData[0]->GetScalarPointer(); - START_INDEX_VOLUME = inData[0][0]->GetScalarPointer(); - - vtkImageResliceExecute(this, inData[0][0], inPtr, outData[0], outPtr, - outExt, id); -} diff --git a/Core/Code/Algorithms/mitkVtkImageMapReslice.h b/Core/Code/Algorithms/mitkVtkImageMapReslice.h deleted file mode 100644 index 44ebbbb89d..0000000000 --- a/Core/Code/Algorithms/mitkVtkImageMapReslice.h +++ /dev/null @@ -1,56 +0,0 @@ -/*========================================================================= - -Program: Medical Imaging & Interaction Toolkit -Language: C++ -Date: $Date$ -Version: $Revision: $ - -Copyright (c) German Cancer Research Center, Division of Medical and -Biological Informatics. All rights reserved. -See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. - -This software is distributed WITHOUT ANY WARRANTY; without even -the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -PURPOSE. See the above copyright notices for more information. - -=========================================================================*/ - -#ifndef mitkVtkImageMapReslice_h_Included -#define mitkVtkImageMapReslice_h_Included - -#include -#include "MitkExports.h" - - /** \brief A Filter based on vtkImageReslice that extracts Coordinates in the 3D volume not pixel values. - * - */ - class MITK_CORE_EXPORT mitkVtkImageMapReslice : public vtkImageReslice - { - public: - - static mitkVtkImageMapReslice *New(); - vtkTypeMacro(mitkVtkImageMapReslice, vtkImageReslice); - - virtual void SetOutputExtent(int ex[]); - virtual void SetOutputExtent(int xmin, int xmax,int ymin,int ymax,int zmin,int zmax); - - virtual unsigned int* GetMap(){ return this->m_Map;} - - - protected: - - mitkVtkImageMapReslice(); - virtual ~mitkVtkImageMapReslice(); - - virtual void ThreadedRequestData(vtkInformation *vtkNotUsed(request), - vtkInformationVector **vtkNotUsed(inputVector), - vtkInformationVector *vtkNotUsed(outputVector), - vtkImageData ***inData, - vtkImageData **outData, - int outExt[6], int id); - - unsigned int* m_Map; - }; - - -#endif //mitkVtkImageMapReslice_h_Included diff --git a/Core/Code/Testing/mitkOverwriteSliceFilterTest.cpp b/Core/Code/Testing/mitkOverwriteSliceFilterTest.cpp index b669cd3a7f..6271d0cd12 100644 --- a/Core/Code/Testing/mitkOverwriteSliceFilterTest.cpp +++ b/Core/Code/Testing/mitkOverwriteSliceFilterTest.cpp @@ -1,516 +1,392 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date$ Version: $Revision: 7837 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include -#include #include -#include #include #include #include #include #include #include #include #include #include int VolumeSize = 128; - -static void OverwriteByIndexShiftTest(mitk::Image* workingImage, mitk::Image* refImg) -{ - /* ============= setup plane ============*/ - int sliceindex = 55;//rand() % 32; - bool isFrontside = true; - bool isRotated = false; - - mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New(); - plane->InitializeStandardPlane(workingImage->GetGeometry(), mitk::PlaneGeometry::Transversal, sliceindex, isFrontside, isRotated); - mitk::Point3D origin = plane->GetOrigin(); - mitk::Vector3D normal; - normal = plane->GetNormal(); - normal.Normalize(); - origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5 - plane->SetOrigin(origin); - - - - /* ============= extract slice ============*/ - mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New(); - slicer->SetInput(workingImage); - slicer->SetWorldGeometry(plane); - slicer->SetVtkOutputRequest(true); - slicer->Modified(); - slicer->Update(); - - vtkSmartPointer slice = vtkSmartPointer::New(); - slice = slicer->GetVtkOutput(); - - - - - /* ============= extract map ============*/ - vtkSmartPointer resliceMap = vtkSmartPointer::New(); - mitk::ExtractSliceFilter::Pointer slicerMap = mitk::ExtractSliceFilter::New(resliceMap); - slicerMap->SetInput(workingImage); - slicerMap->SetWorldGeometry(plane); - slicerMap->SetVtkOutputRequest(true); - slicerMap->Modified(); - slicerMap->Update(); - - unsigned int* map = resliceMap->GetMap(); - - - /* ============= overwrite slice ============*/ - mitk::OverwriteSliceFilter::Pointer overwriter = mitk::OverwriteSliceFilter::New(); - overwriter->SetInput(workingImage); - overwriter->SetInputMap(map); - overwriter->SetInputSlice(slice); - overwriter->Modified(); - overwriter->Update(); - - - - - /* ============= check ref == working ============*/ - bool areSame = true; - mitk::Index3D id; - id[0] = id[1] = id[2] = 0; - for (int x = 0; x < VolumeSize; ++x){ - id[0] = x; - for (int y = 0; y < VolumeSize; ++y){ - id[1] = y; - for (int z = 0; z < VolumeSize; ++z){ - id[2] = z; - areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); - if(!areSame) - goto stop; - } - } - } -stop: - MITK_TEST_CONDITION(areSame,"comparing images"); - - - - /* ============= edit slice ============*/ - int idX = std::abs(VolumeSize-59); - int idY = std::abs(VolumeSize-23); - int idZ = 0; - int component = 0; - double val = 33.0; - - slice->SetScalarComponentFromDouble(idX,idY,idZ,component,val); - - - - /* ============= overwrite slice ============*/ - overwriter->Modified(); - overwriter->Update(); - - - /* ============= check ============*/ - areSame = true; - - int x,y,z; - - for ( x = 0; x < VolumeSize; ++x){ - id[0] = x; - for ( y = 0; y < VolumeSize; ++y){ - id[1] = y; - for ( z = 0; z < VolumeSize; ++z){ - id[2] = z; - areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); - if(!areSame) - goto stop2; - } - } - } -stop2: - MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]"; - MITK_TEST_CONDITION(x==idX && y==idY && z==sliceindex,"overwrited the right index"); - -} - - - static void OverwriteByPointerTest(mitk::Image* workingImage, mitk::Image* refImg) { /* ============= setup plane ============*/ int sliceindex = 55;//rand() % 32; bool isFrontside = true; bool isRotated = false; mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New(); plane->InitializeStandardPlane(workingImage->GetGeometry(), mitk::PlaneGeometry::Transversal, sliceindex, isFrontside, isRotated); mitk::Point3D origin = plane->GetOrigin(); mitk::Vector3D normal; normal = plane->GetNormal(); normal.Normalize(); origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5 plane->SetOrigin(origin); /* ============= extract slice ============*/ vtkSmartPointer resliceIdx = vtkSmartPointer::New(); mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New(resliceIdx); slicer->SetInput(workingImage); slicer->SetWorldGeometry(plane); slicer->SetVtkOutputRequest(true); slicer->Modified(); slicer->Update(); vtkSmartPointer slice = vtkSmartPointer::New(); slice = slicer->GetVtkOutput(); /* ============= overwrite slice ============*/ resliceIdx->SetOverwriteMode(true); resliceIdx->Modified(); slicer->Modified(); slicer->Update();//implicit overwrite /* ============= check ref == working ============*/ bool areSame = true; mitk::Index3D id; id[0] = id[1] = id[2] = 0; for (int x = 0; x < VolumeSize; ++x){ id[0] = x; for (int y = 0; y < VolumeSize; ++y){ id[1] = y; for (int z = 0; z < VolumeSize; ++z){ id[2] = z; areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); if(!areSame) goto stop; } } } stop: - MITK_TEST_CONDITION(areSame,"comparing images"); + MITK_TEST_CONDITION(areSame,"comparing images [orthogonal]"); /* ============= edit slice ============*/ int idX = std::abs(VolumeSize-59); int idY = std::abs(VolumeSize-23); int idZ = 0; int component = 0; double val = 33.0; slice->SetScalarComponentFromDouble(idX,idY,idZ,component,val); /* ============= overwrite slice ============*/ vtkSmartPointer resliceIdx2 = vtkSmartPointer::New(); resliceIdx2->SetOverwriteMode(true); resliceIdx2->SetInputSlice(slice); mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New(resliceIdx2); slicer2->SetInput(workingImage); slicer2->SetWorldGeometry(plane); slicer2->SetVtkOutputRequest(true); slicer2->Modified(); slicer2->Update(); /* ============= check ============*/ areSame = true; int x,y,z; for ( x = 0; x < VolumeSize; ++x){ id[0] = x; for ( y = 0; y < VolumeSize; ++y){ id[1] = y; for ( z = 0; z < VolumeSize; ++z){ id[2] = z; areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); if(!areSame) goto stop2; } } } stop2: - MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]"; - MITK_TEST_CONDITION(x==idX && y==idY && z==sliceindex,"overwrited the right index"); + //MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]"; + MITK_TEST_CONDITION(x==idX && y==idY && z==sliceindex,"overwrited the right index [orthogonal]"); } static void OverwriteByPointerForObliquePlaneTest(mitk::Image* workingImage, mitk::Image* refImg) { /*==============TEST WITHOUT MITK CONVERTION=============================*/ /* ============= setup plane ============*/ int sliceindex = (int)(VolumeSize/2);//rand() % 32; bool isFrontside = true; bool isRotated = false; mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New(); obliquePlane->InitializeStandardPlane(workingImage->GetGeometry(), mitk::PlaneGeometry::Transversal, sliceindex, isFrontside, isRotated); mitk::Point3D origin = obliquePlane->GetOrigin(); mitk::Vector3D normal; normal = obliquePlane->GetNormal(); normal.Normalize(); origin += normal * 0.5;//pixelspacing is 1, so half the spacing is 0.5 obliquePlane->SetOrigin(origin); mitk::Vector3D rotationVector = obliquePlane->GetAxisVector(0); rotationVector.Normalize(); float degree = 45.0; mitk::RotationOperation* op = new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree); obliquePlane->ExecuteOperation(op); delete op; /* ============= extract slice ============*/ mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New(); slicer->SetInput(workingImage); slicer->SetWorldGeometry(obliquePlane); slicer->SetVtkOutputRequest(true); slicer->Modified(); slicer->Update(); vtkSmartPointer slice = vtkSmartPointer::New(); slice = slicer->GetVtkOutput(); /* ============= overwrite slice ============*/ vtkSmartPointer resliceIdx = vtkSmartPointer::New(); mitk::ExtractSliceFilter::Pointer overwriter = mitk::ExtractSliceFilter::New(resliceIdx); resliceIdx->SetOverwriteMode(true); resliceIdx->SetInputSlice(slice); resliceIdx->Modified(); overwriter->SetInput(workingImage); overwriter->SetWorldGeometry(obliquePlane); overwriter->SetVtkOutputRequest(true); overwriter->Modified(); overwriter->Update(); /* ============= check ref == working ============*/ bool areSame = true; mitk::Index3D id; id[0] = id[1] = id[2] = 0; for (int x = 0; x < VolumeSize; ++x){ id[0] = x; for (int y = 0; y < VolumeSize; ++y){ id[1] = y; for (int z = 0; z < VolumeSize; ++z){ id[2] = z; areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); if(!areSame) goto stop; } } } stop: - MITK_TEST_CONDITION(areSame,"comparing images (no mitk convertion)"); + MITK_TEST_CONDITION(areSame,"comparing images (no mitk convertion) [oblique]"); /*==============TEST WITH MITK CONVERTION=============================*/ /* ============= extract slice ============*/ mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New(); slicer2->SetInput(workingImage); slicer2->SetWorldGeometry(obliquePlane); slicer2->Modified(); slicer2->Update(); mitk::Image::Pointer sliceInMitk = slicer2->GetOutput(); vtkSmartPointer slice2 = vtkSmartPointer::New(); slice2 = sliceInMitk->GetVtkImageData(); /* ============= overwrite slice ============*/ vtkSmartPointer resliceIdx2 = vtkSmartPointer::New(); mitk::ExtractSliceFilter::Pointer overwriter2 = mitk::ExtractSliceFilter::New(resliceIdx2); resliceIdx2->SetOverwriteMode(true); resliceIdx2->SetInputSlice(slice2); resliceIdx2->Modified(); overwriter2->SetInput(workingImage); overwriter2->SetWorldGeometry(obliquePlane); overwriter2->SetVtkOutputRequest(true); overwriter2->Modified(); overwriter2->Update(); /* ============= check ref == working ============*/ areSame = true; id[0] = id[1] = id[2] = 0; for (int x = 0; x < VolumeSize; ++x){ id[0] = x; for (int y = 0; y < VolumeSize; ++y){ id[1] = y; for (int z = 0; z < VolumeSize; ++z){ id[2] = z; areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); if(!areSame) goto stop2; } } } stop2: - MITK_TEST_CONDITION(areSame,"comparing images (with mitk convertion)"); + MITK_TEST_CONDITION(areSame,"comparing images (with mitk convertion) [oblique]"); /*==============TEST EDIT WITHOUT MITK CONVERTION=============================*/ /* ============= edit slice ============*/ int idX = std::abs(VolumeSize-59); int idY = std::abs(VolumeSize-23); int idZ = 0; int component = 0; double val = 33.0; slice->SetScalarComponentFromDouble(idX,idY,idZ,component,val); - - + + mitk::Vector3D indx; + indx[0] = idX; indx[1] = idY; indx[2] = idZ; + sliceInMitk->GetGeometry()->IndexToWorld(indx, indx); /* ============= overwrite slice ============*/ vtkSmartPointer resliceIdx3 = vtkSmartPointer::New(); resliceIdx3->SetOverwriteMode(true); resliceIdx3->SetInputSlice(slice); mitk::ExtractSliceFilter::Pointer overwriter3 = mitk::ExtractSliceFilter::New(resliceIdx3); overwriter3->SetInput(workingImage); overwriter3->SetWorldGeometry(obliquePlane); overwriter3->SetVtkOutputRequest(true); overwriter3->Modified(); overwriter3->Update(); /* ============= check ============*/ areSame = true; int x,y,z; for ( x = 0; x < VolumeSize; ++x){ id[0] = x; for ( y = 0; y < VolumeSize; ++y){ id[1] = y; for ( z = 0; z < VolumeSize; ++z){ id[2] = z; areSame = refImg->GetPixelValueByIndex(id) == workingImage->GetPixelValueByIndex(id); if(!areSame) goto stop3; } } } stop3: - MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]"; - //MITK_TEST_CONDITION(x==idX && y==idY && z==sliceindex,"overwrited the right index"); + //MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]"; + //MITK_INFO << indx; + MITK_TEST_CONDITION(x==idX && y==z,"overwrited the right index [oblique]"); } /*================ #BEGIN test main ================*/ int mitkOverwriteSliceFilterTest(int argc, char* argv[]) { MITK_TEST_BEGIN("mitkOverwriteSliceFilterTest") typedef itk::Image ImageType; typedef itk::ImageRegionConstIterator< ImageType > ImageIterator; ImageType::Pointer image = ImageType::New(); ImageType::IndexType start; start[0] = start[1] = start[2] = 0; ImageType::SizeType size; size[0] = size[1] = size[2] = VolumeSize; ImageType::RegionType imgRegion; imgRegion.SetSize(size); imgRegion.SetIndex(start); image->SetRegions(imgRegion); image->SetSpacing(1.0); image->Allocate(); ImageIterator imageIterator( image, image->GetLargestPossibleRegion() ); imageIterator.GoToBegin(); unsigned short pixelValue = 0; //fill the image with distinct values while ( !imageIterator.IsAtEnd() ) { image->SetPixel(imageIterator.GetIndex(), pixelValue); ++imageIterator; ++pixelValue; } /* end setup itk image */ mitk::Image::Pointer refImage; CastToMitkImage(image, refImage); mitk::Image::Pointer workingImg; CastToMitkImage(image, workingImg); OverwriteByPointerTest(workingImg, refImage); - - - //mitk::Image::Pointer workingImg2; - //CastToMitkImage(image, workingImg2); - //OverwriteByIndexShiftTest(workingImg2, refImage); - - mitk::Image::Pointer workingImg3; CastToMitkImage(image, workingImg3); OverwriteByPointerForObliquePlaneTest(workingImg3, refImage); MITK_TEST_END() } diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake index 3ebd79ccb3..c238064e8f 100644 --- a/Core/Code/files.cmake +++ b/Core/Code/files.cmake @@ -1,343 +1,339 @@ SET(H_FILES Algorithms/itkImportMitkImageContainer.h Algorithms/itkImportMitkImageContainer.txx Algorithms/itkLocalVariationImageFilter.h Algorithms/itkLocalVariationImageFilter.txx Algorithms/itkMITKScalarImageToHistogramGenerator.h Algorithms/itkMITKScalarImageToHistogramGenerator.txx Algorithms/itkTotalVariationDenoisingImageFilter.h Algorithms/itkTotalVariationDenoisingImageFilter.txx Algorithms/itkTotalVariationSingleIterationImageFilter.h Algorithms/itkTotalVariationSingleIterationImageFilter.txx Algorithms/mitkBilateralFilter.h Algorithms/mitkBilateralFilter.cpp Algorithms/mitkImageAccessByItk.h Algorithms/mitkImageCast.h Algorithms/mitkImageToItk.h Algorithms/mitkImageToItk.txx Algorithms/mitkInstantiateAccessFunctions.h Algorithms/mitkITKImageImport.h Algorithms/mitkITKImageImport.txx Algorithms/mitkPixelTypeList.h # Preprocessor macros taken from Boost Algorithms/mitkPPArithmeticDec.h Algorithms/mitkPPArgCount.h Algorithms/mitkPPCat.h Algorithms/mitkPPConfig.h Algorithms/mitkPPControlExprIIf.h Algorithms/mitkPPControlIf.h Algorithms/mitkPPControlIIf.h Algorithms/mitkPPDebugError.h Algorithms/mitkPPDetailAutoRec.h Algorithms/mitkPPDetailDMCAutoRec.h Algorithms/mitkPPExpand.h Algorithms/mitkPPFacilitiesEmpty.h Algorithms/mitkPPFacilitiesExpand.h Algorithms/mitkPPLogicalBool.h Algorithms/mitkPPRepetitionDetailDMCFor.h Algorithms/mitkPPRepetitionDetailEDGFor.h Algorithms/mitkPPRepetitionDetailFor.h Algorithms/mitkPPRepetitionDetailMSVCFor.h Algorithms/mitkPPRepetitionFor.h Algorithms/mitkPPSeqElem.h Algorithms/mitkPPSeqForEach.h Algorithms/mitkPPSeqForEachProduct.h Algorithms/mitkPPSeq.h Algorithms/mitkPPSeqEnum.h Algorithms/mitkPPSeqSize.h Algorithms/mitkPPSeqToTuple.h Algorithms/mitkPPStringize.h Algorithms/mitkPPTupleEat.h Algorithms/mitkPPTupleElem.h Algorithms/mitkPPTupleRem.h Algorithms/mitkClippedSurfaceBoundsCalculator.h Algorithms/mitkExtractSliceFilter.h - Algorithms/mitkVtkImageMapReslice.h Algorithms/mitkVtkImageIdxReslice.h - Algorithms/mitkOverwriteSliceFilter.h IO/mitkPixelTypeTraits.h DataManagement/mitkCommon.h Interactions/mitkEventMapperAddOn.h Service/mitkAny.h Service/mitkGetModuleContext.h Service/mitkItkHashMap.h Service/mitkItkHashSet.h Service/mitkItkHashTable.h Service/mitkModuleAbstractTracked.h Service/mitkModuleAbstractTracked.tpp Service/mitkModuleActivator.h Service/mitkServiceFactory.h Service/mitkServiceTracker.h Service/mitkServiceTracker.tpp Service/mitkServiceTrackerCustomizer.h Service/mitkServiceTrackerPrivate.h Service/mitkServiceTrackerPrivate.tpp Service/mitkServiceUtils.h Service/mitkSharedData.h Service/mitkStaticInit.h Service/mitkTrackedService.h Service/mitkTrackedService.tpp Service/mitkTrackedServiceListener.h ) SET(CPP_FILES Algorithms/mitkBaseDataSource.cpp Algorithms/mitkBaseProcess.cpp Algorithms/mitkCoreObjectFactoryBase.cpp Algorithms/mitkCoreObjectFactory.cpp Algorithms/mitkDataNodeFactory.cpp Algorithms/mitkDataNodeSource.cpp Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp Algorithms/mitkHistogramGenerator.cpp Algorithms/mitkImageCaster.cpp Algorithms/mitkImageCastPart1.cpp Algorithms/mitkImageCastPart2.cpp Algorithms/mitkImageCastPart3.cpp Algorithms/mitkImageCastPart4.cpp Algorithms/mitkImageChannelSelector.cpp Algorithms/mitkImageSliceSelector.cpp Algorithms/mitkImageSource.cpp Algorithms/mitkImageTimeSelector.cpp Algorithms/mitkImageToImageFilter.cpp Algorithms/mitkPointSetSource.cpp Algorithms/mitkPointSetToPointSetFilter.cpp Algorithms/mitkRGBToRGBACastImageFilter.cpp Algorithms/mitkSubImageSelector.cpp Algorithms/mitkSurfaceSource.cpp Algorithms/mitkSurfaceToSurfaceFilter.cpp Algorithms/mitkUIDGenerator.cpp Algorithms/mitkVolumeCalculator.cpp Algorithms/mitkClippedSurfaceBoundsCalculator.cpp Algorithms/mitkExtractSliceFilter.cpp - Algorithms/mitkVtkImageMapReslice.cpp Algorithms/mitkVtkImageIdxReslice.cpp - Algorithms/mitkOverwriteSliceFilter.cpp Controllers/mitkBaseController.cpp Controllers/mitkCallbackFromGUIThread.cpp Controllers/mitkCameraController.cpp Controllers/mitkCameraRotationController.cpp Controllers/mitkFocusManager.cpp Controllers/mitkLimitedLinearUndo.cpp Controllers/mitkOperationEvent.cpp Controllers/mitkPlanePositionManager.cpp Controllers/mitkProgressBar.cpp Controllers/mitkRenderingManager.cpp Controllers/mitkSliceNavigationController.cpp Controllers/mitkSlicesCoordinator.cpp Controllers/mitkSlicesRotator.cpp Controllers/mitkSlicesSwiveller.cpp Controllers/mitkStatusBar.cpp Controllers/mitkStepper.cpp Controllers/mitkTestManager.cpp Controllers/mitkUndoController.cpp Controllers/mitkVerboseLimitedLinearUndo.cpp Controllers/mitkVtkInteractorCameraController.cpp Controllers/mitkVtkLayerController.cpp DataManagement/mitkAbstractTransformGeometry.cpp DataManagement/mitkAnnotationProperty.cpp DataManagement/mitkApplicationCursor.cpp DataManagement/mitkBaseData.cpp DataManagement/mitkBaseProperty.cpp DataManagement/mitkClippingProperty.cpp DataManagement/mitkChannelDescriptor.cpp DataManagement/mitkColorProperty.cpp DataManagement/mitkDataStorage.cpp #DataManagement/mitkDataTree.cpp DataManagement/mitkDataNode.cpp #DataManagement/mitkDataTreeStorage.cpp DataManagement/mitkDisplayGeometry.cpp DataManagement/mitkEnumerationProperty.cpp DataManagement/mitkGeometry2D.cpp DataManagement/mitkGeometry2DData.cpp DataManagement/mitkGeometry3D.cpp DataManagement/mitkGeometryData.cpp DataManagement/mitkGroupTagProperty.cpp DataManagement/mitkImage.cpp DataManagement/mitkImageDataItem.cpp DataManagement/mitkImageDescriptor.cpp DataManagement/mitkImageStatisticsHolder.cpp DataManagement/mitkLandmarkBasedCurvedGeometry.cpp DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp DataManagement/mitkLandmarkProjector.cpp DataManagement/mitkLevelWindow.cpp DataManagement/mitkLevelWindowManager.cpp DataManagement/mitkLevelWindowPreset.cpp DataManagement/mitkLevelWindowProperty.cpp DataManagement/mitkLookupTable.cpp DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable DataManagement/mitkMemoryUtilities.cpp DataManagement/mitkModalityProperty.cpp DataManagement/mitkModeOperation.cpp DataManagement/mitkNodePredicateAnd.cpp DataManagement/mitkNodePredicateBase.cpp DataManagement/mitkNodePredicateCompositeBase.cpp DataManagement/mitkNodePredicateData.cpp DataManagement/mitkNodePredicateDataType.cpp DataManagement/mitkNodePredicateDimension.cpp DataManagement/mitkNodePredicateFirstLevel.cpp DataManagement/mitkNodePredicateNot.cpp DataManagement/mitkNodePredicateOr.cpp DataManagement/mitkNodePredicateProperty.cpp DataManagement/mitkNodePredicateSource.cpp DataManagement/mitkPlaneOrientationProperty.cpp DataManagement/mitkPlaneGeometry.cpp DataManagement/mitkPlaneOperation.cpp DataManagement/mitkPointOperation.cpp DataManagement/mitkPointSet.cpp DataManagement/mitkProperties.cpp DataManagement/mitkPropertyList.cpp DataManagement/mitkRestorePlanePositionOperation.cpp DataManagement/mitkRotationOperation.cpp DataManagement/mitkSlicedData.cpp DataManagement/mitkSlicedGeometry3D.cpp DataManagement/mitkSmartPointerProperty.cpp DataManagement/mitkStandaloneDataStorage.cpp DataManagement/mitkStateTransitionOperation.cpp DataManagement/mitkStringProperty.cpp DataManagement/mitkSurface.cpp DataManagement/mitkSurfaceOperation.cpp DataManagement/mitkThinPlateSplineCurvedGeometry.cpp DataManagement/mitkTimeSlicedGeometry.cpp DataManagement/mitkTransferFunction.cpp DataManagement/mitkTransferFunctionProperty.cpp DataManagement/mitkTransferFunctionInitializer.cpp DataManagement/mitkVector.cpp DataManagement/mitkVtkInterpolationProperty.cpp DataManagement/mitkVtkRepresentationProperty.cpp DataManagement/mitkVtkResliceInterpolationProperty.cpp DataManagement/mitkVtkScalarModeProperty.cpp DataManagement/mitkVtkVolumeRenderingProperty.cpp DataManagement/mitkWeakPointerProperty.cpp DataManagement/mitkShaderProperty.cpp DataManagement/mitkResliceMethodProperty.cpp DataManagement/mitkMaterial.cpp Interactions/mitkAction.cpp Interactions/mitkAffineInteractor.cpp Interactions/mitkCoordinateSupplier.cpp Interactions/mitkDisplayCoordinateOperation.cpp Interactions/mitkDisplayInteractor.cpp Interactions/mitkDisplayPositionEvent.cpp Interactions/mitkDisplayVectorInteractor.cpp Interactions/mitkDisplayVectorInteractorLevelWindow.cpp Interactions/mitkDisplayVectorInteractorScroll.cpp Interactions/mitkEvent.cpp Interactions/mitkEventDescription.cpp Interactions/mitkEventMapper.cpp Interactions/mitkGlobalInteraction.cpp Interactions/mitkInteractor.cpp Interactions/mitkMouseModeSwitcher.cpp Interactions/mitkMouseMovePointSetInteractor.cpp Interactions/mitkMoveSurfaceInteractor.cpp Interactions/mitkNodeDepententPointSetInteractor.cpp Interactions/mitkPointSetInteractor.cpp Interactions/mitkPositionEvent.cpp Interactions/mitkPositionTracker.cpp Interactions/mitkState.cpp Interactions/mitkStateEvent.cpp Interactions/mitkStateMachine.cpp Interactions/mitkStateMachineFactory.cpp Interactions/mitkTransition.cpp Interactions/mitkWheelEvent.cpp Interactions/mitkKeyEvent.cpp Interactions/mitkVtkEventAdapter.cpp Interactions/mitkCrosshairPositionEvent.cpp IO/mitkBaseDataIOFactory.cpp IO/mitkDicomSeriesReader.cpp IO/mitkFileReader.cpp IO/mitkFileSeriesReader.cpp IO/mitkFileWriter.cpp #IO/mitkIpPicGet.c IO/mitkImageGenerator.cpp IO/mitkImageWriter.cpp IO/mitkImageWriterFactory.cpp IO/mitkItkImageFileIOFactory.cpp IO/mitkItkImageFileReader.cpp IO/mitkItkPictureWrite.cpp IO/mitkLookupTableProperty.cpp IO/mitkOperation.cpp #IO/mitkPicFileIOFactory.cpp #IO/mitkPicFileReader.cpp #IO/mitkPicFileWriter.cpp #IO/mitkPicHelper.cpp #IO/mitkPicVolumeTimeSeriesIOFactory.cpp #IO/mitkPicVolumeTimeSeriesReader.cpp IO/mitkPixelType.cpp IO/mitkPointSetIOFactory.cpp IO/mitkPointSetReader.cpp IO/mitkPointSetWriter.cpp IO/mitkPointSetWriterFactory.cpp IO/mitkRawImageFileReader.cpp IO/mitkStandardFileLocations.cpp IO/mitkSTLFileIOFactory.cpp IO/mitkSTLFileReader.cpp IO/mitkSurfaceVtkWriter.cpp IO/mitkSurfaceVtkWriterFactory.cpp IO/mitkVtiFileIOFactory.cpp IO/mitkVtiFileReader.cpp IO/mitkVtkImageIOFactory.cpp IO/mitkVtkImageReader.cpp IO/mitkVtkSurfaceIOFactory.cpp IO/mitkVtkSurfaceReader.cpp IO/vtkPointSetXMLParser.cpp IO/mitkLog.cpp Rendering/mitkBaseRenderer.cpp Rendering/mitkVtkMapper2D.cpp Rendering/mitkVtkMapper3D.cpp Rendering/mitkRenderWindowFrame.cpp Rendering/mitkGeometry2DDataMapper2D.cpp Rendering/mitkGeometry2DDataVtkMapper3D.cpp Rendering/mitkGLMapper2D.cpp Rendering/mitkGradientBackground.cpp Rendering/mitkManufacturerLogo.cpp Rendering/mitkMapper2D.cpp Rendering/mitkMapper3D.cpp Rendering/mitkMapper.cpp Rendering/mitkPointSetGLMapper2D.cpp Rendering/mitkPointSetVtkMapper3D.cpp Rendering/mitkPolyDataGLMapper2D.cpp Rendering/mitkSurfaceGLMapper2D.cpp Rendering/mitkSurfaceVtkMapper3D.cpp Rendering/mitkVolumeDataVtkMapper3D.cpp Rendering/mitkVtkPropRenderer.cpp Rendering/mitkVtkWidgetRendering.cpp Rendering/vtkMitkRectangleProp.cpp Rendering/vtkMitkRenderProp.cpp Rendering/mitkVtkEventProvider.cpp Rendering/mitkRenderWindow.cpp Rendering/mitkRenderWindowBase.cpp Rendering/mitkShaderRepository.cpp Rendering/mitkImageVtkMapper2D.cpp Rendering/vtkMitkThickSlicesFilter.cpp Rendering/vtkMitkApplyLevelWindowToRGBFilter.cpp Service/mitkAny.cpp Service/mitkAtomicInt.cpp Service/mitkCoreActivator.cpp Service/mitkCoreModuleContext.cpp Service/mitkModule.cpp Service/mitkModuleContext.cpp Service/mitkModuleEvent.cpp Service/mitkModuleInfo.cpp Service/mitkModulePrivate.cpp Service/mitkModuleRegistry.cpp Service/mitkModuleUtils.cpp Service/mitkModuleVersion.cpp Service/mitkLDAPExpr.cpp Service/mitkLDAPFilter.cpp Service/mitkServiceEvent.cpp Service/mitkServiceException.cpp Service/mitkServiceListenerEntry.cpp Service/mitkServiceListeners.cpp Service/mitkServiceProperties.cpp Service/mitkServiceReference.cpp Service/mitkServiceReferencePrivate.cpp Service/mitkServiceRegistration.cpp Service/mitkServiceRegistrationPrivate.cpp Service/mitkServiceRegistry.cpp )