diff --git a/Modules/DiffusionImaging/Rendering/mitkCompositeMapper.h b/Modules/DiffusionImaging/Rendering/mitkCompositeMapper.h index 43238b6f56..581b162ee8 100644 --- a/Modules/DiffusionImaging/Rendering/mitkCompositeMapper.h +++ b/Modules/DiffusionImaging/Rendering/mitkCompositeMapper.h @@ -1,169 +1,170 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef COMPOSITEMAPPER_H_HEADER_INCLUDED #define COMPOSITEMAPPER_H_HEADER_INCLUDED #include "mitkGLMapper2D.h" #include "mitkVtkMapper2D.h" #include "mitkQBallImage.h" #include "mitkImageVtkMapper2D.h" #include "mitkOdfVtkMapper2D.h" #include "mitkLevelWindowProperty.h" - +#include namespace mitk { class CopyImageMapper2D : public ImageVtkMapper2D { public: mitkClassMacro(CopyImageMapper2D,ImageVtkMapper2D); itkNewMacro(Self); friend class CompositeMapper; }; //##Documentation //## @brief Composite pattern for combination of different mappers //## @ingroup Mapper class CompositeMapper : public VtkMapper2D { public: - mitkClassMacro(CompositeMapper,VtkMapper2D); - itkNewMacro(Self); + mitkClassMacro(CompositeMapper,VtkMapper2D) + itkNewMacro(Self) virtual void MitkRenderOverlay(BaseRenderer* renderer) { m_ImgMapper->MitkRenderOverlay(renderer); m_OdfMapper->MitkRenderOverlay(renderer); } virtual void MitkRenderOpaqueGeometry(BaseRenderer* renderer) { m_ImgMapper->MitkRenderOpaqueGeometry(renderer); m_OdfMapper->MitkRenderOpaqueGeometry(renderer); if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 ) { renderer->Modified(); } } virtual void MitkRenderTranslucentGeometry(BaseRenderer* renderer) { m_ImgMapper->MitkRenderTranslucentGeometry(renderer); m_OdfMapper->MitkRenderTranslucentGeometry(renderer); } virtual void MitkRenderVolumetricGeometry(BaseRenderer* renderer) { m_ImgMapper->MitkRenderVolumetricGeometry(renderer); m_OdfMapper->MitkRenderVolumetricGeometry(renderer); } void SetDataNode(DataNode* node) { m_DataNode = node; m_ImgMapper->SetDataNode(node); m_OdfMapper->SetDataNode(node); } mitk::ImageVtkMapper2D::Pointer GetImageMapper() { ImageVtkMapper2D* retval = m_ImgMapper; return retval; } bool IsVtkBased() const { return m_OdfMapper->IsVtkBased(); } bool HasVtkProp( const vtkProp* prop, BaseRenderer* renderer ) { return m_OdfMapper->HasVtkProp(prop, renderer); } void ReleaseGraphicsResources(vtkWindow* window) { m_ImgMapper->ReleaseGraphicsResources(window); m_OdfMapper->ReleaseGraphicsResources(window); } static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false ) { mitk::OdfVtkMapper2D::SetDefaultProperties(node, renderer, overwrite); mitk::CopyImageMapper2D::SetDefaultProperties(node, renderer, overwrite); mitk::LevelWindow opaclevwin; opaclevwin.SetRangeMinMax(0,255); opaclevwin.SetWindowBounds(0,0); mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin); node->AddProperty( "opaclevelwindow", prop ); } bool IsLODEnabled( BaseRenderer * renderer ) const { return m_ImgMapper->IsLODEnabled(renderer) || m_OdfMapper->IsLODEnabled(renderer); } vtkProp* GetVtkProp(mitk::BaseRenderer* renderer) { vtkPropAssembly* assembly = vtkPropAssembly::New(); assembly->AddPart( m_OdfMapper->GetVtkProp(renderer)); assembly->AddPart( m_ImgMapper->GetVtkProp(renderer)); return assembly; } void SetGeometry3D(const mitk::Geometry3D* aGeometry3D) { m_ImgMapper->SetGeometry3D(aGeometry3D); m_OdfMapper->SetGeometry3D(aGeometry3D); } - protected: - - virtual void GenerateData() + virtual void Update(mitk::BaseRenderer* renderer) { - m_OdfMapper->GenerateData(); + m_OdfMapper->Update(renderer); + GenerateDataForRenderer(renderer); } + protected: + virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer) { m_ImgMapper->GenerateDataForRenderer(renderer); - if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) > 0 ) - { - m_OdfMapper->GenerateDataForRenderer(renderer); - } +// if( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) > 0 ) +// { +// m_OdfMapper->GenerateDataForRenderer(renderer); +// } } CompositeMapper(); virtual ~CompositeMapper(); private: mitk::OdfVtkMapper2D::Pointer m_OdfMapper; mitk::CopyImageMapper2D::Pointer m_ImgMapper; }; } // namespace mitk #endif /* COMPOSITEMAPPER_H_HEADER_INCLUDED */ diff --git a/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.h b/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.h index 895aaed175..307b5ab403 100644 --- a/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.h +++ b/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.h @@ -1,145 +1,145 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef ODFVTKMAPPER2D_H_HEADER_INCLUDED #define ODFVTKMAPPER2D_H_HEADER_INCLUDED #include "mitkVtkMapper2D.h" #include "vtkPropAssembly.h" #include "vtkAppendPolyData.h" #include "vtkActor.h" #include "vtkPolyDataMapper.h" #include "vtkPlane.h" #include "vtkCutter.h" #include "vtkClipPolyData.h" #include "vtkTransform.h" #include "vtkDataArrayTemplate.h" #include "vtkSmartPointer.h" #include "vtkOdfSource.h" #include "vtkThickPlane.h" -//#include "mitkTrackingCameraController.h" - namespace mitk { - //##Documentation - //## @brief Mapper for spherical object densitiy function representations - //## - template - class OdfVtkMapper2D : public VtkMapper2D - { +//##Documentation +//## @brief Mapper for spherical object densitiy function representations +//## +template +class OdfVtkMapper2D : public VtkMapper2D +{ struct OdfDisplayGeometry { - vtkFloatingPointType vp[ 3 ], vnormal[ 3 ]; - Vector3D normal; - double d, d1, d2; - mitk::Point3D M3D, L3D, O3D; - - vtkFloatingPointType vp_original[ 3 ], vnormal_original[ 3 ]; - mitk::Vector2D size, origin; - - bool Equals(OdfDisplayGeometry other) - { - return other.vp_original[0] == vp[0] && - other.vp_original[1] == vp[1] && - other.vp_original[2] == vp[2] && - other.vnormal_original[0] == vnormal[0] && - other.vnormal_original[1] == vnormal[1] && - other.vnormal_original[2] == vnormal[2] && - other.size[0] == size[0] && - other.size[1] == size[1] && - other.origin[0] == origin[0] && - other.origin[1] == origin[1]; - } + vtkFloatingPointType vp[ 3 ], vnormal[ 3 ]; + Vector3D normal; + double d, d1, d2; + mitk::Point3D M3D, L3D, O3D; + + vtkFloatingPointType vp_original[ 3 ], vnormal_original[ 3 ]; + mitk::Vector2D size, origin; + + bool Equals(OdfDisplayGeometry other) + { + return other.vp_original[0] == vp[0] && + other.vp_original[1] == vp[1] && + other.vp_original[2] == vp[2] && + other.vnormal_original[0] == vnormal[0] && + other.vnormal_original[1] == vnormal[1] && + other.vnormal_original[2] == vnormal[2] && + other.size[0] == size[0] && + other.size[1] == size[1] && + other.origin[0] == origin[0] && + other.origin[1] == origin[1]; + } }; - public: +public: - mitkClassMacro(OdfVtkMapper2D,VtkMapper2D); - itkNewMacro(Self); + mitkClassMacro(OdfVtkMapper2D,VtkMapper2D) + itkNewMacro(Self) virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer); - bool IsVisibleOdfs(mitk::BaseRenderer* renderer); - virtual void MitkRenderOverlay(mitk::BaseRenderer* renderer); virtual void MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer); virtual void MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer); - - virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer* /*renderer*/){}; + virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer* /*renderer*/){} OdfDisplayGeometry MeasureDisplayedGeometry(mitk::BaseRenderer* renderer); double GetMinImageSpacing( int index ); void ApplyPropertySettings(); - virtual void Slice(mitk::BaseRenderer* renderer, - OdfDisplayGeometry dispGeo); + virtual void Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo); virtual int GetIndex(mitk::BaseRenderer* renderer); - static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false); - - virtual void GenerateData(); + virtual void Update(mitk::BaseRenderer * renderer); virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer); - virtual bool IsLODEnabled( BaseRenderer * /*renderer*/ ) const { return true; } - protected: - OdfVtkMapper2D(); - - virtual ~OdfVtkMapper2D(); - - static void GlyphMethod(void *arg); - - bool IsPlaneRotated(mitk::BaseRenderer* renderer); - - private: + class LocalStorage : public mitk::Mapper::BaseLocalStorage + { + public: - std::vector m_PropAssemblies; - std::vector m_OdfsPlanes; - std::vector m_OdfsActors; - std::vector m_OdfsMappers; - vtkPolyData* m_TemplateOdf; + std::vector< vtkSmartPointer > m_PropAssemblies; + std::vector< vtkSmartPointer > m_OdfsPlanes; + std::vector< vtkSmartPointer > m_OdfsActors; + std::vector< vtkSmartPointer > m_OdfsMappers; + vtkSmartPointer< vtkPolyData > m_TemplateOdf; - static vtkSmartPointer m_OdfTransform; - static vtkSmartPointer m_OdfSource; - static float m_Scaling; - static int m_Normalization; - static int m_ScaleBy; - static float m_IndexParam1; - static float m_IndexParam2; + itk::TimeStamp m_LastUpdateTime; - int m_ShowMaxNumber; + /** \brief Default constructor of the local storage. */ + LocalStorage(); + /** \brief Default deconstructor of the local storage. */ + ~LocalStorage() + { + } + }; - std::vector m_Planes; - std::vector m_Cutters; +protected: - std::vector m_ThickPlanes1; - std::vector m_Clippers1; + OdfVtkMapper2D(); + virtual ~OdfVtkMapper2D(); - std::vector m_ThickPlanes2; - std::vector m_Clippers2; + static void GlyphMethod(void *arg); + bool IsPlaneRotated(mitk::BaseRenderer* renderer); - vtkImageData* m_VtkImage ; +private: mitk::Image* GetInput(); - OdfDisplayGeometry m_LastDisplayGeometry; - }; + static vtkSmartPointer m_OdfTransform; + static vtkSmartPointer m_OdfSource; + static float m_Scaling; + static int m_Normalization; + static int m_ScaleBy; + static float m_IndexParam1; + static float m_IndexParam2; + int m_ShowMaxNumber; + + std::vector< vtkSmartPointer > m_Planes; + std::vector< vtkSmartPointer > m_Cutters; + std::vector< vtkSmartPointer > m_ThickPlanes1; + std::vector< vtkSmartPointer > m_Clippers1; + std::vector< vtkSmartPointer > m_ThickPlanes2; + std::vector< vtkSmartPointer > m_Clippers2; + vtkImageData* m_VtkImage ; + OdfDisplayGeometry m_LastDisplayGeometry; + mitk::Mapper::LocalStorageHandler m_LSH; +}; } // namespace mitk #include "mitkOdfVtkMapper2D.txx" #endif /* ODFVTKMAPPER2D_H_HEADER_INCLUDED */ diff --git a/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.txx b/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.txx index 5cd3536fc2..8e515dd38b 100644 --- a/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.txx +++ b/Modules/DiffusionImaging/Rendering/mitkOdfVtkMapper2D.txx @@ -1,943 +1,882 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef __mitkOdfVtkMapper2D_txx__ #define __mitkOdfVtkMapper2D_txx__ #include "mitkOdfVtkMapper2D.h" #include "mitkDataNode.h" #include "mitkBaseRenderer.h" #include "mitkMatrixConvert.h" #include "mitkGeometry3D.h" #include "mitkOdfNormalizationMethodProperty.h" #include "mitkOdfScaleByProperty.h" #include "mitkProperties.h" #include "mitkTensorImage.h" #include "vtkSphereSource.h" #include "vtkPropCollection.h" #include "vtkMaskedGlyph3D.h" #include "vtkGlyph2D.h" #include "vtkGlyph3D.h" #include "vtkMaskedProgrammableGlyphFilter.h" #include "vtkImageData.h" #include "vtkLinearTransform.h" #include "vtkCamera.h" #include "vtkPointData.h" #include "vtkTransformPolyDataFilter.h" #include "vtkTransform.h" #include "vtkOdfSource.h" #include "vtkDoubleArray.h" #include "vtkLookupTable.h" #include "vtkProperty.h" #include "vtkPolyDataNormals.h" #include "vtkLight.h" #include "vtkLightCollection.h" #include "vtkMath.h" #include "vtkFloatArray.h" #include "vtkDelaunay2D.h" #include "vtkMapper.h" #include "vtkRenderer.h" #include "itkOrientationDistributionFunction.h" #include "itkFixedArray.h" #include #include "vtkOpenGLRenderer.h" #define _USE_MATH_DEFINES #include template vtkSmartPointer mitk::OdfVtkMapper2D::m_OdfTransform = vtkSmartPointer::New(); template vtkSmartPointer mitk::OdfVtkMapper2D::m_OdfSource = vtkSmartPointer::New(); template float mitk::OdfVtkMapper2D::m_Scaling; template int mitk::OdfVtkMapper2D::m_Normalization; template int mitk::OdfVtkMapper2D::m_ScaleBy; template float mitk::OdfVtkMapper2D::m_IndexParam1; template float mitk::OdfVtkMapper2D::m_IndexParam2; #define ODF_MAPPER_PI M_PI + template -mitk::OdfVtkMapper2D -::OdfVtkMapper2D() +mitk::OdfVtkMapper2D::LocalStorage::LocalStorage() { - m_PropAssemblies.push_back(vtkPropAssembly::New()); - m_PropAssemblies.push_back(vtkPropAssembly::New()); - m_PropAssemblies.push_back(vtkPropAssembly::New()); + m_PropAssemblies.push_back(vtkPropAssembly::New()); + m_PropAssemblies.push_back(vtkPropAssembly::New()); + m_PropAssemblies.push_back(vtkPropAssembly::New()); - m_OdfsPlanes.push_back(vtkAppendPolyData::New()); - m_OdfsPlanes.push_back(vtkAppendPolyData::New()); - m_OdfsPlanes.push_back(vtkAppendPolyData::New()); + m_OdfsPlanes.push_back(vtkAppendPolyData::New()); + m_OdfsPlanes.push_back(vtkAppendPolyData::New()); + m_OdfsPlanes.push_back(vtkAppendPolyData::New()); - m_OdfsPlanes[0]->AddInput(vtkPolyData::New()); - m_OdfsPlanes[1]->AddInput(vtkPolyData::New()); - m_OdfsPlanes[2]->AddInput(vtkPolyData::New()); + m_OdfsPlanes[0]->AddInput(vtkPolyData::New()); + m_OdfsPlanes[1]->AddInput(vtkPolyData::New()); + m_OdfsPlanes[2]->AddInput(vtkPolyData::New()); - m_OdfsActors.push_back(vtkActor::New()); - m_OdfsActors.push_back(vtkActor::New()); - m_OdfsActors.push_back(vtkActor::New()); + m_OdfsActors.push_back(vtkActor::New()); + m_OdfsActors.push_back(vtkActor::New()); + m_OdfsActors.push_back(vtkActor::New()); - m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud(); - m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud(); - m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud(); + m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud(); + m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud(); + m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud(); - m_OdfsMappers.push_back(vtkPolyDataMapper::New()); - m_OdfsMappers.push_back(vtkPolyDataMapper::New()); - m_OdfsMappers.push_back(vtkPolyDataMapper::New()); + m_OdfsMappers.push_back(vtkPolyDataMapper::New()); + m_OdfsMappers.push_back(vtkPolyDataMapper::New()); + m_OdfsMappers.push_back(vtkPolyDataMapper::New()); - vtkLookupTable *lut = vtkLookupTable::New(); + vtkLookupTable *lut = vtkLookupTable::New(); - m_OdfsMappers[0]->SetLookupTable(lut); - m_OdfsMappers[1]->SetLookupTable(lut); - m_OdfsMappers[2]->SetLookupTable(lut); + m_OdfsMappers[0]->SetLookupTable(lut); + m_OdfsMappers[1]->SetLookupTable(lut); + m_OdfsMappers[2]->SetLookupTable(lut); - m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]); - m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]); - m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]); + m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]); + m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]); + m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]); +} - m_Planes.push_back(vtkPlane::New()); - m_Planes.push_back(vtkPlane::New()); - m_Planes.push_back(vtkPlane::New()); +template +mitk::OdfVtkMapper2D +::OdfVtkMapper2D() +{ + + m_Planes.push_back(vtkPlane::New()); + m_Planes.push_back(vtkPlane::New()); + m_Planes.push_back(vtkPlane::New()); - m_Cutters.push_back(vtkCutter::New()); - m_Cutters.push_back(vtkCutter::New()); - m_Cutters.push_back(vtkCutter::New()); + m_Cutters.push_back(vtkCutter::New()); + m_Cutters.push_back(vtkCutter::New()); + m_Cutters.push_back(vtkCutter::New()); - m_Cutters[0]->SetCutFunction( m_Planes[0] ); - m_Cutters[0]->GenerateValues( 1, 0, 1 ); + m_Cutters[0]->SetCutFunction( m_Planes[0] ); + m_Cutters[0]->GenerateValues( 1, 0, 1 ); - m_Cutters[1]->SetCutFunction( m_Planes[1] ); - m_Cutters[1]->GenerateValues( 1, 0, 1 ); + m_Cutters[1]->SetCutFunction( m_Planes[1] ); + m_Cutters[1]->GenerateValues( 1, 0, 1 ); - m_Cutters[2]->SetCutFunction( m_Planes[2] ); - m_Cutters[2]->GenerateValues( 1, 0, 1 ); + m_Cutters[2]->SetCutFunction( m_Planes[2] ); + m_Cutters[2]->GenerateValues( 1, 0, 1 ); - // Windowing the cutted planes in direction 1 - m_ThickPlanes1.push_back(vtkThickPlane::New()); - m_ThickPlanes1.push_back(vtkThickPlane::New()); - m_ThickPlanes1.push_back(vtkThickPlane::New()); + // Windowing the cutted planes in direction 1 + m_ThickPlanes1.push_back(vtkThickPlane::New()); + m_ThickPlanes1.push_back(vtkThickPlane::New()); + m_ThickPlanes1.push_back(vtkThickPlane::New()); - m_Clippers1.push_back(vtkClipPolyData::New()); - m_Clippers1.push_back(vtkClipPolyData::New()); - m_Clippers1.push_back(vtkClipPolyData::New()); + m_Clippers1.push_back(vtkClipPolyData::New()); + m_Clippers1.push_back(vtkClipPolyData::New()); + m_Clippers1.push_back(vtkClipPolyData::New()); - m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] ); - m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] ); - m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] ); + m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] ); + m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] ); + m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] ); - // Windowing the cutted planes in direction 2 - m_ThickPlanes2.push_back(vtkThickPlane::New()); - m_ThickPlanes2.push_back(vtkThickPlane::New()); - m_ThickPlanes2.push_back(vtkThickPlane::New()); + // Windowing the cutted planes in direction 2 + m_ThickPlanes2.push_back(vtkThickPlane::New()); + m_ThickPlanes2.push_back(vtkThickPlane::New()); + m_ThickPlanes2.push_back(vtkThickPlane::New()); - m_Clippers2.push_back(vtkClipPolyData::New()); - m_Clippers2.push_back(vtkClipPolyData::New()); - m_Clippers2.push_back(vtkClipPolyData::New()); + m_Clippers2.push_back(vtkClipPolyData::New()); + m_Clippers2.push_back(vtkClipPolyData::New()); + m_Clippers2.push_back(vtkClipPolyData::New()); - m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] ); - m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] ); - m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] ); + m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] ); + m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] ); + m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] ); - m_ShowMaxNumber = 500; + m_ShowMaxNumber = 500; } template mitk::OdfVtkMapper2D ::~OdfVtkMapper2D() { - m_PropAssemblies[0]->Delete(); - m_PropAssemblies[1]->Delete(); - m_PropAssemblies[2]->Delete(); - m_OdfsPlanes[0]->Delete(); - m_OdfsPlanes[1]->Delete(); - m_OdfsPlanes[2]->Delete(); - m_OdfsActors[0]->Delete(); - m_OdfsActors[1]->Delete(); - m_OdfsActors[2]->Delete(); - m_OdfsMappers[0]->Delete(); - m_OdfsMappers[1]->Delete(); - m_OdfsMappers[2]->Delete(); - m_Planes[0]->Delete(); - m_Planes[1]->Delete(); - m_Planes[2]->Delete(); - m_Cutters[0]->Delete(); - m_Cutters[1]->Delete(); - m_Cutters[2]->Delete(); - m_ThickPlanes1[0]->Delete(); - m_ThickPlanes1[1]->Delete(); - m_ThickPlanes1[2]->Delete(); - m_ThickPlanes2[0]->Delete(); - m_ThickPlanes2[1]->Delete(); - m_ThickPlanes2[2]->Delete(); - m_Clippers1[0]->Delete(); - m_Clippers1[1]->Delete(); - m_Clippers1[2]->Delete(); - m_Clippers2[0]->Delete(); - m_Clippers2[1]->Delete(); - m_Clippers2[2]->Delete(); + } template mitk::Image* mitk::OdfVtkMapper2D ::GetInput() { - return static_cast ( m_DataNode->GetData() ); + return static_cast ( m_DataNode->GetData() ); } template vtkProp* mitk::OdfVtkMapper2D ::GetVtkProp(mitk::BaseRenderer* renderer) { - return m_PropAssemblies[GetIndex(renderer)]; + LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer); + return localStorage->m_PropAssemblies[GetIndex(renderer)]; } template int mitk::OdfVtkMapper2D ::GetIndex(mitk::BaseRenderer* renderer) { - if(!strcmp(renderer->GetName(),"stdmulti.widget1")) - return 0; + if(!strcmp(renderer->GetName(),"stdmulti.widget1")) + return 0; - if(!strcmp(renderer->GetName(),"stdmulti.widget2")) - return 1; + if(!strcmp(renderer->GetName(),"stdmulti.widget2")) + return 1; - if(!strcmp(renderer->GetName(),"stdmulti.widget3")) - return 2; + if(!strcmp(renderer->GetName(),"stdmulti.widget3")) + return 2; - return 0; + return 0; } template void mitk::OdfVtkMapper2D ::GlyphMethod(void *arg) { - vtkMaskedProgrammableGlyphFilter - *pfilter=(vtkMaskedProgrammableGlyphFilter*)arg; - - double point[3]; - double debugpoint[3]; - pfilter->GetPoint(point); - pfilter->GetPoint(debugpoint); - - itk::Point p(point); - Vector3D spacing = pfilter->GetGeometry()->GetSpacing(); - p[0] /= spacing[0]; - p[1] /= spacing[1]; - p[2] /= spacing[2]; - - mitk::Point3D p2; - pfilter->GetGeometry()->IndexToWorld( p, p2 ); - point[0] = p2[0]; - point[1] = p2[1]; - point[2] = p2[2]; - - vtkPointData* data = pfilter->GetPointData(); - vtkDataArray* odfvals = data->GetArray("vector"); - vtkIdType id = pfilter->GetPointId(); - m_OdfTransform->Identity(); - m_OdfTransform->Translate(point[0],point[1],point[2]); - - typedef itk::OrientationDistributionFunction OdfType; - OdfType odf; - - if(odfvals->GetNumberOfComponents()==6) - { - float tensorelems[6] = { - (float)odfvals->GetComponent(id,0), - (float)odfvals->GetComponent(id,1), - (float)odfvals->GetComponent(id,2), - (float)odfvals->GetComponent(id,3), - (float)odfvals->GetComponent(id,4), - (float)odfvals->GetComponent(id,5), - }; - itk::DiffusionTensor3D tensor(tensorelems); - odf.InitFromTensor(tensor); - } - else - { - for(int i=0; iGetComponent(id,i); - } - - switch(m_ScaleBy) - { - case ODFSB_NONE: - m_OdfSource->SetScale(m_Scaling); - break; - case ODFSB_GFA: - m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2)); - break; - case ODFSB_PC: - m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0)); - break; - } - - m_OdfSource->SetNormalization(m_Normalization); - m_OdfSource->SetOdf(odf); - m_OdfSource->Modified(); + vtkMaskedProgrammableGlyphFilter* pfilter=(vtkMaskedProgrammableGlyphFilter*)arg; + + double point[3]; + double debugpoint[3]; + pfilter->GetPoint(point); + pfilter->GetPoint(debugpoint); + + itk::Point p(point); + Vector3D spacing = pfilter->GetGeometry()->GetSpacing(); + p[0] /= spacing[0]; + p[1] /= spacing[1]; + p[2] /= spacing[2]; + + mitk::Point3D p2; + pfilter->GetGeometry()->IndexToWorld( p, p2 ); + point[0] = p2[0]; + point[1] = p2[1]; + point[2] = p2[2]; + + vtkPointData* data = pfilter->GetPointData(); + vtkDataArray* odfvals = data->GetArray("vector"); + vtkIdType id = pfilter->GetPointId(); + m_OdfTransform->Identity(); + m_OdfTransform->Translate(point[0],point[1],point[2]); + + typedef itk::OrientationDistributionFunction OdfType; + OdfType odf; + + if(odfvals->GetNumberOfComponents()==6) + { + float tensorelems[6] = { + (float)odfvals->GetComponent(id,0), + (float)odfvals->GetComponent(id,1), + (float)odfvals->GetComponent(id,2), + (float)odfvals->GetComponent(id,3), + (float)odfvals->GetComponent(id,4), + (float)odfvals->GetComponent(id,5), + }; + itk::DiffusionTensor3D tensor(tensorelems); + odf.InitFromTensor(tensor); + } + else + { + for(int i=0; iGetComponent(id,i); + } + + switch(m_ScaleBy) + { + case ODFSB_NONE: + m_OdfSource->SetScale(m_Scaling); + break; + case ODFSB_GFA: + m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2)); + break; + case ODFSB_PC: + m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0)); + break; + } + + m_OdfSource->SetNormalization(m_Normalization); + m_OdfSource->SetOdf(odf); + m_OdfSource->Modified(); } template typename mitk::OdfVtkMapper2D::OdfDisplayGeometry mitk::OdfVtkMapper2D ::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer) { - Geometry2D::ConstPointer worldGeometry = - renderer->GetCurrentWorldGeometry2D(); - PlaneGeometry::ConstPointer worldPlaneGeometry = - dynamic_cast( worldGeometry.GetPointer() ); - - // set up the cutter orientation according to the current geometry of - // the renderers plane - vtkFloatingPointType vp[ 3 ], vnormal[ 3 ]; - Point3D point = worldPlaneGeometry->GetOrigin(); - Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize(); - vnl2vtk( point.Get_vnl_vector(), vp ); - vnl2vtk( normal.Get_vnl_vector(), vnormal ); - - mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry(); - mitk::Vector2D size = dispGeometry->GetSizeInMM(); - mitk::Vector2D origin = dispGeometry->GetOriginInMM(); - - // - // |------O------| - // | d2 | - // L d1 M | - // | | - // |-------------| - // - - mitk::Vector2D M; - mitk::Vector2D L; - mitk::Vector2D O; - - M[0] = origin[0] + size[0]/2; - M[1] = origin[1] + size[1]/2; - - L[0] = origin[0]; - L[1] = origin[1] + size[1]/2; - - O[0] = origin[0] + size[0]/2; - O[1] = origin[1] + size[1]; - - mitk::Point2D point1; - point1[0] = M[0]; point1[1] = M[1]; - mitk::Point3D M3D; - dispGeometry->Map(point1, M3D); - - point1[0] = L[0]; point1[1] = L[1]; - mitk::Point3D L3D; - dispGeometry->Map(point1, L3D); - - point1[0] = O[0]; point1[1] = O[1]; - mitk::Point3D O3D; - dispGeometry->Map(point1, O3D); - - double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0]) - + (M3D[1]-L3D[1])*(M3D[1]-L3D[1]) - + (M3D[2]-L3D[2])*(M3D[2]-L3D[2])); - double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0]) - + (M3D[1]-O3D[1])*(M3D[1]-O3D[1]) - + (M3D[2]-O3D[2])*(M3D[2]-O3D[2])); - double d = d1>d2 ? d1 : d2; - d = d2; - - OdfDisplayGeometry retval; - retval.vp[0] = vp[0]; - retval.vp[1] = vp[1]; - retval.vp[2] = vp[2]; - retval.vnormal[0] = vnormal[0]; - retval.vnormal[1] = vnormal[1]; - retval.vnormal[2] = vnormal[2]; - retval.normal[0] = normal[0]; - retval.normal[1] = normal[1]; - retval.normal[2] = normal[2]; - retval.d = d; - retval.d1 = d1; - retval.d2 = d2; - retval.M3D[0] = M3D[0]; - retval.M3D[1] = M3D[1]; - retval.M3D[2] = M3D[2]; - retval.L3D[0] = L3D[0]; - retval.L3D[1] = L3D[1]; - retval.L3D[2] = L3D[2]; - retval.O3D[0] = O3D[0]; - retval.O3D[1] = O3D[1]; - retval.O3D[2] = O3D[2]; - - retval.vp_original[0] = vp[0]; - retval.vp_original[1] = vp[1]; - retval.vp_original[2] = vp[2]; - retval.vnormal_original[0] = vnormal[0]; - retval.vnormal_original[1] = vnormal[1]; - retval.vnormal_original[2] = vnormal[2]; - retval.size[0] = size[0]; - retval.size[1] = size[1]; - retval.origin[0] = origin[0]; - retval.origin[1] = origin[1]; - - return retval; - + Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D(); + PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast( worldGeometry.GetPointer() ); + + // set up the cutter orientation according to the current geometry of + // the renderers plane + vtkFloatingPointType vp[ 3 ], vnormal[ 3 ]; + Point3D point = worldPlaneGeometry->GetOrigin(); + Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize(); + vnl2vtk( point.Get_vnl_vector(), vp ); + vnl2vtk( normal.Get_vnl_vector(), vnormal ); + + mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry(); + mitk::Vector2D size = dispGeometry->GetSizeInMM(); + mitk::Vector2D origin = dispGeometry->GetOriginInMM(); + + // + // |------O------| + // | d2 | + // L d1 M | + // | | + // |-------------| + // + + mitk::Vector2D M; + mitk::Vector2D L; + mitk::Vector2D O; + + M[0] = origin[0] + size[0]/2; + M[1] = origin[1] + size[1]/2; + + L[0] = origin[0]; + L[1] = origin[1] + size[1]/2; + + O[0] = origin[0] + size[0]/2; + O[1] = origin[1] + size[1]; + + mitk::Point2D point1; + point1[0] = M[0]; point1[1] = M[1]; + mitk::Point3D M3D; + dispGeometry->Map(point1, M3D); + + point1[0] = L[0]; point1[1] = L[1]; + mitk::Point3D L3D; + dispGeometry->Map(point1, L3D); + + point1[0] = O[0]; point1[1] = O[1]; + mitk::Point3D O3D; + dispGeometry->Map(point1, O3D); + + double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0]) + + (M3D[1]-L3D[1])*(M3D[1]-L3D[1]) + + (M3D[2]-L3D[2])*(M3D[2]-L3D[2])); + double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0]) + + (M3D[1]-O3D[1])*(M3D[1]-O3D[1]) + + (M3D[2]-O3D[2])*(M3D[2]-O3D[2])); + double d = d1>d2 ? d1 : d2; + d = d2; + + OdfDisplayGeometry retval; + retval.vp[0] = vp[0]; + retval.vp[1] = vp[1]; + retval.vp[2] = vp[2]; + retval.vnormal[0] = vnormal[0]; + retval.vnormal[1] = vnormal[1]; + retval.vnormal[2] = vnormal[2]; + retval.normal[0] = normal[0]; + retval.normal[1] = normal[1]; + retval.normal[2] = normal[2]; + retval.d = d; + retval.d1 = d1; + retval.d2 = d2; + retval.M3D[0] = M3D[0]; + retval.M3D[1] = M3D[1]; + retval.M3D[2] = M3D[2]; + retval.L3D[0] = L3D[0]; + retval.L3D[1] = L3D[1]; + retval.L3D[2] = L3D[2]; + retval.O3D[0] = O3D[0]; + retval.O3D[1] = O3D[1]; + retval.O3D[2] = O3D[2]; + + retval.vp_original[0] = vp[0]; + retval.vp_original[1] = vp[1]; + retval.vp_original[2] = vp[2]; + retval.vnormal_original[0] = vnormal[0]; + retval.vnormal_original[1] = vnormal[1]; + retval.vnormal_original[2] = vnormal[2]; + retval.size[0] = size[0]; + retval.size[1] = size[1]; + retval.origin[0] = origin[0]; + retval.origin[1] = origin[1]; + + return retval; } template void mitk::OdfVtkMapper2D ::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo) { - vtkLinearTransform * vtktransform = - this->GetDataNode()->GetVtkTransform(this->GetTimestep()); - - int index = GetIndex(renderer); - - vtkTransform* inversetransform = vtkTransform::New(); - inversetransform->Identity(); - inversetransform->Concatenate(vtktransform->GetLinearInverse()); - double myscale[3]; - ((vtkTransform*)vtktransform)->GetScale(myscale); - inversetransform->PostMultiply(); - inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]); - inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp ); - inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal ); - - // vtk works in axis align coords - // thus the normal also must be axis align, since - // we do not allow arbitrary cutting through volume - // - // vnormal should already be axis align, but in order - // to get rid of precision effects, we set the two smaller - // components to zero here - int dims[3]; - m_VtkImage->GetDimensions(dims); - double spac[3]; - m_VtkImage->GetSpacing(spac); - if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1]) - && fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) ) - { - if(fabs(dispGeo.vp[0]/spac[0]) < 0.4) - dispGeo.vp[0] = 0.4*spac[0]; - if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4) - dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0]; - dispGeo.vnormal[1] = 0; - dispGeo.vnormal[2] = 0; - } - - if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) ) - { - if(fabs(dispGeo.vp[1]/spac[1]) < 0.4) - dispGeo.vp[1] = 0.4*spac[1]; - if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4) - dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1]; - dispGeo.vnormal[0] = 0; - dispGeo.vnormal[2] = 0; - } - - if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) ) - { - if(fabs(dispGeo.vp[2]/spac[2]) < 0.4) - dispGeo.vp[2] = 0.4*spac[2]; - if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4) - dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2]; - dispGeo.vnormal[0] = 0; - dispGeo.vnormal[1] = 0; - } - - - m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL ); - m_Planes[index]->SetOrigin( dispGeo.vp ); - m_Planes[index]->SetNormal( dispGeo.vnormal ); - - vtkPoints* points = NULL; - vtkPoints* tmppoints = NULL; - vtkPolyData* polydata = NULL; - vtkFloatArray* pointdata = NULL; - vtkDelaunay2D *delaunay = NULL; - vtkPolyData* cuttedPlane = NULL; - - // the cutter only works if we do not have a 2D-image - // or if we have a 2D-image and want to see the whole image. - // - // for side views of 2D-images, we need some special treatment - if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) || - (dims[1] == 1 && dispGeo.vnormal[1] != 0) || - (dims[2] == 1 && dispGeo.vnormal[2] != 0) )) - { - m_Cutters[index]->SetCutFunction( m_Planes[index] ); - m_Cutters[index]->SetInput( m_VtkImage ); - m_Cutters[index]->Update(); - cuttedPlane = m_Cutters[index]->GetOutput(); - } - else - { - // cutting of a 2D-Volume does not work, - // so we have to build up our own polydata object - cuttedPlane = vtkPolyData::New(); - points = vtkPoints::New(); - points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints()); - for(int i=0; iGetNumberOfPoints(); i++) - { - points->SetPoint(i, m_VtkImage->GetPoint(i)); - } - cuttedPlane->SetPoints(points); - - pointdata = vtkFloatArray::New(); - int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents(); - pointdata->SetNumberOfComponents(comps); - int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples(); - pointdata->SetNumberOfTuples(tuples); - for(int i=0; iSetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i)); - pointdata->SetName( "vector" ); - cuttedPlane->GetPointData()->AddArray(pointdata); - - int nZero1, nZero2; - if(dims[0]==1) - { - nZero1 = 1; nZero2 = 2; - } - else if(dims[1]==1) - { - nZero1 = 0; nZero2 = 2; - } - else - { - nZero1 = 0; nZero2 = 1; - } + LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer); - tmppoints = vtkPoints::New(); - for(int j=0; jGetNumberOfPoints(); j++){ - double pt[3]; - m_VtkImage->GetPoint(j,pt); - tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0); - } + vtkLinearTransform * vtktransform = + this->GetDataNode()->GetVtkTransform(this->GetTimestep()); + + int index = GetIndex(renderer); - polydata = vtkPolyData::New(); - polydata->SetPoints( tmppoints ); - delaunay = vtkDelaunay2D::New(); - delaunay->SetInput( polydata ); - delaunay->Update(); - vtkCellArray* polys = delaunay->GetOutput()->GetPolys(); - cuttedPlane->SetPolys(polys); - } - - if(cuttedPlane->GetNumberOfPoints()) - { - // WINDOWING HERE - inversetransform = vtkTransform::New(); + vtkSmartPointer inversetransform = vtkTransform::New(); inversetransform->Identity(); inversetransform->Concatenate(vtktransform->GetLinearInverse()); double myscale[3]; ((vtkTransform*)vtktransform)->GetScale(myscale); inversetransform->PostMultiply(); inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]); - - dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0]; - dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1]; - dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2]; - vtkMath::Normalize(dispGeo.vnormal); - dispGeo.vp[0] = dispGeo.M3D[0]; - dispGeo.vp[1] = dispGeo.M3D[1]; - dispGeo.vp[2] = dispGeo.M3D[2]; - - inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp ); - inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal ); - - m_ThickPlanes1[index]->count = 0; - m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL ); - m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp ); - m_ThickPlanes1[index]->SetThickness(dispGeo.d2); - m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] ); - m_Clippers1[index]->SetInput( cuttedPlane ); - m_Clippers1[index]->SetInsideOut(1); - m_Clippers1[index]->Update(); - - dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0]; - dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1]; - dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2]; - vtkMath::Normalize(dispGeo.vnormal); - dispGeo.vp[0] = dispGeo.M3D[0]; - dispGeo.vp[1] = dispGeo.M3D[1]; - dispGeo.vp[2] = dispGeo.M3D[2]; - inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp ); inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal ); - m_ThickPlanes2[index]->count = 0; - m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL ); - m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp ); - m_ThickPlanes2[index]->SetThickness(dispGeo.d1); - m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] ); - m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() ); - m_Clippers2[index]->SetInsideOut(1); - m_Clippers2[index]->Update(); + // vtk works in axis align coords + // thus the normal also must be axis align, since + // we do not allow arbitrary cutting through volume + // + // vnormal should already be axis align, but in order + // to get rid of precision effects, we set the two smaller + // components to zero here + int dims[3]; + m_VtkImage->GetDimensions(dims); + double spac[3]; + m_VtkImage->GetSpacing(spac); + if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1]) + && fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) ) + { + if(fabs(dispGeo.vp[0]/spac[0]) < 0.4) + dispGeo.vp[0] = 0.4*spac[0]; + if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4) + dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0]; + dispGeo.vnormal[1] = 0; + dispGeo.vnormal[2] = 0; + } - cuttedPlane = m_Clippers2[index]->GetOutput (); + if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) ) + { + if(fabs(dispGeo.vp[1]/spac[1]) < 0.4) + dispGeo.vp[1] = 0.4*spac[1]; + if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4) + dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1]; + dispGeo.vnormal[0] = 0; + dispGeo.vnormal[2] = 0; + } - if(cuttedPlane->GetNumberOfPoints()) + if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) ) { - m_OdfsPlanes[index]->RemoveAllInputs(); - - vtkPolyDataNormals* normals = vtkPolyDataNormals::New(); - normals->SetInputConnection( m_OdfSource->GetOutputPort() ); - normals->SplittingOff(); - normals->ConsistencyOff(); - normals->AutoOrientNormalsOff(); - normals->ComputePointNormalsOn(); - normals->ComputeCellNormalsOff(); - normals->FlipNormalsOff(); - normals->NonManifoldTraversalOff(); - - vtkTransformPolyDataFilter* trans = vtkTransformPolyDataFilter::New(); - trans->SetInputConnection( normals->GetOutputPort() ); - trans->SetTransform(m_OdfTransform); - - vtkMaskedProgrammableGlyphFilter* glyphGenerator = vtkMaskedProgrammableGlyphFilter::New(); - glyphGenerator->SetMaximumNumberOfPoints(m_ShowMaxNumber); - glyphGenerator->SetRandomMode(0); - glyphGenerator->SetUseMaskPoints(1); - glyphGenerator->SetSource( trans->GetOutput() ); - glyphGenerator->SetInput(cuttedPlane); - glyphGenerator->SetColorModeToColorBySource(); - glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector"); - glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry()); - glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator); - try - { - glyphGenerator->Update(); - } - catch( itk::ExceptionObject& err ) - { - std::cout << err << std::endl; - } - - m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput()); - - trans->Delete(); - glyphGenerator->Delete(); - normals->Delete(); - - m_OdfsPlanes[index]->Update(); + if(fabs(dispGeo.vp[2]/spac[2]) < 0.4) + dispGeo.vp[2] = 0.4*spac[2]; + if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4) + dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2]; + dispGeo.vnormal[0] = 0; + dispGeo.vnormal[1] = 0; } - } - m_PropAssemblies[index]->VisibilityOn(); - if(m_PropAssemblies[index]->GetParts()->IsItemPresent(m_OdfsActors[index])) - m_PropAssemblies[index]->RemovePart(m_OdfsActors[index]); - m_OdfsMappers[index]->SetInput(m_OdfsPlanes[index]->GetOutput()); - m_PropAssemblies[index]->AddPart(m_OdfsActors[index]); - if(inversetransform) inversetransform->Delete(); - if(points) points->Delete(); - if(pointdata) pointdata->Delete(); - if(tmppoints) tmppoints->Delete(); - if(polydata) polydata->Delete(); - if(delaunay) delaunay->Delete(); + m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL ); + m_Planes[index]->SetOrigin( dispGeo.vp ); + m_Planes[index]->SetNormal( dispGeo.vnormal ); + + vtkSmartPointer points; + vtkSmartPointer tmppoints; + vtkSmartPointer polydata; + vtkSmartPointer pointdata; + vtkSmartPointer delaunay; + vtkSmartPointer cuttedPlane; + + // the cutter only works if we do not have a 2D-image + // or if we have a 2D-image and want to see the whole image. + // + // for side views of 2D-images, we need some special treatment + if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) || + (dims[1] == 1 && dispGeo.vnormal[1] != 0) || + (dims[2] == 1 && dispGeo.vnormal[2] != 0) )) + { + m_Cutters[index]->SetCutFunction( m_Planes[index] ); + m_Cutters[index]->SetInput( m_VtkImage ); + m_Cutters[index]->Update(); + cuttedPlane = m_Cutters[index]->GetOutput(); + } + else + { + // cutting of a 2D-Volume does not work, + // so we have to build up our own polydata object + cuttedPlane = vtkPolyData::New(); + points = vtkPoints::New(); + points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints()); + for(int i=0; iGetNumberOfPoints(); i++) + { + points->SetPoint(i, m_VtkImage->GetPoint(i)); + } + cuttedPlane->SetPoints(points); + + pointdata = vtkFloatArray::New(); + int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents(); + pointdata->SetNumberOfComponents(comps); + int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples(); + pointdata->SetNumberOfTuples(tuples); + for(int i=0; iSetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i)); + pointdata->SetName( "vector" ); + cuttedPlane->GetPointData()->AddArray(pointdata); + + int nZero1, nZero2; + if(dims[0]==1) + { + nZero1 = 1; nZero2 = 2; + } + else if(dims[1]==1) + { + nZero1 = 0; nZero2 = 2; + } + else + { + nZero1 = 0; nZero2 = 1; + } + + tmppoints = vtkPoints::New(); + for(int j=0; jGetNumberOfPoints(); j++){ + double pt[3]; + m_VtkImage->GetPoint(j,pt); + tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0); + } + + polydata = vtkPolyData::New(); + polydata->SetPoints( tmppoints ); + delaunay = vtkDelaunay2D::New(); + delaunay->SetInput( polydata ); + delaunay->Update(); + vtkCellArray* polys = delaunay->GetOutput()->GetPolys(); + cuttedPlane->SetPolys(polys); + } + if(cuttedPlane->GetNumberOfPoints()) + { + // WINDOWING HERE + inversetransform = vtkTransform::New(); + inversetransform->Identity(); + inversetransform->Concatenate(vtktransform->GetLinearInverse()); + double myscale[3]; + ((vtkTransform*)vtktransform)->GetScale(myscale); + inversetransform->PostMultiply(); + inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]); + + dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0]; + dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1]; + dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2]; + vtkMath::Normalize(dispGeo.vnormal); + dispGeo.vp[0] = dispGeo.M3D[0]; + dispGeo.vp[1] = dispGeo.M3D[1]; + dispGeo.vp[2] = dispGeo.M3D[2]; + + inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp ); + inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal ); + + m_ThickPlanes1[index]->count = 0; + m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL ); + m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp ); + m_ThickPlanes1[index]->SetThickness(dispGeo.d2); + m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] ); + m_Clippers1[index]->SetInput( cuttedPlane ); + m_Clippers1[index]->SetInsideOut(1); + m_Clippers1[index]->Update(); + + dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0]; + dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1]; + dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2]; + vtkMath::Normalize(dispGeo.vnormal); + dispGeo.vp[0] = dispGeo.M3D[0]; + dispGeo.vp[1] = dispGeo.M3D[1]; + dispGeo.vp[2] = dispGeo.M3D[2]; + + inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp ); + inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal ); + + m_ThickPlanes2[index]->count = 0; + m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL ); + m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp ); + m_ThickPlanes2[index]->SetThickness(dispGeo.d1); + m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] ); + m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() ); + m_Clippers2[index]->SetInsideOut(1); + m_Clippers2[index]->Update(); + + cuttedPlane = m_Clippers2[index]->GetOutput (); + + if(cuttedPlane->GetNumberOfPoints()) + { + localStorage->m_OdfsPlanes[index]->RemoveAllInputs(); + + vtkSmartPointer normals = vtkPolyDataNormals::New(); + normals->SetInputConnection( m_OdfSource->GetOutputPort() ); + normals->SplittingOff(); + normals->ConsistencyOff(); + normals->AutoOrientNormalsOff(); + normals->ComputePointNormalsOn(); + normals->ComputeCellNormalsOff(); + normals->FlipNormalsOff(); + normals->NonManifoldTraversalOff(); + + vtkSmartPointer trans = vtkTransformPolyDataFilter::New(); + trans->SetInputConnection( normals->GetOutputPort() ); + trans->SetTransform(m_OdfTransform); + + vtkSmartPointer glyphGenerator = vtkMaskedProgrammableGlyphFilter::New(); + glyphGenerator->SetMaximumNumberOfPoints(std::min(m_ShowMaxNumber,(int)cuttedPlane->GetNumberOfPoints())); + glyphGenerator->SetRandomMode(0); + glyphGenerator->SetUseMaskPoints(1); + glyphGenerator->SetSource( trans->GetOutput() ); + glyphGenerator->SetInput(cuttedPlane); + glyphGenerator->SetColorModeToColorBySource(); + glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector"); + glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry()); + glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator); + + try + { + glyphGenerator->Update(); + } + catch( itk::ExceptionObject& err ) + { + std::cout << err << std::endl; + } + + localStorage->m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput()); + + localStorage->m_OdfsPlanes[index]->Update(); + } + } + localStorage->m_PropAssemblies[index]->VisibilityOn(); + if(localStorage->m_PropAssemblies[index]->GetParts()->IsItemPresent(localStorage->m_OdfsActors[index])) + localStorage->m_PropAssemblies[index]->RemovePart(localStorage->m_OdfsActors[index]); + localStorage->m_OdfsMappers[index]->SetInput(localStorage->m_OdfsPlanes[index]->GetOutput()); + localStorage->m_PropAssemblies[index]->AddPart(localStorage->m_OdfsActors[index]); } template bool mitk::OdfVtkMapper2D ::IsVisibleOdfs(mitk::BaseRenderer* renderer) { - if(this->IsPlaneRotated(renderer)) - return false; - bool retval = false; - switch(GetIndex(renderer)) - { - case 0: - retval = this->IsVisible(renderer, "VisibleOdfs_T"); - break; - case 1: - retval = this->IsVisible(renderer, "VisibleOdfs_S"); - break; - case 2: - retval = this->IsVisible(renderer, "VisibleOdfs_C"); - break; - } - - return retval; + mitk::Image::Pointer input = const_cast(this->GetInput()); + const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry(); + if(inputTimeGeometry==NULL || inputTimeGeometry->GetTimeSteps()==0 || !inputTimeGeometry->IsValidTime(this->GetTimestep())) + return false; + + if(this->IsPlaneRotated(renderer)) + return false; + + bool retval = false; + switch(GetIndex(renderer)) + { + case 0: + retval = this->IsVisible(renderer, "VisibleOdfs_T"); + break; + case 1: + retval = this->IsVisible(renderer, "VisibleOdfs_S"); + break; + case 2: + retval = this->IsVisible(renderer, "VisibleOdfs_C"); + break; + } + + return retval; } template void mitk::OdfVtkMapper2D ::MitkRenderOverlay(mitk::BaseRenderer* renderer) { - if ( this->IsVisibleOdfs(renderer)==false ) - return; + if ( this->IsVisibleOdfs(renderer)==false ) + return; - if ( this->GetVtkProp(renderer)->GetVisibility() ) - { - this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); - } + if ( this->GetVtkProp(renderer)->GetVisibility() ) + this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); } template void mitk::OdfVtkMapper2D ::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer) { - if ( this->IsVisibleOdfs( renderer )==false ) - return; + if ( this->IsVisibleOdfs( renderer )==false ) + return; - if ( this->GetVtkProp(renderer)->GetVisibility() ) - { - // adapt cam pos - OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer); - - this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() ); - } + if ( this->GetVtkProp(renderer)->GetVisibility() ) + { + // adapt cam pos + OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer); + this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() ); + } } template void mitk::OdfVtkMapper2D ::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer) { - if ( this->IsVisibleOdfs(renderer)==false ) - return; + if ( this->IsVisibleOdfs(renderer)==false ) + return; - if ( this->GetVtkProp(renderer)->GetVisibility() ) - this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer()); + if ( this->GetVtkProp(renderer)->GetVisibility() ) + this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer()); } template -void mitk::OdfVtkMapper2D -::GenerateData() +void mitk::OdfVtkMapper2D +::Update(mitk::BaseRenderer* renderer) { - mitk::Image::Pointer input = const_cast( this->GetInput() ); - if ( input.IsNull() ) return ; - - std::string classname("TensorImage"); - if(classname.compare(input->GetNameOfClass())==0) - { - m_VtkImage = dynamic_cast( this->GetInput() )->GetNonRgbVtkImageData(); - } - - std::string qclassname("QBallImage"); - if(qclassname.compare(input->GetNameOfClass())==0) - { - m_VtkImage = dynamic_cast( this->GetInput() )->GetNonRgbVtkImageData(); - } - - if( m_VtkImage ) - { - // make sure, that we have point data with more than 1 component (as vectors) - vtkPointData* pointData = m_VtkImage->GetPointData(); - if ( pointData == NULL ) + if ( !this->IsVisible( renderer ) ) + return; + + mitk::Image::Pointer input = const_cast( this->GetInput() ); + if ( input.IsNull() ) return ; + + std::string classname("TensorImage"); + if(classname.compare(input->GetNameOfClass())==0) + m_VtkImage = dynamic_cast( this->GetInput() )->GetNonRgbVtkImageData(); + + std::string qclassname("QBallImage"); + if(qclassname.compare(input->GetNameOfClass())==0) + m_VtkImage = dynamic_cast( this->GetInput() )->GetNonRgbVtkImageData(); + + if( m_VtkImage ) { - itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" ); - return ; + // make sure, that we have point data with more than 1 component (as vectors) + vtkPointData* pointData = m_VtkImage->GetPointData(); + if ( pointData == NULL ) + { + itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" ); + return ; + } + if ( pointData->GetNumberOfArrays() == 0 ) + { + itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" ); + return ; + } + else if ( pointData->GetArray(0)->GetNumberOfComponents() != N + && pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/) + { + itkWarningMacro( << "number of components != number of directions in ODF!" ); + return; + } + else if ( pointData->GetArrayName( 0 ) == NULL ) + { + m_VtkImage->GetPointData()->GetArray(0)->SetName("vector"); + } + + GenerateDataForRenderer(renderer); } - if ( pointData->GetNumberOfArrays() == 0 ) + else { - itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" ); - return ; + itkWarningMacro( << "m_VtkImage is NULL!" ); + return ; } - else if ( pointData->GetArray(0)->GetNumberOfComponents() != N - && pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/) +} + +template +void mitk::OdfVtkMapper2D +::GenerateDataForRenderer( mitk::BaseRenderer *renderer ) +{ + LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer); + + OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer); + + + if ( (localStorage->m_LastUpdateTime >= m_DataNode->GetMTime()) //was the node modified? + && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList()->GetMTime()) //was a property modified? + && (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList(renderer)->GetMTime()) + && dispGeo.Equals(m_LastDisplayGeometry)) + return; + + localStorage->m_LastUpdateTime.Modified(); + + if(!IsVisibleOdfs(renderer)) { - itkWarningMacro( << "number of components != number of directions in ODF!" ); - return; + localStorage->m_OdfsActors[0]->VisibilityOff(); + localStorage->m_OdfsActors[1]->VisibilityOff(); + localStorage->m_OdfsActors[2]->VisibilityOff(); } - else if ( pointData->GetArrayName( 0 ) == NULL ) + else { - m_VtkImage->GetPointData()->GetArray(0)->SetName("vector"); + localStorage->m_OdfsActors[0]->VisibilityOn(); + localStorage->m_OdfsActors[1]->VisibilityOn(); + localStorage->m_OdfsActors[2]->VisibilityOn(); + + m_OdfSource->SetAdditionalScale(GetMinImageSpacing(GetIndex(renderer))); + ApplyPropertySettings(); + Slice(renderer, dispGeo); + m_LastDisplayGeometry = dispGeo; } - } - else - { - itkWarningMacro( << "m_VtkImage is NULL!" ); - return ; - } } template double mitk::OdfVtkMapper2D::GetMinImageSpacing( int index ) { - // Spacing adapted scaling - double spacing[3]; - m_VtkImage->GetSpacing(spacing); - double min; - if(index==0) - { - min = spacing[0]; - min = min > spacing[1] ? spacing[1] : min; - } - if(index==1) - { - min = spacing[1]; - min = min > spacing[2] ? spacing[2] : min; - } - if(index==2) - { - min = spacing[0]; - min = min > spacing[2] ? spacing[2] : min; - } - return min; + // Spacing adapted scaling + double spacing[3]; + m_VtkImage->GetSpacing(spacing); + double min; + if(index==0) + { + min = spacing[0]; + min = min > spacing[1] ? spacing[1] : min; + } + if(index==1) + { + min = spacing[1]; + min = min > spacing[2] ? spacing[2] : min; + } + if(index==2) + { + min = spacing[0]; + min = min > spacing[2] ? spacing[2] : min; + } + return min; } template void mitk::OdfVtkMapper2D ::ApplyPropertySettings() { - this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling ); - this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber ); - - OdfNormalizationMethodProperty* nmp = dynamic_cast - ( - this->GetDataNode()->GetProperty( "Normalization" )); - if(nmp) - { - m_Normalization = nmp->GetNormalization(); - } - - OdfScaleByProperty* sbp = dynamic_cast - ( - this->GetDataNode()->GetProperty( "ScaleBy" )); - if(sbp) - { - m_ScaleBy = sbp->GetScaleBy(); - } - - this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1); - this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2); + this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling ); + this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber ); + + OdfNormalizationMethodProperty* nmp = dynamic_cast(this->GetDataNode()->GetProperty( "Normalization" )); + if(nmp) + m_Normalization = nmp->GetNormalization(); + + OdfScaleByProperty* sbp = dynamic_cast(this->GetDataNode()->GetProperty( "ScaleBy" )); + if(sbp) + m_ScaleBy = sbp->GetScaleBy(); + + this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1); + this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2); } template bool mitk::OdfVtkMapper2D ::IsPlaneRotated(mitk::BaseRenderer* renderer) { - Geometry2D::ConstPointer worldGeometry = - renderer->GetCurrentWorldGeometry2D(); - PlaneGeometry::ConstPointer worldPlaneGeometry = - dynamic_cast( worldGeometry.GetPointer() ); - - vtkFloatingPointType vnormal[ 3 ]; - Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize(); - vnl2vtk( normal.Get_vnl_vector(), vnormal ); - - vtkLinearTransform * vtktransform = - this->GetDataNode()->GetVtkTransform(this->GetTimestep()); - - vtkTransform* inversetransform = vtkTransform::New(); - inversetransform->Identity(); - inversetransform->Concatenate(vtktransform->GetLinearInverse()); - double* n = inversetransform->TransformNormal(vnormal); - - int nonZeros = 0; - for (int j=0; j<3; j++) - { - if (fabs(n[j])>mitk::eps){ - nonZeros++; - } - } - if(nonZeros>1) - return true; + Geometry2D::ConstPointer worldGeometry = + renderer->GetCurrentWorldGeometry2D(); + PlaneGeometry::ConstPointer worldPlaneGeometry = + dynamic_cast( worldGeometry.GetPointer() ); - return false; -} + vtkFloatingPointType vnormal[ 3 ]; + Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize(); + vnl2vtk( normal.Get_vnl_vector(), vnormal ); -template -void mitk::OdfVtkMapper2D -::GenerateDataForRenderer( mitk::BaseRenderer *renderer ) -{ - if(!m_VtkImage) - { - itkWarningMacro( << "m_VtkImage is NULL!" ); - return ; - } - - int index = GetIndex(renderer); - - if(IsVisibleOdfs(renderer)==false) - { - m_OdfsActors[0]->VisibilityOff(); - m_OdfsActors[1]->VisibilityOff(); - m_OdfsActors[2]->VisibilityOff(); - return; - } - else - { - m_OdfsActors[0]->VisibilityOn(); - m_OdfsActors[1]->VisibilityOn(); - m_OdfsActors[2]->VisibilityOn(); - - OdfDisplayGeometry dispGeo = - MeasureDisplayedGeometry( renderer); - - m_OdfSource->SetAdditionalScale(GetMinImageSpacing(index)); - ApplyPropertySettings(); - Slice(renderer, dispGeo); - m_LastDisplayGeometry = dispGeo; - - } - - // Get the TimeSlicedGeometry of the input object - mitk::Image::Pointer input = const_cast(this->GetInput()); - const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry(); - if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 )) - { - m_PropAssemblies[0]->VisibilityOff(); - m_PropAssemblies[1]->VisibilityOff(); - m_PropAssemblies[2]->VisibilityOff(); - return; - } - - if( inputTimeGeometry->IsValidTime( this->GetTimestep() ) == false ) - { - m_PropAssemblies[0]->VisibilityOff(); - m_PropAssemblies[1]->VisibilityOff(); - m_PropAssemblies[2]->VisibilityOff(); - return; - } + vtkLinearTransform * vtktransform = + this->GetDataNode()->GetVtkTransform(this->GetTimestep()); + vtkSmartPointer inversetransform = vtkTransform::New(); + inversetransform->Identity(); + inversetransform->Concatenate(vtktransform->GetLinearInverse()); + double* n = inversetransform->TransformNormal(vnormal); + + int nonZeros = 0; + for (int j=0; j<3; j++) + { + if (fabs(n[j])>mitk::eps){ + nonZeros++; + } + } + if(nonZeros>1) + return true; + return false; } template void mitk::OdfVtkMapper2D ::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* /*renderer*/, bool /*overwrite*/) { - node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) ); - node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) ); - node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New()); - node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New()); - node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2)); - node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1)); - node->SetProperty( "visible", mitk::BoolProperty::New( true ) ); - node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) ); - node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) ); - node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) ); - node->SetProperty ("layer", mitk::IntProperty::New(100)); - node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) ); + node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) ); + node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) ); + node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New()); + node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New()); + node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2)); + node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1)); + node->SetProperty( "visible", mitk::BoolProperty::New( true ) ); + node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) ); + node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) ); + node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) ); + node->SetProperty ("layer", mitk::IntProperty::New(100)); + node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) ); } #endif // __mitkOdfVtkMapper2D_txx__