diff --git a/Modules/Core/include/mitkIShaderRepository.h b/Modules/Core/include/mitkIShaderRepository.h index 749e4adb91..b78a95c5ff 100644 --- a/Modules/Core/include/mitkIShaderRepository.h +++ b/Modules/Core/include/mitkIShaderRepository.h @@ -1,136 +1,137 @@ /*=================================================================== 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 MITKISHADERREPOSITORY_H #define MITKISHADERREPOSITORY_H #include #include "mitkCommon.h" #include "mitkServiceInterface.h" #include class vtkActor; class vtkShaderProgram2; namespace mitk { class DataNode; class BaseRenderer; /** * \ingroup MicroServices_Interfaces * \brief Management class for vtkShader XML descriptions. * * Loads XML shader files from std::istream objects and adds default properties * for each shader object (shader uniforms) to the specified mitk::DataNode. * * Additionally, it provides a utility function for applying properties for shaders * in mappers. */ struct MITKCORE_EXPORT IShaderRepository { struct ShaderPrivate; class MITKCORE_EXPORT Shader : public itk::LightObject { public: mitkClassMacroItkParent(Shader, itk::LightObject) itkFactorylessNewMacro(Self) ~Shader(); int GetId() const; std::string GetName() const; std::string GetMaterialXml() const; protected: Shader(); void SetId(int id); void SetName(const std::string &name); void SetMaterialXml(const std::string &xml); private: // not implemented Shader(const Shader &); Shader &operator=(const Shader &); ShaderPrivate *d; }; class MITKCORE_EXPORT ShaderProgram : public itk::LightObject { public: virtual void Activate() = 0; virtual void Deactivate() = 0; mitkClassMacroItkParent(ShaderProgram, itk::LightObject) }; virtual ~IShaderRepository(); virtual std::list GetShaders() const = 0; /** * \brief Return the named shader. * * \param name The shader name. * \return A Shader object. * * Names might not be unique. Use the shader id to uniquely identify a shader. */ virtual Shader::Pointer GetShader(const std::string &name) const = 0; virtual ShaderProgram::Pointer CreateShaderProgram() = 0; /** * \brief Return the shader identified by the given id. * @param id The shader id. * @return The shader object or null if the id is unknown. */ virtual Shader::Pointer GetShader(int id) const = 0; /** \brief Adds all parsed shader uniforms to property list of the given DataNode; * used by mappers. */ - virtual void AddDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) const = 0; + virtual void AddDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite, std::string property_name="shader") const = 0; /** \brief Applies shader and shader specific variables of the specified DataNode * to the VTK object by updating the shader variables of its vtkProperty. */ virtual void UpdateShaderProgram(mitk::IShaderRepository::ShaderProgram *shaderProgram, mitk::DataNode *node, - mitk::BaseRenderer *renderer) const = 0; + mitk::BaseRenderer *renderer, + std::string property_name="shader") const = 0; /** \brief Loads a shader from a given file. Make sure that this stream is in the XML shader format. * * \return A unique id for the loaded shader which can be used to unload it. */ virtual int LoadShader(std::istream &stream, const std::string &name) = 0; /** * \brief Unload a previously loaded shader. * \param id The unique shader id returned by LoadShader. * \return \c true if the shader id was found and the shader was successfully unloaded, * \c false otherwise. */ virtual bool UnloadShader(int id) = 0; }; } MITK_DECLARE_SERVICE_INTERFACE(mitk::IShaderRepository, "org.mitk.services.IShaderRepository/1.0") #endif // MITKISHADERREPOSITORY_H diff --git a/Modules/Core/include/mitkVtkMapper.h b/Modules/Core/include/mitkVtkMapper.h index 15cd86b0d3..5cba64d2b2 100644 --- a/Modules/Core/include/mitkVtkMapper.h +++ b/Modules/Core/include/mitkVtkMapper.h @@ -1,177 +1,178 @@ /*=================================================================== 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. ===================================================================*/ // change number #ifndef VTKMAPPER_H_HEADER_INCLUDED_C1C5453B #define VTKMAPPER_H_HEADER_INCLUDED_C1C5453B #include "mitkBaseRenderer.h" #include "mitkDataNode.h" #include "mitkIShaderRepository.h" #include "mitkLocalStorageHandler.h" #include "mitkMapper.h" #include "mitkVtkPropRenderer.h" #include #include #include #include #include #include #include #include #include #include class vtkProp; class vtkProp3D; class vtkActor; namespace mitk { /** \brief Base class of all Vtk Mappers in order to display primitives * by exploiting Vtk functionality. * * Rendering of opaque, translucent or volumetric geometry and overlays * is done in consecutive render passes. * * \ingroup Mapper */ class MITKCORE_EXPORT VtkMapper : public Mapper { public: mitkClassMacro(VtkMapper, Mapper); virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) = 0; /** \brief Re-issues all drawing commands required to describe * the entire scene each time a new frame is required, * regardless of actual changes. */ static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper); /** * \brief Returns whether this is an vtk-based mapper * \deprecatedSince{2013_03} All mappers of superclass VTKMapper are vtk based, use a dynamic_cast instead */ DEPRECATED(virtual bool IsVtkBased() const override); /** \brief Determines which geometry should be rendered * (opaque, translucent, volumetric, overlay) * and calls the appropriate function. * * Called by mitk::VtkPropRenderer::Render */ void MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) override; /** \brief Checks visibility and renders the overlay */ virtual void MitkRenderOverlay(BaseRenderer *renderer); /** \brief Checks visibility and renders untransparent geometry */ virtual void MitkRenderOpaqueGeometry(BaseRenderer *renderer); /** \brief Checks visiblity and renders transparent geometry */ virtual void MitkRenderTranslucentGeometry(BaseRenderer *renderer); /** \brief Checks visibility and renders volumes */ virtual void MitkRenderVolumetricGeometry(BaseRenderer *renderer); /** \brief Returns true if this mapper owns the specified vtkProp for * the given BaseRenderer. * * Note: returns false by default; should be implemented for VTK-based * Mapper subclasses. */ virtual bool HasVtkProp(const vtkProp *prop, BaseRenderer *renderer); /** \brief Set the vtkTransform of the m_Prop3D for * the current time step of \a renderer * * Called by mitk::VtkPropRenderer::Update before rendering. This * method will transform all actors (e.g. of an vtkAssembly) according * the geometry. * * \warning This method transforms only props which derive * from vtkProp3D. Make sure to use vtkAssembly, if you have * multiple props. vtkPropAssembly does not work, since it derives * from vtkProp. */ virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer); /** * \brief Apply color and opacity properties read from the PropertyList * \deprecatedSince{2013_03} Use ApplyColorAndOpacityProperties(mitk::BaseRenderer* renderer, vtkActor * actor) * instead */ DEPRECATED(inline virtual void ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)) { ApplyColorAndOpacityProperties(renderer, actor); } /** * \brief SHADERTODO */ - void ApplyShaderProperties(mitk::BaseRenderer *renderer); + void ApplyShaderProperties(mitk::BaseRenderer *renderer, + std::string property_name="shader"); /** * \brief Apply color and opacity properties read from the PropertyList. * Called by mapper subclasses. */ virtual void ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor *actor) override; /** * \brief Release vtk-based graphics resources that are being consumed by this mapper. * * Method called by mitk::VtkPropRenderer. The parameter renderer could be used to * determine which graphic resources to release. The local storage is accessible * by the parameter renderer. Should be overwritten in subclasses. */ virtual void ReleaseGraphicsResources(mitk::BaseRenderer * /*renderer*/) {} class VtkMapperLocalStorage : public mitk::Mapper::BaseLocalStorage { public: mitk::IShaderRepository::ShaderProgram::Pointer m_ShaderProgram; itk::TimeStamp m_ModifiedTimeStamp; VtkMapperLocalStorage() { IShaderRepository *shaderRepo = CoreServices::GetShaderRepository(); if (shaderRepo) { m_ShaderProgram = shaderRepo->CreateShaderProgram(); } } ~VtkMapperLocalStorage() {} }; mitk::LocalStorageHandler m_VtkMapperLSH; protected: /** constructor */ VtkMapper(); /** virtual destructor in order to derive from this class */ virtual ~VtkMapper(); private: /** copy constructor */ VtkMapper(const VtkMapper &); /** assignment operator */ VtkMapper &operator=(const VtkMapper &); }; } // namespace mitk #endif /* VTKMAPPER_H_HEADER_INCLUDED_C1C5453B */ diff --git a/Modules/Core/src/Rendering/mitkVtkMapper.cpp b/Modules/Core/src/Rendering/mitkVtkMapper.cpp index 5003e99123..cbdd2ae6ca 100644 --- a/Modules/Core/src/Rendering/mitkVtkMapper.cpp +++ b/Modules/Core/src/Rendering/mitkVtkMapper.cpp @@ -1,161 +1,162 @@ /*=================================================================== 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. ===================================================================*/ #include "mitkVtkMapper.h" mitk::VtkMapper::VtkMapper() { } mitk::VtkMapper::~VtkMapper() { } void mitk::VtkMapper::MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type) { VtkMapperLocalStorage *ls = m_VtkMapperLSH.GetLocalStorage(renderer); if (ls->m_ShaderProgram) { ls->m_ShaderProgram->Activate(); } switch (type) { case mitk::VtkPropRenderer::Opaque: this->MitkRenderOpaqueGeometry(renderer); break; case mitk::VtkPropRenderer::Translucent: this->MitkRenderTranslucentGeometry(renderer); break; case mitk::VtkPropRenderer::Overlay: this->MitkRenderOverlay(renderer); break; case mitk::VtkPropRenderer::Volumetric: this->MitkRenderVolumetricGeometry(renderer); break; } if (ls->m_ShaderProgram) { ls->m_ShaderProgram->Deactivate(); } } bool mitk::VtkMapper::IsVtkBased() const { return true; } void mitk::VtkMapper::MitkRenderOverlay(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); } } void mitk::VtkMapper::MitkRenderOpaqueGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderOpaqueGeometry(renderer->GetVtkRenderer()); } } void mitk::VtkMapper::MitkRenderTranslucentGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (this->GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer()); } } -void mitk::VtkMapper::ApplyShaderProperties(mitk::BaseRenderer *renderer) +void mitk::VtkMapper::ApplyShaderProperties(mitk::BaseRenderer *renderer, + std::string property_name) { IShaderRepository *shaderRepo = CoreServices::GetShaderRepository(); if (shaderRepo) { VtkMapperLocalStorage *ls = m_VtkMapperLSH.GetLocalStorage(renderer); - shaderRepo->UpdateShaderProgram(ls->m_ShaderProgram, this->GetDataNode(), renderer); + shaderRepo->UpdateShaderProgram(ls->m_ShaderProgram, this->GetDataNode(), renderer, property_name); } } void mitk::VtkMapper::MitkRenderVolumetricGeometry(BaseRenderer *renderer) { bool visible = true; GetDataNode()->GetVisibility(visible, renderer, "visible"); if (!visible) return; if (GetVtkProp(renderer)->GetVisibility()) { GetVtkProp(renderer)->RenderVolumetricGeometry(renderer->GetVtkRenderer()); } } bool mitk::VtkMapper::HasVtkProp(const vtkProp *prop, BaseRenderer *renderer) { vtkProp *myProp = this->GetVtkProp(renderer); // TODO: check if myProp is a vtkAssembly and if so, check if prop is contained in its leafs return (prop == myProp); } void mitk::VtkMapper::SetVtkMapperImmediateModeRendering(vtkMapper *mapper) { if (mapper) mapper->SetImmediateModeRendering(mitk::VtkPropRenderer::useImmediateModeRendering()); } void mitk::VtkMapper::UpdateVtkTransform(mitk::BaseRenderer *renderer) { vtkLinearTransform *vtktransform = GetDataNode()->GetVtkTransform(this->GetTimestep()); vtkProp3D *prop = dynamic_cast(GetVtkProp(renderer)); if (prop) prop->SetUserTransform(vtktransform); } void mitk::VtkMapper::ApplyColorAndOpacityProperties(BaseRenderer *renderer, vtkActor *actor) { float rgba[4] = {1.0f, 1.0f, 1.0f, 1.0f}; DataNode *node = GetDataNode(); // check for color prop and use it for rendering if it exists node->GetColor(rgba, renderer, "color"); // check for opacity prop and use it for rendering if it exists node->GetOpacity(rgba[3], renderer, "opacity"); double drgba[4] = {rgba[0], rgba[1], rgba[2], rgba[3]}; actor->GetProperty()->SetColor(drgba); actor->GetProperty()->SetOpacity(drgba[3]); } diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp index 1ba79aa637..7bd34af922 100644 --- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp +++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper2D.cpp @@ -1,198 +1,198 @@ /*=================================================================== 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. ===================================================================*/ #include "mitkFiberBundleMapper2D.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include mitk::FiberBundleMapper2D::FiberBundleMapper2D() - : m_LineWidth(1) + : m_LineWidth(1) { - m_lut = vtkLookupTable::New(); - m_lut->Build(); + m_lut = vtkLookupTable::New(); + m_lut->Build(); } mitk::FiberBundleMapper2D::~FiberBundleMapper2D() { } mitk::FiberBundle* mitk::FiberBundleMapper2D::GetInput() { - return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() ); + return dynamic_cast< mitk::FiberBundle * > ( GetDataNode()->GetData() ); } void mitk::FiberBundleMapper2D::Update(mitk::BaseRenderer * renderer) { - bool visible = true; - GetDataNode()->GetVisibility(visible, renderer, "visible"); - if ( !visible ) - return; - - // Calculate time step of the input data for the specified renderer (integer value) - // this method is implemented in mitkMapper - this->CalculateTimeStep( renderer ); - - //check if updates occured in the node or on the display - FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); - - //set renderer independent shader properties - const DataNode::Pointer node = this->GetDataNode(); - float thickness = 2.0; - if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness)) - MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR"; - - bool fiberfading = false; - if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading)) - MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR"; - - float fiberOpacity; - this->GetDataNode()->GetOpacity(fiberOpacity, nullptr); - node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberThickness",thickness); - node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading); - node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity); - - mitk::FiberBundle* fiberBundle = this->GetInput(); - if (fiberBundle==nullptr) - return; - - int lineWidth = 0; - node->GetIntProperty("LineWidth", lineWidth); - if (m_LineWidth!=lineWidth) - { - m_LineWidth = lineWidth; - fiberBundle->RequestUpdate2D(); - } - - if ( localStorage->m_LastUpdateTimeGetCurrentWorldPlaneGeometryUpdateTime() || localStorage->m_LastUpdateTimeGetUpdateTime2D() ) - { - this->UpdateShaderParameter(renderer); - this->GenerateDataForRenderer( renderer ); - } + bool visible = true; + GetDataNode()->GetVisibility(visible, renderer, "visible"); + if ( !visible ) + return; + + // Calculate time step of the input data for the specified renderer (integer value) + // this method is implemented in mitkMapper + this->CalculateTimeStep( renderer ); + + //check if updates occured in the node or on the display + FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); + + //set renderer independent shader properties + const DataNode::Pointer node = this->GetDataNode(); + float thickness = 2.0; + if(!this->GetDataNode()->GetPropertyValue("Fiber2DSliceThickness",thickness)) + MITK_INFO << "FIBER2D SLICE THICKNESS PROPERTY ERROR"; + + bool fiberfading = false; + if(!this->GetDataNode()->GetPropertyValue("Fiber2DfadeEFX",fiberfading)) + MITK_INFO << "FIBER2D SLICE FADE EFX PROPERTY ERROR"; + + float fiberOpacity; + this->GetDataNode()->GetOpacity(fiberOpacity, nullptr); + node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberSliceThickness",thickness); + node->SetIntProperty("shader.mitkShaderFiberClipping.fiberFadingON",fiberfading); + node->SetFloatProperty("shader.mitkShaderFiberClipping.fiberOpacity",fiberOpacity); + + mitk::FiberBundle* fiberBundle = this->GetInput(); + if (fiberBundle==nullptr) + return; + + int lineWidth = 0; + node->GetIntProperty("LineWidth", lineWidth); + if (m_LineWidth!=lineWidth) + { + m_LineWidth = lineWidth; + fiberBundle->RequestUpdate2D(); + } + + if ( localStorage->m_LastUpdateTimeGetCurrentWorldPlaneGeometryUpdateTime() || localStorage->m_LastUpdateTimeGetUpdateTime2D() ) + { + this->UpdateShaderParameter(renderer); + this->GenerateDataForRenderer( renderer ); + } } void mitk::FiberBundleMapper2D::UpdateShaderParameter(mitk::BaseRenderer * renderer) { - //get information about current position of views - mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController(); - mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry(); - - //generate according cutting planes based on the view position - float planeNormal[3]; - planeNormal[0] = planeGeo->GetNormal()[0]; - planeNormal[1] = planeGeo->GetNormal()[1]; - planeNormal[2] = planeGeo->GetNormal()[2]; - - float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0]; - float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1]; - float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2]; - float thickness = tmp1 + tmp2 + tmp3; //attention, correct normalvector - - DataNode::Pointer node = this->GetDataNode(); - node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",thickness,renderer); - node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",planeNormal[0],renderer); - node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",planeNormal[1],renderer); - node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",planeNormal[2],renderer); + //get information about current position of views + mitk::SliceNavigationController::Pointer sliceContr = renderer->GetSliceNavigationController(); + mitk::PlaneGeometry::ConstPointer planeGeo = sliceContr->GetCurrentPlaneGeometry(); + + //generate according cutting planes based on the view position + float planeNormal[3]; + planeNormal[0] = planeGeo->GetNormal()[0]; + planeNormal[1] = planeGeo->GetNormal()[1]; + planeNormal[2] = planeGeo->GetNormal()[2]; + + float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0]; + float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1]; + float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2]; + float distance = tmp1 + tmp2 + tmp3; //attention, correct normalvector + + DataNode::Pointer node = this->GetDataNode(); + node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.w",distance,renderer); + node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.x",planeNormal[0],renderer); + node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.y",planeNormal[1],renderer); + node->SetFloatProperty("shader.mitkShaderFiberClipping.slicingPlane.z",planeNormal[2],renderer); } // vtkActors and Mappers are feeded here void mitk::FiberBundleMapper2D::GenerateDataForRenderer(mitk::BaseRenderer *renderer) { - mitk::FiberBundle* fiberBundle = this->GetInput(); + mitk::FiberBundle* fiberBundle = this->GetInput(); - //the handler of local storage gets feeded in this method with requested data for related renderwindow - FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); + //the handler of local storage gets feeded in this method with requested data for related renderwindow + FBXLocalStorage *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); - mitk::DataNode* node = this->GetDataNode(); - if ( node == nullptr ) - return; + mitk::DataNode* node = this->GetDataNode(); + if ( node == nullptr ) + return; - vtkSmartPointer fiberPolyData = fiberBundle->GetFiberPolyData(); - if (fiberPolyData == nullptr) - return; + vtkSmartPointer fiberPolyData = fiberBundle->GetFiberPolyData(); + if (fiberPolyData == nullptr) + return; - fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors()); - localStorage->m_FiberMapper->ScalarVisibilityOn(); - localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData(); - localStorage->m_FiberMapper->SetLookupTable(m_lut); //apply the properties after the slice was set - localStorage->m_PointActor->GetProperty()->SetOpacity(0.999); - localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS"); + fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors()); + localStorage->m_FiberMapper->ScalarVisibilityOn(); + localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData(); + localStorage->m_FiberMapper->SetLookupTable(m_lut); //apply the properties after the slice was set + localStorage->m_PointActor->GetProperty()->SetOpacity(0.999); + localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS"); - localStorage->m_FiberMapper->SetInputData(fiberPolyData); - localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper); - localStorage->m_PointActor->GetProperty()->ShadingOn(); - localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth); + localStorage->m_FiberMapper->SetInputData(fiberPolyData); + localStorage->m_PointActor->SetMapper(localStorage->m_FiberMapper); + localStorage->m_PointActor->GetProperty()->ShadingOn(); + localStorage->m_PointActor->GetProperty()->SetLineWidth(m_LineWidth); - // Applying shading properties - this->ApplyShaderProperties(renderer); + // Applying shading properties + this->ApplyShaderProperties(renderer); - // We have been modified => save this for next Update() - localStorage->m_LastUpdateTime.Modified(); + // We have been modified => save this for next Update() + localStorage->m_LastUpdateTime.Modified(); } vtkProp* mitk::FiberBundleMapper2D::GetVtkProp(mitk::BaseRenderer *renderer) { - this->Update(renderer); - return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor; + this->Update(renderer); + return m_LocalStorageHandler.GetLocalStorage(renderer)->m_PointActor; } void mitk::FiberBundleMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) { - Superclass::SetDefaultProperties(node, renderer, overwrite); - node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping")); - - // Shaders - IShaderRepository* shaderRepo = CoreServices::GetShaderRepository(); - if (shaderRepo) - { - shaderRepo->AddDefaultProperties(node, renderer, overwrite); - } - - //add other parameters to propertylist - node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite ); - node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite ); - node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite); + Superclass::SetDefaultProperties(node, renderer, overwrite); + node->SetProperty("shader",mitk::ShaderProperty::New("mitkShaderFiberClipping")); + + // Shaders + IShaderRepository* shaderRepo = CoreServices::GetShaderRepository(); + if (shaderRepo) + { + shaderRepo->AddDefaultProperties(node, renderer, overwrite); + } + + //add other parameters to propertylist + node->AddProperty( "Fiber2DSliceThickness", mitk::FloatProperty::New(1.0f), renderer, overwrite ); + node->AddProperty( "Fiber2DfadeEFX", mitk::BoolProperty::New(true), renderer, overwrite ); + node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite); } mitk::FiberBundleMapper2D::FBXLocalStorage::FBXLocalStorage() { - m_PointActor = vtkSmartPointer::New(); - m_FiberMapper = vtkSmartPointer::New(); + m_PointActor = vtkSmartPointer::New(); + m_FiberMapper = vtkSmartPointer::New(); } diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp index b86e7da848..726ac2f328 100644 --- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp +++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.cpp @@ -1,251 +1,288 @@ /*=================================================================== 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. ===================================================================*/ #include "mitkFiberBundleMapper3D.h" #include #include #include #include #include #include #include #include #include #include +#include +#include mitk::FiberBundleMapper3D::FiberBundleMapper3D() - : m_TubeRadius(0.0) - , m_TubeSides(15) - , m_LineWidth(1) + : m_TubeRadius(0.0) + , m_TubeSides(15) + , m_LineWidth(1) { - m_lut = vtkLookupTable::New(); - m_lut->Build(); + m_lut = vtkLookupTable::New(); + m_lut->Build(); } mitk::FiberBundleMapper3D::~FiberBundleMapper3D() { } const mitk::FiberBundle* mitk::FiberBundleMapper3D::GetInput() { - return static_cast ( GetDataNode()->GetData() ); + return static_cast ( GetDataNode()->GetData() ); } /* This method is called once the mapper gets new input, for UI rotation or changes in colorcoding this method is NOT called */ void mitk::FiberBundleMapper3D::InternalGenerateData(mitk::BaseRenderer *renderer) { - mitk::FiberBundle* fiberBundle = dynamic_cast (GetDataNode()->GetData()); - if (fiberBundle == nullptr) - return; - - vtkSmartPointer fiberPolyData = fiberBundle->GetFiberPolyData(); - if (fiberPolyData == nullptr) - return; - - fiberPolyData->GetPointData()->AddArray(fiberBundle->GetFiberColors()); - float tmpopa; - this->GetDataNode()->GetOpacity(tmpopa, nullptr); - FBXLocalStorage3D *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); - - if (m_TubeRadius>0.0) - { - vtkSmartPointer tubeFilter = vtkSmartPointer::New(); - tubeFilter->SetInputData(fiberPolyData); - tubeFilter->SetNumberOfSides(m_TubeSides); - tubeFilter->SetRadius(m_TubeRadius); - tubeFilter->Update(); - fiberPolyData = tubeFilter->GetOutput(); - } - else if (m_RibbonWidth>0.0) - { - vtkSmartPointer tubeFilter = vtkSmartPointer::New(); - tubeFilter->SetInputData(fiberPolyData); - tubeFilter->SetWidth(m_RibbonWidth); - tubeFilter->Update(); - fiberPolyData = tubeFilter->GetOutput(); - } - - if (tmpopa<1) - { - vtkSmartPointer depthSort = vtkSmartPointer::New(); - depthSort->SetInputData( fiberPolyData ); - depthSort->SetCamera( renderer->GetVtkRenderer()->GetActiveCamera() ); - depthSort->SetDirectionToFrontToBack(); - depthSort->Update(); - localStorage->m_FiberMapper->SetInputConnection(depthSort->GetOutputPort()); - } - else - { - localStorage->m_FiberMapper->SetInputData(fiberPolyData); - } - - if (m_Lighting) - { - float floatProp = 1.0; - GetDataNode()->GetFloatProperty("light.ambient", floatProp); - localStorage->m_FiberActor->GetProperty()->SetAmbient(floatProp); - GetDataNode()->GetFloatProperty("light.diffuse", floatProp); - localStorage->m_FiberActor->GetProperty()->SetDiffuse(floatProp); - GetDataNode()->GetFloatProperty("light.specular", floatProp); - localStorage->m_FiberActor->GetProperty()->SetSpecular(floatProp); - GetDataNode()->GetFloatProperty("light.specularpower", floatProp); - localStorage->m_FiberActor->GetProperty()->SetSpecularPower( floatProp ); - - mitk::ColorProperty* ambientC = dynamic_cast(GetDataNode()->GetProperty("light.ambientcolor")); - mitk::ColorProperty* diffuseC = dynamic_cast(GetDataNode()->GetProperty("light.diffusecolor")); - mitk::ColorProperty* specularC = dynamic_cast(GetDataNode()->GetProperty("light.specularcolor")); - - localStorage->m_FiberActor->GetProperty()->SetAmbientColor( ambientC->GetColor()[0], ambientC->GetColor()[1], ambientC->GetColor()[2] ); - localStorage->m_FiberActor->GetProperty()->SetDiffuseColor( diffuseC->GetColor()[0], diffuseC->GetColor()[1], diffuseC->GetColor()[2] ); - localStorage->m_FiberActor->GetProperty()->SetSpecularColor( specularC->GetColor()[0], specularC->GetColor()[1], specularC->GetColor()[2] ); - localStorage->m_FiberActor->GetProperty()->SetLighting(true); - } - else - { - localStorage->m_FiberActor->GetProperty()->SetLighting(false); - } - - localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS"); - localStorage->m_FiberMapper->ScalarVisibilityOn(); - localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData(); - localStorage->m_FiberActor->SetMapper(localStorage->m_FiberMapper); - localStorage->m_FiberMapper->SetLookupTable(m_lut); - - // set Opacity - localStorage->m_FiberActor->GetProperty()->SetOpacity((double) tmpopa); - localStorage->m_FiberActor->GetProperty()->SetLineWidth(m_LineWidth); - - localStorage->m_FiberAssembly->AddPart(localStorage->m_FiberActor); - localStorage->m_LastUpdateTime.Modified(); + m_FiberPolyData->GetPointData()->AddArray(m_FiberBundle->GetFiberColors()); + float tmpopa; + this->GetDataNode()->GetOpacity(tmpopa, nullptr); + FBXLocalStorage3D *localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); + + if (m_TubeRadius>0.0) + { + vtkSmartPointer tubeFilter = vtkSmartPointer::New(); + tubeFilter->SetInputData(m_FiberPolyData); + tubeFilter->SetNumberOfSides(m_TubeSides); + tubeFilter->SetRadius(m_TubeRadius); + tubeFilter->Update(); + m_FiberPolyData = tubeFilter->GetOutput(); + } + else if (m_RibbonWidth>0.0) + { + vtkSmartPointer tubeFilter = vtkSmartPointer::New(); + tubeFilter->SetInputData(m_FiberPolyData); + tubeFilter->SetWidth(m_RibbonWidth); + tubeFilter->Update(); + m_FiberPolyData = tubeFilter->GetOutput(); + } + + if (tmpopa<1) + { + vtkSmartPointer depthSort = vtkSmartPointer::New(); + depthSort->SetInputData( m_FiberPolyData ); + depthSort->SetCamera( renderer->GetVtkRenderer()->GetActiveCamera() ); + depthSort->SetDirectionToFrontToBack(); + depthSort->Update(); + localStorage->m_FiberMapper->SetInputConnection(depthSort->GetOutputPort()); + } + else + { + localStorage->m_FiberMapper->SetInputData(m_FiberPolyData); + } + + if (m_Lighting) + { + float floatProp = 1.0; + GetDataNode()->GetFloatProperty("light.ambient", floatProp); + localStorage->m_FiberActor->GetProperty()->SetAmbient(floatProp); + GetDataNode()->GetFloatProperty("light.diffuse", floatProp); + localStorage->m_FiberActor->GetProperty()->SetDiffuse(floatProp); + GetDataNode()->GetFloatProperty("light.specular", floatProp); + localStorage->m_FiberActor->GetProperty()->SetSpecular(floatProp); + GetDataNode()->GetFloatProperty("light.specularpower", floatProp); + localStorage->m_FiberActor->GetProperty()->SetSpecularPower( floatProp ); + + mitk::ColorProperty* ambientC = dynamic_cast(GetDataNode()->GetProperty("light.ambientcolor")); + mitk::ColorProperty* diffuseC = dynamic_cast(GetDataNode()->GetProperty("light.diffusecolor")); + mitk::ColorProperty* specularC = dynamic_cast(GetDataNode()->GetProperty("light.specularcolor")); + + localStorage->m_FiberActor->GetProperty()->SetAmbientColor( ambientC->GetColor()[0], ambientC->GetColor()[1], ambientC->GetColor()[2] ); + localStorage->m_FiberActor->GetProperty()->SetDiffuseColor( diffuseC->GetColor()[0], diffuseC->GetColor()[1], diffuseC->GetColor()[2] ); + localStorage->m_FiberActor->GetProperty()->SetSpecularColor( specularC->GetColor()[0], specularC->GetColor()[1], specularC->GetColor()[2] ); + localStorage->m_FiberActor->GetProperty()->SetLighting(true); + } + else + { + localStorage->m_FiberActor->GetProperty()->SetLighting(false); + } + + localStorage->m_FiberMapper->SelectColorArray("FIBER_COLORS"); + localStorage->m_FiberMapper->ScalarVisibilityOn(); + localStorage->m_FiberMapper->SetScalarModeToUsePointFieldData(); + localStorage->m_FiberActor->SetMapper(localStorage->m_FiberMapper); + localStorage->m_FiberMapper->SetLookupTable(m_lut); + + // set Opacity + localStorage->m_FiberActor->GetProperty()->SetOpacity((double) tmpopa); + localStorage->m_FiberActor->GetProperty()->SetLineWidth(m_LineWidth); + + localStorage->m_FiberAssembly->AddPart(localStorage->m_FiberActor); + localStorage->m_LastUpdateTime.Modified(); } void mitk::FiberBundleMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ) { - bool visible = true; - GetDataNode()->GetVisibility(visible, renderer, "visible"); - if ( !visible ) return; - - const DataNode* node = this->GetDataNode(); - FBXLocalStorage3D* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); - mitk::FiberBundle* fiberBundle = dynamic_cast(node->GetData()); - - // did any rendering properties change? - float tubeRadius = 0; - node->GetFloatProperty("shape.tuberadius", tubeRadius); - if (m_TubeRadius!=tubeRadius) - { - m_TubeRadius = tubeRadius; - fiberBundle->RequestUpdate3D(); - } - - int tubeSides = 0; - node->GetIntProperty("shape.tubesides", tubeSides); - if (m_TubeSides!=tubeSides) - { - m_TubeSides = tubeSides; - fiberBundle->RequestUpdate3D(); - } - - int lineWidth = 0; - node->GetIntProperty("shape.linewidth", lineWidth); - if (m_LineWidth!=lineWidth) - { - m_LineWidth = lineWidth; - fiberBundle->RequestUpdate3D(); - } - - float ribbonWidth = 0; - node->GetFloatProperty("shape.ribbonwidth", ribbonWidth); - if (m_RibbonWidth!=ribbonWidth) - { - m_RibbonWidth = ribbonWidth; - fiberBundle->RequestUpdate3D(); - } - - bool lighting = false; - node->GetBoolProperty("light.enable", lighting); - if (m_Lighting!=lighting) - { - m_Lighting = lighting; - fiberBundle->RequestUpdate3D(); - } - - if (localStorage->m_LastUpdateTime>=fiberBundle->GetUpdateTime3D()) - return; - - // Calculate time step of the input data for the specified renderer (integer value) - // this method is implemented in mitkMapper - this->CalculateTimeStep( renderer ); - this->InternalGenerateData(renderer); + bool visible = true; + GetDataNode()->GetVisibility(visible, renderer, "visible"); + if ( !visible ) + return; + + const DataNode* node = this->GetDataNode(); + FBXLocalStorage3D* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer); + + m_FiberBundle = dynamic_cast(node->GetData()); + m_FiberPolyData = m_FiberBundle->GetFiberPolyData(); + + this->UpdateShaderParameter(renderer); + this->ApplyShaderProperties(renderer, "shader_3d"); + + // did any rendering properties change? + float tubeRadius = 0; + node->GetFloatProperty("shape.tuberadius", tubeRadius); + if (m_TubeRadius!=tubeRadius) + { + m_TubeRadius = tubeRadius; + m_FiberBundle->RequestUpdate3D(); + } + + int tubeSides = 0; + node->GetIntProperty("shape.tubesides", tubeSides); + if (m_TubeSides!=tubeSides) + { + m_TubeSides = tubeSides; + m_FiberBundle->RequestUpdate3D(); + } + + int lineWidth = 0; + node->GetIntProperty("shape.linewidth", lineWidth); + if (m_LineWidth!=lineWidth) + { + m_LineWidth = lineWidth; + m_FiberBundle->RequestUpdate3D(); + } + + float ribbonWidth = 0; + node->GetFloatProperty("shape.ribbonwidth", ribbonWidth); + if (m_RibbonWidth!=ribbonWidth) + { + m_RibbonWidth = ribbonWidth; + m_FiberBundle->RequestUpdate3D(); + } + + bool lighting = false; + node->GetBoolProperty("light.enable", lighting); + if (m_Lighting!=lighting) + { + m_Lighting = lighting; + m_FiberBundle->RequestUpdate3D(); + } + + if (localStorage->m_LastUpdateTime>=m_FiberBundle->GetUpdateTime3D()) + return; + + // Calculate time step of the input data for the specified renderer (integer value) + // this method is implemented in mitkMapper + this->CalculateTimeStep( renderer ); + this->InternalGenerateData(renderer); } - -void mitk::FiberBundleMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) +void mitk::FiberBundleMapper3D::UpdateShaderParameter(mitk::BaseRenderer * renderer) { - Superclass::SetDefaultProperties(node, renderer, overwrite); - node->AddProperty( "opacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); - node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite); - node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite); - - node->AddProperty( "shape.linewidth", mitk::IntProperty::New( true ), renderer, overwrite ); - node->AddProperty( "shape.tuberadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite); - node->AddProperty( "shape.tubesides",mitk::IntProperty::New( 15 ), renderer, overwrite); - node->AddProperty( "shape.ribbonwidth", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); - - node->AddProperty( "light.enable", mitk::BoolProperty::New( true ), renderer, overwrite); - node->AddProperty( "light.ambient", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); - node->AddProperty( "light.diffuse", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); - node->AddProperty( "light.specular", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); - node->AddProperty( "light.specularpower", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); - node->AddProperty( "light.ambientcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); - node->AddProperty( "light.diffusecolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); - node->AddProperty( "light.specularcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); + mitk::Vector3D plane_vec; + this->GetDataNode()->GetPropertyValue("Fiber3DClippingPlane",plane_vec); + + bool flip; + this->GetDataNode()->GetBoolProperty("Fiber3DClippingPlaneFlip",flip); + + float distance = plane_vec.GetNorm(); + plane_vec.Normalize(); + + if (flip) + { + plane_vec *= -1; + distance *= -1; + } + + DataNode::Pointer node = this->GetDataNode(); + node->SetFloatProperty("shader_3d.mitkShaderFiberClipping3D.slicingPlane.w",distance,renderer); + node->SetFloatProperty("shader_3d.mitkShaderFiberClipping3D.slicingPlane.x",plane_vec[0],renderer); + node->SetFloatProperty("shader_3d.mitkShaderFiberClipping3D.slicingPlane.y",plane_vec[1],renderer); + node->SetFloatProperty("shader_3d.mitkShaderFiberClipping3D.slicingPlane.z",plane_vec[2],renderer); + + float fiberOpacity; + this->GetDataNode()->GetOpacity(fiberOpacity, nullptr); + node->SetFloatProperty("shader_3d.mitkShaderFiberClipping3D.fiberOpacity",fiberOpacity); } -vtkProp* mitk::FiberBundleMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) +void mitk::FiberBundleMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) { - return m_LocalStorageHandler.GetLocalStorage(renderer)->m_FiberAssembly; + Superclass::SetDefaultProperties(node, renderer, overwrite); + + node->AddProperty("shader_3d", mitk::ShaderProperty::New("mitkShaderFiberClipping3D")); + mitk::Vector3D plane_vec; plane_vec.Fill(0.0); + node->AddProperty( "Fiber3DClippingPlane", mitk::Vector3DProperty::New( plane_vec ), renderer, overwrite ); + node->AddProperty( "Fiber3DClippingPlaneId", mitk::IntProperty::New( 0 ), renderer, overwrite ); + node->AddProperty( "Fiber3DClippingPlaneFlip", mitk::BoolProperty::New( false ), renderer, overwrite ); + + // Shaders + IShaderRepository* shaderRepo = CoreServices::GetShaderRepository(); + + if (shaderRepo) + { + shaderRepo->AddDefaultProperties(node, renderer, overwrite, "shader_3d"); + } + + node->AddProperty( "opacity", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); + node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), renderer, overwrite); + node->AddProperty( "pickable", mitk::BoolProperty::New( true ), renderer, overwrite); + + node->AddProperty( "shape.linewidth", mitk::IntProperty::New( true ), renderer, overwrite ); + node->AddProperty( "shape.tuberadius",mitk::FloatProperty::New( 0.0 ), renderer, overwrite); + node->AddProperty( "shape.tubesides",mitk::IntProperty::New( 15 ), renderer, overwrite); + node->AddProperty( "shape.ribbonwidth", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); + + node->AddProperty( "light.enable", mitk::BoolProperty::New( true ), renderer, overwrite); + node->AddProperty( "light.ambient", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); + node->AddProperty( "light.diffuse", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); + node->AddProperty( "light.specular", mitk::FloatProperty::New( 0.0 ), renderer, overwrite); + node->AddProperty( "light.specularpower", mitk::FloatProperty::New( 1.0 ), renderer, overwrite); + node->AddProperty( "light.ambientcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); + node->AddProperty( "light.diffusecolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); + node->AddProperty( "light.specularcolor", mitk::ColorProperty::New(1,1,1), renderer, overwrite); } -void mitk::FiberBundleMapper3D::UpdateVtkObjects() +vtkProp* mitk::FiberBundleMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) { - + return m_LocalStorageHandler.GetLocalStorage(renderer)->m_FiberAssembly; } void mitk::FiberBundleMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *) { } mitk::FiberBundleMapper3D::FBXLocalStorage3D::FBXLocalStorage3D() { - m_FiberActor = vtkSmartPointer::New(); - m_FiberMapper = vtkSmartPointer::New(); - m_FiberAssembly = vtkSmartPointer::New(); + m_FiberActor = vtkSmartPointer::New(); + m_FiberMapper = vtkSmartPointer::New(); + m_FiberAssembly = vtkSmartPointer::New(); } diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h index cd3be5b43c..101362a19d 100644 --- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h +++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleMapper3D.h @@ -1,101 +1,103 @@ /*=================================================================== 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 FiberBundleMapper3D_H_HEADER_INCLUDED #define FiberBundleMapper3D_H_HEADER_INCLUDED //#include //?? necessary #include #include #include class vtkPropAssembly; class vtkPolyDataMapper; class vtkLookupTable; class vtkOpenGLActor; namespace mitk { //##Documentation //## @brief Mapper for FiberBundle //## @ingroup Mapper class FiberBundleMapper3D : public VtkMapper { public: mitkClassMacro(FiberBundleMapper3D, VtkMapper) itkFactorylessNewMacro(Self) itkCloneMacro(Self) //========== essential implementation for 3D mapper ======== const FiberBundle* GetInput(); virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override; //looks like depricated.. should be replaced bz GetViewProp() static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false ); static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper); virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer) override; //========================================================= class FBXLocalStorage3D : public mitk::Mapper::BaseLocalStorage { public: /** \brief Point Actor of a 3D render window. */ vtkSmartPointer m_FiberActor; /** \brief Point Mapper of a 3D render window. */ vtkSmartPointer m_FiberMapper; vtkSmartPointer m_FiberAssembly; /** \brief Timestamp of last update of stored data. */ itk::TimeStamp m_LastUpdateTime; /** \brief Constructor of the local storage. Do as much actions as possible in here to avoid double executions. */ FBXLocalStorage3D(); //if u copy&paste from this 2Dmapper, be aware that the implementation of this constructor is in the cpp file ~FBXLocalStorage3D() { } }; /** \brief This member holds all three LocalStorages for the 3D render window(s). */ mitk::LocalStorageHandler m_LocalStorageHandler; protected: FiberBundleMapper3D(); virtual ~FiberBundleMapper3D(); void InternalGenerateData(mitk::BaseRenderer *renderer); - void UpdateVtkObjects(); //?? + void UpdateShaderParameter(mitk::BaseRenderer*); private: vtkSmartPointer m_lut; float m_TubeRadius; int m_TubeSides; int m_LineWidth; float m_RibbonWidth; bool m_Lighting; + vtkSmartPointer m_FiberPolyData; + mitk::FiberBundle* m_FiberBundle; }; } // end namespace mitk #endif /* FiberBundleMapper3D_H_HEADER_INCLUDED */ diff --git a/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml b/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml index da3da5b910..7f3799f333 100644 --- a/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml +++ b/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping.xml @@ -1,56 +1,52 @@ - - + + varying vec3 positionWorld; varying vec3 color; void main(void) { color = gl_Color.rgb; positionWorld = vec3(gl_Vertex); gl_Position = ftransform(); } - + + uniform vec4 slicingPlane; - uniform float fiberThickness; + uniform float fiberSliceThickness; uniform int fiberFadingON; uniform float fiberOpacity; varying vec3 positionWorld; varying vec3 color; void main(void) { - float r1 = dot(positionWorld, slicingPlane.xyz) - slicingPlane.w; - - if ( abs(r1) > fiberThickness ) - discard; - - if (fiberFadingON != 0) - { - float x = (r1+fiberThickness)/(fiberThickness*2.0); - x = 1.0 - x; - gl_FragColor = vec4(color*x, fiberOpacity); - }else{ - gl_FragColor = vec4(color, fiberOpacity); - } - + float r1 = dot(positionWorld, slicingPlane.xyz) - slicingPlane.w; + + if ( abs(r1) > fiberSliceThickness ) + discard; + + if (fiberFadingON != 0) + { + float x = (r1+fiberSliceThickness)/(fiberSliceThickness*2.0); + x = 1.0 - x; + gl_FragColor = vec4(color*x, fiberOpacity); + } + else + { + gl_FragColor = vec4(color, fiberOpacity); + } } - + - + diff --git a/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping3D.xml b/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping3D.xml new file mode 100644 index 0000000000..325ffadd0c --- /dev/null +++ b/Modules/DiffusionImaging/FiberTracking/Resources/Shaders/mitkShaderFiberClipping3D.xml @@ -0,0 +1,39 @@ + + + + + varying vec3 positionWorld; + varying vec3 color; + + void main(void) + { + color = gl_Color.rgb; + positionWorld = vec3(gl_Vertex); + gl_Position = ftransform(); + } + + + + + uniform vec4 slicingPlane; + uniform float fiberOpacity; + + varying vec3 positionWorld; + varying vec3 color; + + void main(void) + { + float r1 = dot(positionWorld, slicingPlane.xyz) - slicingPlane.w; + + if ( r1 > 0 ) + discard; + + gl_FragColor = vec4(color, fiberOpacity); + } + + + + + + + diff --git a/Modules/DiffusionImaging/FiberTracking/files.cmake b/Modules/DiffusionImaging/FiberTracking/files.cmake index 92512547a1..b395a50634 100644 --- a/Modules/DiffusionImaging/FiberTracking/files.cmake +++ b/Modules/DiffusionImaging/FiberTracking/files.cmake @@ -1,94 +1,95 @@ set(CPP_FILES mitkFiberTrackingModuleActivator.cpp ## IO datastructures IODataStructures/FiberBundle/mitkFiberBundle.cpp IODataStructures/FiberBundle/mitkTrackvis.cpp IODataStructures/PlanarFigureComposite/mitkPlanarFigureComposite.cpp IODataStructures/mitkTractographyForest.cpp # Interactions # Tractography Algorithms/GibbsTracking/mitkParticleGrid.cpp Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.cpp Algorithms/GibbsTracking/mitkEnergyComputer.cpp Algorithms/GibbsTracking/mitkGibbsEnergyComputer.cpp Algorithms/GibbsTracking/mitkFiberBuilder.cpp Algorithms/GibbsTracking/mitkSphereInterpolator.cpp Algorithms/itkStreamlineTrackingFilter.cpp Algorithms/TrackingHandlers/mitkTrackingDataHandler.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.cpp Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp ) set(H_FILES # DataStructures -> FiberBundle IODataStructures/FiberBundle/mitkFiberBundle.h IODataStructures/FiberBundle/mitkTrackvis.h IODataStructures/mitkFiberfoxParameters.h IODataStructures/mitkTractographyForest.h # Algorithms Algorithms/itkTractDensityImageFilter.h Algorithms/itkTractsToFiberEndingsImageFilter.h Algorithms/itkTractsToRgbaImageFilter.h Algorithms/itkTractsToVectorImageFilter.h Algorithms/itkEvaluateDirectionImagesFilter.h Algorithms/itkEvaluateTractogramDirectionsFilter.h Algorithms/itkFiberCurvatureFilter.h # Tractography Algorithms/TrackingHandlers/mitkTrackingDataHandler.h Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h Algorithms/itkGibbsTrackingFilter.h Algorithms/itkStochasticTractographyFilter.h Algorithms/GibbsTracking/mitkParticle.h Algorithms/GibbsTracking/mitkParticleGrid.h Algorithms/GibbsTracking/mitkMetropolisHastingsSampler.h Algorithms/GibbsTracking/mitkSimpSamp.h Algorithms/GibbsTracking/mitkEnergyComputer.h Algorithms/GibbsTracking/mitkGibbsEnergyComputer.h Algorithms/GibbsTracking/mitkSphereInterpolator.h Algorithms/GibbsTracking/mitkFiberBuilder.h Algorithms/itkStreamlineTrackingFilter.h # Fiberfox Fiberfox/itkFibersFromPlanarFiguresFilter.h Fiberfox/itkTractsToDWIImageFilter.h Fiberfox/itkKspaceImageFilter.h Fiberfox/itkDftImageFilter.h Fiberfox/itkFieldmapGeneratorFilter.h Fiberfox/SignalModels/mitkDiffusionSignalModel.h Fiberfox/SignalModels/mitkTensorModel.h Fiberfox/SignalModels/mitkBallModel.h Fiberfox/SignalModels/mitkDotModel.h Fiberfox/SignalModels/mitkAstroStickModel.h Fiberfox/SignalModels/mitkStickModel.h Fiberfox/SignalModels/mitkRawShModel.h Fiberfox/SignalModels/mitkDiffusionNoiseModel.h Fiberfox/SignalModels/mitkRicianNoiseModel.h Fiberfox/SignalModels/mitkChiSquareNoiseModel.h Fiberfox/Sequences/mitkAcquisitionType.h Fiberfox/Sequences/mitkSingleShotEpi.h Fiberfox/Sequences/mitkCartesianReadout.h ) set(RESOURCE_FILES # Binary directory resources FiberTrackingLUTBaryCoords.bin FiberTrackingLUTIndices.bin # Shaders Shaders/mitkShaderFiberClipping.xml + Shaders/mitkShaderFiberClipping3D.xml ) diff --git a/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp b/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp index ac71216d6f..a97d5ec41f 100644 --- a/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp +++ b/Modules/VtkShaders/src/mitkVtkShaderRepository.cpp @@ -1,644 +1,646 @@ /*=================================================================== 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. ===================================================================*/ #define SR_INFO MITK_INFO("shader.repository") #define SR_WARN MITK_WARN("shader.repository") #define SR_ERROR MITK_ERROR("shader.repository") #include "mitkVtkShaderRepository.h" #include "mitkDataNode.h" #include "mitkProperties.h" #include "mitkShaderProperty.h" #include "mitkVtkShaderProgram.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include int mitk::VtkShaderRepository::shaderId = 0; const bool mitk::VtkShaderRepository::debug = false; mitk::VtkShaderRepository::VtkShaderRepository() { LoadShaders(); } mitk::VtkShaderRepository::~VtkShaderRepository() { } mitk::IShaderRepository::ShaderProgram::Pointer mitk::VtkShaderRepository::CreateShaderProgram() { mitk::IShaderRepository::ShaderProgram::Pointer shaderProg = (mitk::VtkShaderProgram::New()).GetPointer(); return shaderProg; } void mitk::VtkShaderRepository::LoadShaders() { itk::Directory::Pointer dir = itk::Directory::New(); std::string dirPath = "./vtk_shader"; if (dir->Load(dirPath.c_str())) { int n = dir->GetNumberOfFiles(); for (int r = 0; r < n; r++) { const char *filename = dir->GetFile(r); std::string extension = itksys::SystemTools::GetFilenameExtension(filename); if (extension.compare(".xml") == 0) { Shader::Pointer element = Shader::New(); element->SetName(itksys::SystemTools::GetFilenameWithoutExtension(filename)); std::string filePath = dirPath + std::string("/") + element->GetName() + std::string(".xml"); SR_INFO(debug) << "found shader '" << element->GetName() << "'"; std::ifstream fileStream(filePath.c_str()); element->LoadXmlShader(fileStream); shaders.push_back(element); } } } } mitk::VtkShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShaderImpl(const std::string &name) const { std::list::const_iterator i = shaders.begin(); while (i != shaders.end()) { if ((*i)->GetName() == name) return (*i); i++; } return Shader::Pointer(); } int mitk::VtkShaderRepository::LoadShader(std::istream &stream, const std::string &filename) { Shader::Pointer element = Shader::New(); element->SetName(filename); element->SetId(shaderId++); element->LoadXmlShader(stream); shaders.push_back(element); SR_INFO(debug) << "found shader '" << element->GetName() << "'"; return element->GetId(); } bool mitk::VtkShaderRepository::UnloadShader(int id) { for (std::list::iterator i = shaders.begin(); i != shaders.end(); ++i) { if ((*i)->GetId() == id) { shaders.erase(i); return true; } } return false; } mitk::VtkShaderRepository::Shader::Shader() { } mitk::VtkShaderRepository::Shader::~Shader() { } void mitk::VtkShaderRepository::Shader::SetVertexShaderCode(const std::string &code) { this->m_VertexShaderCode = code; } std::string mitk::VtkShaderRepository::Shader::GetVertexShaderCode() const { return this->m_VertexShaderCode; } void mitk::VtkShaderRepository::Shader::SetFragmentShaderCode(const std::string &code) { this->m_FragmentShaderCode = code; } std::string mitk::VtkShaderRepository::Shader::GetFragmentShaderCode() const { return this->m_FragmentShaderCode; } void mitk::VtkShaderRepository::Shader::SetGeometryShaderCode(const std::string &code) { this->m_GeometryShaderCode = code; } std::string mitk::VtkShaderRepository::Shader::GetGeometryShaderCode() const { return this->m_GeometryShaderCode; } std::list mitk::VtkShaderRepository::Shader::GetUniforms() const { return uniforms; } void mitk::VtkShaderRepository::Shader::LoadXmlShader(std::istream &stream) { std::string content; content.reserve(2048); char buffer[2048]; while (stream.read(buffer, sizeof(buffer))) { content.append(buffer, sizeof(buffer)); } content.append(buffer, static_cast(stream.gcount())); if (content.empty()) return; this->SetMaterialXml(content); vtkXMLMaterialParser *parser = vtkXMLMaterialParser::New(); vtkXMLMaterial *material = vtkXMLMaterial::New(); parser->SetMaterial(material); parser->Parse(content.c_str()); parser->Delete(); if (material == nullptr) return; // Vertexshader uniforms { vtkXMLShader *s = material->GetVertexShader(); if (s) { SetVertexShaderCode(s->GetCode()); vtkXMLDataElement *x = s->GetRootElement(); int n = x->GetNumberOfNestedElements(); for (int r = 0; r < n; r++) { vtkXMLDataElement *y = x->GetNestedElement(r); if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) { Uniform::Pointer element = Uniform::New(); element->LoadFromXML(y); uniforms.push_back(element); } } } } // Fragmentshader uniforms { vtkXMLShader *s = material->GetFragmentShader(); if (s) { SetFragmentShaderCode(s->GetCode()); vtkXMLDataElement *x = s->GetRootElement(); int n = x->GetNumberOfNestedElements(); for (int r = 0; r < n; r++) { vtkXMLDataElement *y = x->GetNestedElement(r); if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) { Uniform::Pointer element = Uniform::New(); element->LoadFromXML(y); uniforms.push_back(element); } } } } // Geometryshader uniforms { vtkXMLShader *s = material->GetGeometryShader(); if (s) { SetGeometryShaderCode(s->GetCode()); vtkXMLDataElement *x = s->GetRootElement(); int n = x->GetNumberOfNestedElements(); for (int r = 0; r < n; r++) { vtkXMLDataElement *y = x->GetNestedElement(r); if (strcmp(y->GetName(), "ApplicationUniform") == 0 || strcmp(y->GetName(), "Uniform") == 0) { Uniform::Pointer element = Uniform::New(); element->LoadFromXML(y); uniforms.push_back(element); } } } } material->Delete(); } mitk::VtkShaderRepository::Shader::Uniform::Uniform() { } mitk::VtkShaderRepository::Shader::Uniform::~Uniform() { } void mitk::VtkShaderRepository::Shader::Uniform::LoadFromXML(vtkXMLDataElement *y) { // MITK_INFO << "found uniform '" << y->GetAttribute("name") << "' type=" << y->GetAttribute("type");// << " default=" // << y->GetAttribute("value"); name = y->GetAttribute("name"); const char *sType = y->GetAttribute("type"); if (!strcmp(sType, "float")) type = glsl_float; else if (!strcmp(sType, "vec2")) type = glsl_vec2; else if (!strcmp(sType, "vec3")) type = glsl_vec3; else if (!strcmp(sType, "vec4")) type = glsl_vec4; else if (!strcmp(sType, "int")) type = glsl_int; else if (!strcmp(sType, "ivec2")) type = glsl_ivec2; else if (!strcmp(sType, "ivec3")) type = glsl_ivec3; else if (!strcmp(sType, "ivec4")) type = glsl_ivec4; else { type = glsl_none; SR_WARN << "unknown type for uniform '" << name << "'"; } defaultFloat[0] = defaultFloat[1] = defaultFloat[2] = defaultFloat[3] = 0; const char *sDefault = y->GetAttribute("value"); if (sDefault) { switch (type) { case glsl_float: sscanf(sDefault, "%f", &defaultFloat[0]); break; case glsl_vec2: sscanf(sDefault, "%f %f", &defaultFloat[0], &defaultFloat[1]); break; case glsl_vec3: sscanf(sDefault, "%f %f %f", &defaultFloat[0], &defaultFloat[1], &defaultFloat[2]); break; case glsl_vec4: sscanf(sDefault, "%f %f %f %f", &defaultFloat[0], &defaultFloat[1], &defaultFloat[2], &defaultFloat[3]); break; case glsl_int: sscanf(sDefault, "%d", &defaultInt[0]); break; case glsl_ivec2: sscanf(sDefault, "%d %d", &defaultInt[0], &defaultInt[1]); break; case glsl_ivec3: sscanf(sDefault, "%d %d %d", &defaultInt[0], &defaultInt[1], &defaultInt[2]); break; case glsl_ivec4: sscanf(sDefault, "%d %d %d %d", &defaultInt[0], &defaultInt[1], &defaultInt[2], &defaultInt[3]); break; case glsl_none: break; } } } void mitk::VtkShaderRepository::AddDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, - bool overwrite) const + bool overwrite, + std::string property_name) const { - node->AddProperty("shader", mitk::ShaderProperty::New(), renderer, overwrite); + node->AddProperty(property_name.c_str(), mitk::ShaderProperty::New(), renderer, overwrite); std::list::const_iterator i = shaders.begin(); while (i != shaders.end()) { std::list uniforms = (*i)->GetUniforms(); std::string shaderName = (*i)->GetName(); std::list::const_iterator j = uniforms.begin(); while (j != uniforms.end()) { - std::string propertyName = "shader." + shaderName + "." + (*j)->name; + std::string propertyName = property_name + "." + shaderName + "." + (*j)->name; switch ((*j)->type) { case Shader::Uniform::glsl_float: node->AddProperty(propertyName.c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); break; case Shader::Uniform::glsl_vec2: node->AddProperty( (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); break; case Shader::Uniform::glsl_vec3: node->AddProperty( (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); node->AddProperty( (propertyName + ".z").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[2]), renderer, overwrite); break; case Shader::Uniform::glsl_vec4: node->AddProperty( (propertyName + ".x").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[1]), renderer, overwrite); node->AddProperty( (propertyName + ".z").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[2]), renderer, overwrite); node->AddProperty( (propertyName + ".w").c_str(), mitk::FloatProperty::New((*j)->defaultFloat[3]), renderer, overwrite); break; case Shader::Uniform::glsl_int: node->AddProperty(propertyName.c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); break; case Shader::Uniform::glsl_ivec2: node->AddProperty( (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); break; case Shader::Uniform::glsl_ivec3: node->AddProperty( (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); node->AddProperty( (propertyName + ".z").c_str(), mitk::IntProperty::New((*j)->defaultInt[2]), renderer, overwrite); break; case Shader::Uniform::glsl_ivec4: node->AddProperty( (propertyName + ".x").c_str(), mitk::IntProperty::New((*j)->defaultInt[0]), renderer, overwrite); node->AddProperty( (propertyName + ".y").c_str(), mitk::IntProperty::New((*j)->defaultInt[1]), renderer, overwrite); node->AddProperty( (propertyName + ".z").c_str(), mitk::IntProperty::New((*j)->defaultInt[2]), renderer, overwrite); node->AddProperty( (propertyName + ".w").c_str(), mitk::IntProperty::New((*j)->defaultInt[3]), renderer, overwrite); break; case Shader::Uniform::glsl_none: break; } j++; } i++; } } std::list mitk::VtkShaderRepository::GetShaders() const { std::list result; for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) { result.push_back(i->GetPointer()); } return result; } mitk::IShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShader(const std::string &name) const { for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) { if ((*i)->GetName() == name) return i->GetPointer(); } return IShaderRepository::Shader::Pointer(); } mitk::IShaderRepository::Shader::Pointer mitk::VtkShaderRepository::GetShader(int id) const { for (std::list::const_iterator i = shaders.begin(); i != shaders.end(); ++i) { if ((*i)->GetId() == id) return i->GetPointer(); } return IShaderRepository::Shader::Pointer(); } void mitk::VtkShaderRepository::UpdateShaderProgram(ShaderProgram *shaderProgram, DataNode *node, - BaseRenderer *renderer) const + BaseRenderer *renderer, + std::string property_name) const { VtkShaderProgram *mitkVtkShaderProgram = dynamic_cast(shaderProgram); - mitk::ShaderProperty *sep = dynamic_cast(node->GetProperty("shader", renderer)); + mitk::ShaderProperty *sep = dynamic_cast(node->GetProperty(property_name.c_str(), renderer)); if (!sep) { mitkVtkShaderProgram->SetVtkShaderProgram(0); return; } Shader::Pointer s = GetShaderImpl(sep->GetValueAsString()); // Need update pipeline mode if (sep->GetMTime() > mitkVtkShaderProgram->GetShaderTimestampUpdate().GetMTime()) { if (s.IsNull()) { mitkVtkShaderProgram->SetVtkShaderProgram(0); mitkVtkShaderProgram->GetShaderTimestampUpdate().Modified(); return; } vtkSmartPointer program = vtkSmartPointer::New(); #if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) program->SetContext(dynamic_cast(renderer->GetRenderWindow())); #else program->SetContext(renderer->GetRenderWindow()); #endif // The vertext shader vtkShader2 *shader = vtkShader2::New(); shader->SetType(VTK_SHADER_TYPE_VERTEX); shader->SetSourceCode(s->GetVertexShaderCode().c_str()); #if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); #else shader->SetContext(renderer->GetRenderWindow()); #endif program->GetShaders()->AddItem(shader); shader->Delete(); // The fragment shader shader = vtkShader2::New(); shader->SetType(VTK_SHADER_TYPE_FRAGMENT); shader->SetSourceCode(s->GetFragmentShaderCode().c_str()); #if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); #else shader->SetContext(renderer->GetRenderWindow()); #endif program->GetShaders()->AddItem(shader); shader->Delete(); if (s->GetGeometryShaderCode().size() > 0) { // The Geometry shader shader = vtkShader2::New(); shader->SetType(VTK_SHADER_TYPE_GEOMETRY); shader->SetSourceCode(s->GetGeometryShaderCode().c_str()); #if ((VTK_MAJOR_VERSION < 6) || ((VTK_MAJOR_VERSION == 6) && (VTK_MINOR_VERSION == 0))) shader->SetContext(dynamic_cast(renderer->GetRenderWindow())); #else shader->SetContext(renderer->GetRenderWindow()); #endif program->GetShaders()->AddItem(shader); shader->Delete(); } program->Build(); mitkVtkShaderProgram->SetVtkShaderProgram(program); mitkVtkShaderProgram->GetShaderTimestampUpdate().Modified(); } if (s.IsNull()) return; // update uniforms vtkShaderProgram2 *p = mitkVtkShaderProgram->GetVtkShaderProgram(); if (!p) return; std::list::const_iterator j = s->uniforms.begin(); while (j != s->uniforms.end()) { - std::string propertyName = "shader." + s->GetName() + "." + (*j)->name; + std::string propertyName = property_name + "." + s->GetName() + "." + (*j)->name; // MITK_INFO << "querying property: " << propertyName; // mitk::BaseProperty *p = node->GetProperty( propertyName.c_str(), renderer ); // if( p && p->GetMTime() > MTime.GetMTime() ) { float fval[4]; int ival[4]; // MITK_INFO << "copying property " << propertyName << " ->->- " << (*j)->name << " type=" << (*j)->type ; switch ((*j)->type) { case Shader::Uniform::glsl_float: node->GetFloatProperty(propertyName.c_str(), fval[0], renderer); p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 1, fval); break; case Shader::Uniform::glsl_vec2: node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 2, fval); break; case Shader::Uniform::glsl_vec3: node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); node->GetFloatProperty((propertyName + ".z").c_str(), fval[2], renderer); // p->SetUniform3f( (*j)->name.c_str(), fval ); p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 3, fval); break; case Shader::Uniform::glsl_vec4: node->GetFloatProperty((propertyName + ".x").c_str(), fval[0], renderer); node->GetFloatProperty((propertyName + ".y").c_str(), fval[1], renderer); node->GetFloatProperty((propertyName + ".z").c_str(), fval[2], renderer); node->GetFloatProperty((propertyName + ".w").c_str(), fval[3], renderer); p->GetUniformVariables()->SetUniformf((*j)->name.c_str(), 4, fval); break; case Shader::Uniform::glsl_int: node->GetIntProperty(propertyName.c_str(), ival[0], renderer); p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 1, ival); break; case Shader::Uniform::glsl_ivec2: node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 2, ival); break; case Shader::Uniform::glsl_ivec3: node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); node->GetIntProperty((propertyName + ".z").c_str(), ival[2], renderer); // p->SetUniform3f( (*j)->name.c_str(), fval ); p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 3, ival); break; case Shader::Uniform::glsl_ivec4: node->GetIntProperty((propertyName + ".x").c_str(), ival[0], renderer); node->GetIntProperty((propertyName + ".y").c_str(), ival[1], renderer); node->GetIntProperty((propertyName + ".z").c_str(), ival[2], renderer); node->GetIntProperty((propertyName + ".w").c_str(), ival[3], renderer); p->GetUniformVariables()->SetUniformi((*j)->name.c_str(), 4, ival); break; case Shader::Uniform::glsl_none: break; } } j++; } return; } diff --git a/Modules/VtkShaders/src/mitkVtkShaderRepository.h b/Modules/VtkShaders/src/mitkVtkShaderRepository.h index 01f67664e7..a6596665dc 100644 --- a/Modules/VtkShaders/src/mitkVtkShaderRepository.h +++ b/Modules/VtkShaders/src/mitkVtkShaderRepository.h @@ -1,164 +1,165 @@ /*=================================================================== 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 _MITKVTKSHADERREPOSITORY_H_ #define _MITKVTKSHADERREPOSITORY_H_ #include "mitkIShaderRepository.h" #include #include class vtkXMLDataElement; class vtkXMLMaterial; class vtkProperty; namespace mitk { /** * \brief Management class for vtkShader XML descriptions. * * Looks for all XML shader files in a given directory and adds default properties * for each shader object (shader uniforms) to the specified mitk::DataNode. * * Additionally, it provides a utility function for applying properties for shaders * in mappers. */ class VtkShaderRepository : public IShaderRepository { protected: class Shader : public IShaderRepository::Shader { public: mitkClassMacro(Shader, IShaderRepository::Shader) itkFactorylessNewMacro(Self) class Uniform : public itk::Object { public: mitkClassMacroItkParent(Uniform, itk::Object) itkFactorylessNewMacro(Self) enum Type { glsl_none, glsl_float, glsl_vec2, glsl_vec3, glsl_vec4, glsl_int, glsl_ivec2, glsl_ivec3, glsl_ivec4 }; /** * Constructor */ Uniform(); /** * Destructor */ ~Uniform(); Type type; std::string name; int defaultInt[4]; float defaultFloat[4]; void LoadFromXML(vtkXMLDataElement *e); }; std::list uniforms; /** * Constructor */ Shader(); /** * Destructor */ ~Shader(); void SetVertexShaderCode(const std::string &code); std::string GetVertexShaderCode() const; void SetFragmentShaderCode(const std::string &code); std::string GetFragmentShaderCode() const; void SetGeometryShaderCode(const std::string &code); std::string GetGeometryShaderCode() const; std::list GetUniforms() const; private: friend class VtkShaderRepository; std::string m_VertexShaderCode; std::string m_FragmentShaderCode; std::string m_GeometryShaderCode; void LoadXmlShader(std::istream &stream); }; void LoadShaders(); Shader::Pointer GetShaderImpl(const std::string &name) const; private: std::list shaders; static int shaderId; static const bool debug; public: /** * Constructor */ VtkShaderRepository(); /** * Destructor */ ~VtkShaderRepository(); ShaderProgram::Pointer CreateShaderProgram() override; std::list GetShaders() const override; IShaderRepository::Shader::Pointer GetShader(const std::string &name) const override; IShaderRepository::Shader::Pointer GetShader(int id) const override; /** \brief Adds all parsed shader uniforms to property list of the given DataNode; * used by mappers. */ - void AddDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite) const override; + void AddDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite, std::string property_name="shader") const override; /** \brief Applies shader and shader specific variables of the specified DataNode * to the VTK object by updating the shader variables of its vtkProperty. */ int LoadShader(std::istream &stream, const std::string &name) override; bool UnloadShader(int id) override; void UpdateShaderProgram(mitk::IShaderRepository::ShaderProgram *shaderProgram, DataNode *node, - BaseRenderer *renderer) const override; + BaseRenderer *renderer, + std::string property_name="shader") const override; }; } // end of namespace mitk #endif diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp index 7fe4b64111..d4c5354c89 100644 --- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp +++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp @@ -1,1179 +1,1356 @@ /*=================================================================== 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. ===================================================================*/ #include "QmitkControlVisualizationPropertiesView.h" #include "mitkNodePredicateDataType.h" #include "mitkDataNodeObject.h" #include "mitkOdfNormalizationMethodProperty.h" #include "mitkOdfScaleByProperty.h" #include "mitkResliceMethodProperty.h" #include "mitkRenderingManager.h" #include "mitkTbssImage.h" #include "mitkPlanarFigure.h" #include "mitkFiberBundle.h" #include "QmitkDataStorageComboBox.h" #include "mitkPlanarFigureInteractor.h" #include #include #include #include #include #include "usModuleRegistry.h" #include #include "mitkPlaneGeometry.h" #include #include "berryIWorkbenchWindow.h" #include "berryIWorkbenchPage.h" #include "berryISelectionService.h" #include "berryConstants.h" #include "berryPlatformUI.h" #include "itkRGBAPixel.h" #include #include "qwidgetaction.h" #include "qcolordialog.h" #include #include #include #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a))) const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview"; using namespace berry; QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView() : QmitkAbstractView(), m_Controls(nullptr), m_CurrentSelection(0), m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")), m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")), m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")), m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")), m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")), m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")), m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")), m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")), m_GlyIsOn_T(false), m_GlyIsOn_C(false), m_GlyIsOn_S(false), m_CurrentPickingNode(0), m_FiberBundleObserverTag(0), m_FiberBundleObserveOpacityTag(0) { currentThickSlicesMode = 1; m_MyMenu = nullptr; int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads(); if (numThread > 12) numThread = 12; itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread); } QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView() { this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener.data()); } void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action ) { currentThickSlicesMode = action->data().toInt(); switch( currentThickSlicesMode ) { - case 0: // toInt() returns 0 'otherwise'. - return; // dummy code/todo: implement stuff. + case 0: // toInt() returns 0 'otherwise'. + return; // dummy code/todo: implement stuff. - case 1: - this->m_Controls->m_TSMenu->setText("MIP"); - break; + case 1: + this->m_Controls->m_TSMenu->setText("MIP"); + break; - case 2: - this->m_Controls->m_TSMenu->setText("SUM"); - break; + case 2: + this->m_Controls->m_TSMenu->setText("SUM"); + break; - case 3: - this->m_Controls->m_TSMenu->setText("WEIGH"); - break; + case 3: + this->m_Controls->m_TSMenu->setText("WEIGH"); + break; - default: - return; // dummy code/todo: implement stuff. + default: + return; // dummy code/todo: implement stuff. } if (auto renderWindowPart = this->GetRenderWindowPart(OPEN)) { /// TODO There is no way to access the individual crosshair planes through the render window part API. /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const' /// function for this purpose. For the time being, I comment out the lines below, but they are valid /// and they have to be re-enabled after the crosshair planes can be accessed again. -// mitk::DataNode* n; -// n = renderWindowPart->GetSlicingPlane("axial"); -// if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } + // mitk::DataNode* n; + // n = renderWindowPart->GetSlicingPlane("axial"); + // if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } -// n = renderWindowPart->GetSlicingPlane("sagittal"); -// if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } + // n = renderWindowPart->GetSlicingPlane("sagittal"); + // if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } -// n = renderWindowPart->GetSlicingPlane("coronal"); -// if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } + // n = renderWindowPart->GetSlicingPlane("coronal"); + // if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); } mitk::BaseRenderer::Pointer renderer; renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer(); if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer(); if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer(); if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer->GetRenderingManager()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::OnTSNumChanged( int num ) { if (auto renderWindowPart = this->GetRenderWindowPart(OPEN)) { /// TODO There is no way to access the individual crosshair planes through the render window part API. /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const' /// function for this purpose. For the time being, I comment out the lines below, but they are valid /// and they have to be re-enabled after the crosshair planes can be accessed again. -// if(num==0) -// { -// mitk::DataNode* n; -// n = renderWindowPart->GetSlicingPlane("axial"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); -// -// n = renderWindowPart->GetSlicingPlane("sagittal"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); -// -// n = renderWindowPart->GetSlicingPlane("coronal"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); -// } -// else -// { -// mitk::DataNode* n; -// n = renderWindowPart->GetSlicingPlane("axial"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); -// -// n = renderWindowPart->GetSlicingPlane("sagittal"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); -// -// n = renderWindowPart->GetSlicingPlane("coronal"); -// if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); -// if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); -// if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); -// } + // if(num==0) + // { + // mitk::DataNode* n; + // n = renderWindowPart->GetSlicingPlane("axial"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); + // + // n = renderWindowPart->GetSlicingPlane("sagittal"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); + // + // n = renderWindowPart->GetSlicingPlane("coronal"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) ); + // } + // else + // { + // mitk::DataNode* n; + // n = renderWindowPart->GetSlicingPlane("axial"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); + // + // n = renderWindowPart->GetSlicingPlane("sagittal"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); + // + // n = renderWindowPart->GetSlicingPlane("coronal"); + // if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); + // if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) ); + // if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) ); + // } m_TSLabel->setText(QString::number( num*2 + 1 )); mitk::BaseRenderer::Pointer renderer; renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer(); if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer = nullptr; renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer(); if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer = nullptr; renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer(); if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); } renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS); } } void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent) { if (!m_Controls) { // create GUI widgets m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls; m_Controls->setupUi(parent); this->CreateConnections(); // hide warning (ODFs in rotated planes) m_Controls->m_lblRotatedPlanesWarning->hide(); m_MyMenu = new QMenu(parent); m_Controls->m_TSMenu->setMenu( m_MyMenu ); QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png"); m_Controls->m_FiberFading2D->setIcon(iconFiberFade); #ifndef DIFFUSION_IMAGING_EXTENDED int size = m_Controls->m_AdditionalScaling->count(); for(int t=0; tm_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR") { m_Controls->m_AdditionalScaling->removeItem(t); } } #endif m_Controls->m_ScalingFrame->setVisible(false); m_Controls->m_NormalizationFrame->setVisible(false); m_Controls->m_Crosshair->setVisible(false); } } void QmitkControlVisualizationPropertiesView::SetFocus() { m_Controls->m_TSMenu->setFocus(); } void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&) { // test if plane rotated if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S ) { if( this->IsPlaneRotated() ) { // show label m_Controls->m_lblRotatedPlanesWarning->show(); } else { //hide label m_Controls->m_lblRotatedPlanesWarning->hide(); } } } void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* /*node*/) { } #include void QmitkControlVisualizationPropertiesView::CreateConnections() { if ( m_Controls ) { connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) ); connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) ); connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) ); connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) ); connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) ); connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) ); connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) ); connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) ); connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring())); connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) ); connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) ); connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) )); connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor())); connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged())); connect((QObject*) m_Controls->m_TubeWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(TubeRadiusChanged())); connect( (QObject*) m_Controls->m_EllipsoidViewRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnTensorViewChanged() ) ); connect( (QObject*) m_Controls->m_colouriseRainbowRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnColourisationModeChanged() ) ); connect( (QObject*) m_Controls->m_randomModeRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnRandomModeChanged() ) ); + connect((QObject*) m_Controls->m_Clip0, SIGNAL(toggled(bool)), (QObject*) this, SLOT(Toggle3DClipping(bool))); + connect((QObject*) m_Controls->m_Clip1, SIGNAL(toggled(bool)), (QObject*) this, SLOT(Toggle3DClipping(bool))); + connect((QObject*) m_Controls->m_Clip2, SIGNAL(toggled(bool)), (QObject*) this, SLOT(Toggle3DClipping(bool))); + connect((QObject*) m_Controls->m_Clip3, SIGNAL(toggled(bool)), (QObject*) this, SLOT(Toggle3DClipping(bool))); + connect((QObject*) m_Controls->m_FlipClipBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(Toggle3DClipping())); } } // set diffusion image channel to b0 volume void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node) { mitk::DataNode* notConst = const_cast(node); bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast(node->GetData())) ); if (isDiffusionImage) { mitk::Image::Pointer dimg = dynamic_cast(notConst->GetData()); // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0 // and hence we cannot set the Property directly to .front() int displayChannelPropertyValue = 0; mitk::BValueMapProperty* bmapproperty = static_cast - (dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() ); + (dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() ); mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap(); if( map[0].size() > 0) { displayChannelPropertyValue = map[0].front(); } notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue ); } } /* OnSelectionChanged is registered to SelectionService, therefore no need to implement SelectionService Listener explicitly */ void QmitkControlVisualizationPropertiesView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList& nodes) { m_Controls->m_BundleControlsFrame->setVisible(false); m_Controls->m_ImageControlsFrame->setVisible(false); if (nodes.size()>1) // only do stuff if one node is selected return; m_Controls->m_NumberGlyphsFrame->setVisible(false); m_Controls->m_GlyphFrame->setVisible(false); m_Controls->m_TSMenu->setVisible(false); m_SelectedNode = nullptr; int numOdfImages = 0; for (mitk::DataNode::Pointer node: nodes) { if(node.IsNull()) continue; mitk::BaseData* nodeData = node->GetData(); if(nodeData == nullptr) continue; m_SelectedNode = node; if (dynamic_cast(nodeData)) { + int Fiber3DClippingPlaneId; + m_SelectedNode->GetPropertyValue("Fiber3DClippingPlaneId",Fiber3DClippingPlaneId); + switch(Fiber3DClippingPlaneId) + { + case 0: + m_Controls->m_Clip0->setChecked(1); + break; + case 1: + m_Controls->m_Clip1->setChecked(1); + break; + case 2: + m_Controls->m_Clip2->setChecked(1); + break; + case 3: + m_Controls->m_Clip3->setChecked(1); + break; + default : + m_Controls->m_Clip0->setChecked(1); + } + // handle fiber bundle property observers if (m_Color.IsNotNull()) { m_Color->RemoveObserver(m_FiberBundleObserverTag); } itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor ); m_Color = dynamic_cast(node->GetProperty("color", nullptr)); if (m_Color.IsNotNull()) m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command ); if (m_Opacity.IsNotNull()) { m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag); } itk::ReceptorMemberCommand::Pointer command2 = itk::ReceptorMemberCommand::New(); command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity ); m_Opacity = dynamic_cast(node->GetProperty("opacity", nullptr)); if (m_Opacity.IsNotNull()) { m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 ); } m_Controls->m_BundleControlsFrame->setVisible(true); if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode) { m_Controls->m_Crosshair->setEnabled(false); } else { m_Controls->m_Crosshair->setEnabled(true); } int width; node->GetIntProperty("shape.linewidth", width); m_Controls->m_LineWidth->setValue(width); float radius; node->GetFloatProperty("shape.tuberadius", radius); m_Controls->m_TubeWidth->setValue(radius); float range; node->GetFloatProperty("Fiber2DSliceThickness",range); mitk::FiberBundle::Pointer fib = dynamic_cast(node->GetData()); mitk::BaseGeometry::Pointer geo = fib->GetGeometry(); mitk::ScalarType max = geo->GetExtentInMM(0); max = std::max(max, geo->GetExtentInMM(1)); max = std::max(max, geo->GetExtentInMM(2)); m_Controls->m_FiberThicknessSlider->setMaximum(max * 10); m_Controls->m_FiberThicknessSlider->setValue(range * 10); } else if(dynamic_cast(nodeData) || dynamic_cast(nodeData)) { m_Controls->m_ImageControlsFrame->setVisible(true); m_Controls->m_NumberGlyphsFrame->setVisible(true); m_Controls->m_GlyphFrame->setVisible(true); m_Controls->m_NormalizationFrame->setVisible(true); if(m_NodeUsedForOdfVisualization.IsNotNull()) { m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false); } m_NodeUsedForOdfVisualization = node; m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C); m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T); int val; node->GetIntProperty("ShowMaxNumber", val); m_Controls->m_ShowMaxNumber->setValue(val); m_Controls->m_NormalizationDropdown ->setCurrentIndex(dynamic_cast(node->GetProperty("Normalization")) ->GetValueAsId()); float fval; node->GetFloatProperty("Scaling",fval); m_Controls->m_ScalingFactor->setValue(fval); m_Controls->m_AdditionalScaling ->setCurrentIndex(dynamic_cast(node->GetProperty("ScaleBy"))->GetValueAsId()); bool switchTensorViewValue = false; node->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", switchTensorViewValue ); if( dynamic_cast(nodeData) ) { m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( true ); m_Controls-> m_EllipsoidViewRadioButton-> setChecked( switchTensorViewValue ); } else { m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( false ); m_Controls-> m_EllipsoidViewRadioButton-> setChecked( false ); } bool colourisationModeBit = false; node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", colourisationModeBit ); m_Controls-> m_colouriseSimpleRadioButton-> setChecked( colourisationModeBit ); bool randomModeBit = false; node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", randomModeBit ); m_Controls-> m_randomModeRadioButton-> setChecked( randomModeBit ); numOdfImages++; } else if(dynamic_cast(nodeData)) { PlanarFigureFocus(); } else if( dynamic_cast(nodeData) ) { m_Controls->m_ImageControlsFrame->setVisible(true); m_Controls->m_TSMenu->setVisible(true); } } if( nodes.empty() ) { return; } mitk::DataNode::Pointer node = nodes.at(0); if( node.IsNull() ) { return; } QMenu *myMenu = m_MyMenu; myMenu->clear(); QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu); thickSlicesActionGroup->setExclusive(true); int currentTSMode = 0; { mitk::ResliceMethodProperty::Pointer m = dynamic_cast(node->GetProperty( "reslice.thickslices" )); if( m.IsNotNull() ) currentTSMode = m->GetValueAsId(); } int maxTS = 30; for (auto node: nodes) { mitk::Image* image = dynamic_cast(node->GetData()); if (image) { int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2))); if (size>maxTS) { maxTS=size; } } } maxTS /= 2; int currentNum = 0; { mitk::IntProperty::Pointer m = dynamic_cast(node->GetProperty( "reslice.thickslices.num" )); if( m.IsNotNull() ) { currentNum = m->GetValue(); if(currentNum < 0) { currentNum = 0; } if(currentNum > maxTS) { currentNum = maxTS; } } } if(currentTSMode==0) { currentNum=0; } QSlider *m_TSSlider = new QSlider(myMenu); m_TSSlider->setMinimum(0); m_TSSlider->setMaximum(maxTS-1); m_TSSlider->setValue(currentNum); m_TSSlider->setOrientation(Qt::Horizontal); connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) ); QHBoxLayout* _TSLayout = new QHBoxLayout; _TSLayout->setContentsMargins(4,4,4,4); _TSLayout->addWidget(m_TSSlider); _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu)); QWidget* _TSWidget = new QWidget; _TSWidget->setLayout(_TSLayout); QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu); thickSliceModeActionGroup->setExclusive(true); QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu); m_TSSliderAction->setDefaultWidget(_TSWidget); myMenu->addAction(m_TSSliderAction); QAction* mipThickSlicesAction = new QAction(myMenu); mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup); mipThickSlicesAction->setText("MIP (max. intensity proj.)"); mipThickSlicesAction->setCheckable(true); mipThickSlicesAction->setChecked(currentThickSlicesMode==1); mipThickSlicesAction->setData(1); myMenu->addAction( mipThickSlicesAction ); QAction* sumThickSlicesAction = new QAction(myMenu); sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup); sumThickSlicesAction->setText("SUM (sum intensity proj.)"); sumThickSlicesAction->setCheckable(true); sumThickSlicesAction->setChecked(currentThickSlicesMode==2); sumThickSlicesAction->setData(2); myMenu->addAction( sumThickSlicesAction ); QAction* weightedThickSlicesAction = new QAction(myMenu); weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup); weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)"); weightedThickSlicesAction->setCheckable(true); weightedThickSlicesAction->setChecked(currentThickSlicesMode==3); weightedThickSlicesAction->setData(3); myMenu->addAction( weightedThickSlicesAction ); connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) ); } void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S() { m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked(); if (m_NodeUsedForOdfVisualization.IsNull()) { MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr"; return; } m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } +void QmitkControlVisualizationPropertiesView::Visible() +{ + mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + + if (renderWindow) + { + { + mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController(); + itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); + command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::OnAxialChanged ); + m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command ); + } + + { + mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController(); + itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); + command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::OnSagittalChanged ); + m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command ); + } + + { + mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController(); + itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); + command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::OnCoronalChanged ); + m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0), command ); + } + } +} + +void QmitkControlVisualizationPropertiesView::Hidden() +{ + mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + + if (renderWindow) + { + mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController(); + slicer->RemoveObserver(m_SliceObserverTag1); + slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController(); + slicer->RemoveObserver(m_SliceObserverTag2); + slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController(); + slicer->RemoveObserver(m_SliceObserverTag3); + } +} + +void QmitkControlVisualizationPropertiesView::Activated() +{ +} + +void QmitkControlVisualizationPropertiesView::Deactivated() +{ +} + +void QmitkControlVisualizationPropertiesView::Toggle3DClipping(bool enabled) +{ + if (!enabled || m_SelectedNode.IsNull() || dynamic_cast(m_SelectedNode->GetData())==nullptr) + return; + + m_SelectedNode->SetBoolProperty( "Fiber3DClippingPlaneFlip", m_Controls->m_FlipClipBox->isChecked() ); + + if (m_Controls->m_Clip0->isChecked()) + { + m_SelectedNode->SetIntProperty( "Fiber3DClippingPlaneId", 0 ); + Set3DClippingPlane(true, m_SelectedNode, ""); + } + else if (m_Controls->m_Clip1->isChecked()) + { + m_SelectedNode->SetIntProperty( "Fiber3DClippingPlaneId", 1 ); + Set3DClippingPlane(false, m_SelectedNode, "axial"); + } + else if (m_Controls->m_Clip2->isChecked()) + { + m_SelectedNode->SetIntProperty( "Fiber3DClippingPlaneId", 2 ); + Set3DClippingPlane(false, m_SelectedNode, "sagittal"); + } + else if (m_Controls->m_Clip3->isChecked()) + { + m_SelectedNode->SetIntProperty( "Fiber3DClippingPlaneId", 3 ); + Set3DClippingPlane(false, m_SelectedNode, "coronal"); + } + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); +} + + +void QmitkControlVisualizationPropertiesView::OnAxialChanged(const itk::EventObject& ) +{ + mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll(); + for (unsigned int i=0; iSize(); ++i) + { + mitk::DataNode::Pointer node = nodes->GetElement(i); + int plane_id = -1; + node->GetIntProperty("Fiber3DClippingPlaneId", plane_id); + if (plane_id==1) + Set3DClippingPlane(false, node, "axial"); + } + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); +} + +void QmitkControlVisualizationPropertiesView::OnCoronalChanged(const itk::EventObject& ) +{ + mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll(); + for (unsigned int i=0; iSize(); ++i) + { + mitk::DataNode::Pointer node = nodes->GetElement(i); + int plane_id = -1; + node->GetIntProperty("Fiber3DClippingPlaneId", plane_id); + if (plane_id==3) + Set3DClippingPlane(false, node, "coronal"); + } + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); +} + +void QmitkControlVisualizationPropertiesView::OnSagittalChanged(const itk::EventObject& ) +{ + mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll(); + for (unsigned int i=0; iSize(); ++i) + { + mitk::DataNode::Pointer node = nodes->GetElement(i); + int plane_id = -1; + node->GetIntProperty("Fiber3DClippingPlaneId", plane_id); + if (plane_id==2) + Set3DClippingPlane(false, node, "sagittal"); + } + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); +} + +void QmitkControlVisualizationPropertiesView::Set3DClippingPlane(bool disable, mitk::DataNode* node, std::string plane) +{ + mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + + if (renderWindow && node && dynamic_cast(node->GetData())) + { + mitk::Vector3D planeNormal; planeNormal.Fill(0.0); + if (!disable) + { + mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString(plane.c_str()))->GetSliceNavigationController(); + mitk::PlaneGeometry::ConstPointer planeGeo = slicer->GetCurrentPlaneGeometry(); + + //generate according cutting planes based on the view position + planeNormal = planeGeo->GetNormal(); + + float tmp1 = planeGeo->GetOrigin()[0] * planeNormal[0]; + float tmp2 = planeGeo->GetOrigin()[1] * planeNormal[1]; + float tmp3 = planeGeo->GetOrigin()[2] * planeNormal[2]; + float distance = tmp1 + tmp2 + tmp3; //attention, correct normalvector + + planeNormal *= distance; + } + + node->SetProperty( "Fiber3DClippingPlane", mitk::Vector3DProperty::New( planeNormal ) ); + dynamic_cast(node->GetData())->RequestUpdate(); + } +} void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T() { m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked(); if (m_NodeUsedForOdfVisualization.IsNull()) { MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr"; return; } m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C() { m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked(); if (m_NodeUsedForOdfVisualization.IsNull()) { MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is nullptr"; return; } m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } bool QmitkControlVisualizationPropertiesView::IsPlaneRotated() { mitk::Image* currentImage = dynamic_cast( m_NodeUsedForOdfVisualization->GetData() ); if( currentImage == nullptr ) { MITK_ERROR << " Casting problems. Returning false"; return false; } mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0); mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1); mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2); imageNormal0.Normalize(); imageNormal1.Normalize(); imageNormal2.Normalize(); auto renderWindowPart = this->GetRenderWindowPart(); double eps = 0.000001; // for all 2D renderwindows of the render window part check alignment { mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast - ( renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); + ( renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); if (displayPlane.IsNull()) { return false; } mitk::Vector3D normal = displayPlane->GetNormal(); normal.Normalize(); int test = 0; if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; } if (test==3) { return true; } } { mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast - ( renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); + ( renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); if (displayPlane.IsNull()) { return false; } mitk::Vector3D normal = displayPlane->GetNormal(); normal.Normalize(); int test = 0; if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; } if (test==3) { return true; } } { mitk::PlaneGeometry::ConstPointer displayPlane = dynamic_cast - ( renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); + ( renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetCurrentWorldPlaneGeometry() ); if (displayPlane.IsNull()) { return false; } mitk::Vector3D normal = displayPlane->GetNormal(); normal.Normalize(); int test = 0; if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; } if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; } if (test==3) { return true; } } return false; } void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged() { int maxNr = m_Controls->m_ShowMaxNumber->value(); if ( maxNr < 1 ) { m_Controls->m_ShowMaxNumber->setValue( 1 ); maxNr = 1; } if ( dynamic_cast(m_SelectedNode->GetData()) || dynamic_cast(m_SelectedNode->GetData()) ) { m_SelectedNode->SetIntProperty("ShowMaxNumber", maxNr); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown) { typedef mitk::OdfNormalizationMethodProperty PropType; PropType::Pointer normMeth = PropType::New(); switch(normDropdown) { - case 0: - normMeth->SetNormalizationToMinMax(); + case 0: + normMeth->SetNormalizationToMinMax(); break; - case 1: - normMeth->SetNormalizationToMax(); + case 1: + normMeth->SetNormalizationToMax(); break; - case 2: - normMeth->SetNormalizationToNone(); + case 2: + normMeth->SetNormalizationToNone(); break; - case 3: - normMeth->SetNormalizationToGlobalMax(); + case 3: + normMeth->SetNormalizationToGlobalMax(); break; - default: - normMeth->SetNormalizationToMinMax(); + default: + normMeth->SetNormalizationToMinMax(); } if ( dynamic_cast(m_SelectedNode->GetData()) || dynamic_cast(m_SelectedNode->GetData()) ) { m_SelectedNode->SetProperty("Normalization", normMeth.GetPointer()); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor) { if ( dynamic_cast(m_SelectedNode->GetData()) || dynamic_cast(m_SelectedNode->GetData()) ) { m_SelectedNode->SetFloatProperty("Scaling", scalingFactor); } if (auto renderWindowPart = this->GetRenderWindowPart()) { renderWindowPart->RequestUpdate(); } } void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling) { typedef mitk::OdfScaleByProperty PropType; PropType::Pointer scaleBy = PropType::New(); switch(additionalScaling) { - case 0: - scaleBy->SetScaleByNothing(); + case 0: + scaleBy->SetScaleByNothing(); break; - case 1: - scaleBy->SetScaleByGFA(); - //m_Controls->params_frame->setVisible(true); + case 1: + scaleBy->SetScaleByGFA(); + //m_Controls->params_frame->setVisible(true); break; #ifdef DIFFUSION_IMAGING_EXTENDED - case 2: - scaleBy->SetScaleByPrincipalCurvature(); - // commented in for SPIE paper, Principle curvature scaling - //m_Controls->params_frame->setVisible(true); + case 2: + scaleBy->SetScaleByPrincipalCurvature(); + // commented in for SPIE paper, Principle curvature scaling + //m_Controls->params_frame->setVisible(true); break; #endif - default: - scaleBy->SetScaleByNothing(); + default: + scaleBy->SetScaleByNothing(); } if ( dynamic_cast(m_SelectedNode->GetData()) || dynamic_cast(m_SelectedNode->GetData()) ) { m_SelectedNode->SetProperty("Normalization", scaleBy.GetPointer()); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkControlVisualizationPropertiesView::ScalingCheckbox() { m_Controls->m_ScalingFrame->setVisible( m_Controls->m_ScalingCheckbox->isChecked() ); if( ! m_Controls->m_ScalingCheckbox->isChecked() ) { m_Controls->m_AdditionalScaling->setCurrentIndex(0); m_Controls->m_ScalingFactor->setValue(1.0); } } void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX() { if (m_SelectedNode && dynamic_cast(m_SelectedNode->GetData()) ) { bool currentMode; m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode); m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode)); dynamic_cast(m_SelectedNode->GetData())->RequestUpdate2D(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D() { if (m_SelectedNode && dynamic_cast(m_SelectedNode->GetData())) { float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1; float currentThickness = 0; m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness); if ( fabs(fibThickness-currentThickness) < 0.001 ) { return; } m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness)); dynamic_cast(m_SelectedNode->GetData())->RequestUpdate2D(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value) { QString label = "Range %1 mm"; label = label.arg(value * 0.1); m_Controls->label_range->setText(label); FiberSlicingThickness2D(); } void QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity(const itk::EventObject& /*e*/) { if(m_SelectedNode) { mitk::FiberBundle::Pointer fib = dynamic_cast(m_SelectedNode->GetData()); fib->RequestUpdate(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/) { if(m_SelectedNode && dynamic_cast(m_SelectedNode->GetData())) { float color[3]; m_SelectedNode->GetColor(color); mitk::FiberBundle::Pointer fib = dynamic_cast(m_SelectedNode->GetData()); fib->SetFiberColors(color[0]*255, color[1]*255, color[2]*255); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring() { if(m_SelectedNode && dynamic_cast(m_SelectedNode->GetData())) { mitk::FiberBundle::Pointer fib = dynamic_cast(m_SelectedNode->GetData()); fib->ColorFibersByOrientation(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::PlanarFigureFocus() { if(m_SelectedNode) { mitk::PlanarFigure* _PlanarFigure = 0; _PlanarFigure = dynamic_cast (m_SelectedNode->GetData()); if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry()) { QmitkRenderWindow* selectedRenderWindow = 0; bool PlanarFigureInitializedWindow = false; auto renderWindowPart = this->GetRenderWindowPart(OPEN); QmitkRenderWindow* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial"); if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer())) { selectedRenderWindow = axialRenderWindow; } QmitkRenderWindow* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal"); if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty( "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, sagittalRenderWindow->GetRenderer())) { selectedRenderWindow = sagittalRenderWindow; } QmitkRenderWindow* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal"); if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty( "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, coronalRenderWindow->GetRenderer())) { selectedRenderWindow = coronalRenderWindow; } QmitkRenderWindow* _3DRenderWindow = renderWindowPart->GetQmitkRenderWindow("3d"); if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty( "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, _3DRenderWindow->GetRenderer())) { selectedRenderWindow = _3DRenderWindow; } const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry(); mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl(); mitk::Geometry2D::ConstPointer worldGeometry1 = axialRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry(); mitk::PlaneGeometry::ConstPointer _Plane1 = dynamic_cast( worldGeometry1.GetPointer() ); mitk::VnlVector normal1 = _Plane1->GetNormalVnl(); mitk::Geometry2D::ConstPointer worldGeometry2 = sagittalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry(); mitk::PlaneGeometry::ConstPointer _Plane2 = dynamic_cast( worldGeometry2.GetPointer() ); mitk::VnlVector normal2 = _Plane2->GetNormalVnl(); mitk::Geometry2D::ConstPointer worldGeometry3 = coronalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry(); mitk::PlaneGeometry::ConstPointer _Plane3 = dynamic_cast( worldGeometry3.GetPointer() ); mitk::VnlVector normal3 = _Plane3->GetNormalVnl(); normal[0] = fabs(normal[0]); normal[1] = fabs(normal[1]); normal[2] = fabs(normal[2]); normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]); normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]); normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]); double ang1 = angle(normal, normal1); double ang2 = angle(normal, normal2); double ang3 = angle(normal, normal3); if(ang1 < ang2 && ang1 < ang3) { selectedRenderWindow = axialRenderWindow; } else { if(ang2 < ang3) { selectedRenderWindow = sagittalRenderWindow; } else { selectedRenderWindow = coronalRenderWindow; } } // make node visible if (selectedRenderWindow) { const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin(); selectedRenderWindow->GetSliceNavigationController()->ReorientSlices( centerP, _PlaneGeometry->GetNormal()); } } // set interactor for new node (if not already set) mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast(m_SelectedNode->GetDataInteractor().GetPointer()); if(figureInteractor.IsNull()) { figureInteractor = mitk::PlanarFigureInteractor::New(); us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" ); figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule ); figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule ); figureInteractor->SetDataNode( m_SelectedNode ); } m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true)); } } void QmitkControlVisualizationPropertiesView::SetInteractor() { // BUG 19179 // typedef std::vector Container; // Container _NodeSet = this->GetDataManagerSelection(); // mitk::DataNode* node = 0; // mitk::FiberBundle* bundle = 0; // mitk::FiberBundleInteractor::Pointer bundleInteractor = 0; // // finally add all nodes to the model // for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end() // ; it++) // { // node = const_cast(*it); // bundle = dynamic_cast(node->GetData()); // if(bundle) // { // bundleInteractor = dynamic_cast(node->GetInteractor()); // if(bundleInteractor.IsNotNull()) // mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor); // if(!m_Controls->m_Crosshair->isChecked()) // { // m_Controls->m_Crosshair->setChecked(false); // this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor); // m_CurrentPickingNode = 0; // } // else // { // m_Controls->m_Crosshair->setChecked(true); // bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node); // mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor); // this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor); // m_CurrentPickingNode = node; // } // } // } } void QmitkControlVisualizationPropertiesView::TubeRadiusChanged() { if(m_SelectedNode && dynamic_cast(m_SelectedNode->GetData())) { float newRadius = m_Controls->m_TubeWidth->value(); m_SelectedNode->SetFloatProperty("shape.tuberadius", newRadius); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::LineWidthChanged() { if(m_SelectedNode && dynamic_cast(m_SelectedNode->GetData())) { int newWidth = m_Controls->m_LineWidth->value(); int currentWidth = 0; m_SelectedNode->GetIntProperty("shape.linewidth", currentWidth); if (currentWidth==newWidth) return; m_SelectedNode->SetIntProperty("shape.linewidth", newWidth); dynamic_cast(m_SelectedNode->GetData())->RequestUpdate(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkControlVisualizationPropertiesView::Welcome() { berry::PlatformUI::GetWorkbench()->GetIntroManager() ->ShowIntro(GetSite()->GetWorkbenchWindow(), false); } void QmitkControlVisualizationPropertiesView::OnTensorViewChanged() { if( m_NodeUsedForOdfVisualization.IsNotNull() ) { if( m_Controls-> m_EllipsoidViewRadioButton-> isChecked() ) { if ( m_SelectedNode and dynamic_cast( m_SelectedNode->GetData() ) ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( true ) ); mitk::OdfNormalizationMethodProperty::Pointer normalizationProperty = mitk::OdfNormalizationMethodProperty::New( mitk::ODFN_MAX ); m_SelectedNode-> SetProperty( "Normalization", normalizationProperty ); // type OdfNormalizationMethodProperty m_Controls-> m_NormalizationDropdown->setCurrentIndex ( dynamic_cast( m_SelectedNode->GetProperty("Normalization") )->GetValueAsId() ); } else { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) ); m_Controls-> m_OdfViewRadioButton-> setChecked(true); m_Controls-> m_EllipsoidViewRadioButton-> setEnabled(false); } } else if( m_Controls-> m_OdfViewRadioButton-> isChecked() ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) ); } mitk::RenderingManager::GetInstance()-> RequestUpdateAll(); } else { MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnTensorViewChanged()" " was called but m_NodeUsedForOdfVisualization was Null."; } } void QmitkControlVisualizationPropertiesView::OnColourisationModeChanged() { if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() ) { if( m_Controls-> m_colouriseRainbowRadioButton-> isChecked() ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( false ) ); } else if ( m_Controls-> m_colouriseSimpleRadioButton-> isChecked() ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( true ) ); } mitk::RenderingManager::GetInstance()-> RequestUpdateAll(); } else { MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnColourisationModeChanged()" " was called but m_NodeUsedForOdfVisualization was Null."; } } void QmitkControlVisualizationPropertiesView::OnRandomModeChanged() { if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() ) { if( m_Controls-> m_randomModeRadioButton-> isChecked() ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( true ) ); } else if ( m_Controls-> m_orderedModeRadioButton-> isChecked() ) { m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( false ) ); } mitk::RenderingManager::GetInstance()-> RequestUpdateAll(); } else { MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnRandomModeChanged()" " was called but m_NodeUsedForOdfVisualization was Null."; } } diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h index 3b82573dfd..f5df394c6f 100644 --- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h +++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h @@ -1,153 +1,167 @@ /*=================================================================== 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 _QMITKControlVisualizationPropertiesView_H_INCLUDED #define _QMITKControlVisualizationPropertiesView_H_INCLUDED #include #include #include "berryISelectionListener.h" #include "berryIStructuredSelection.h" #include "berryISizeProvider.h" #include "ui_QmitkControlVisualizationPropertiesViewControls.h" #include "mitkEnumerationProperty.h" +#include /*! * \ingroup org_mitk_gui_qt_diffusionquantification_internal * * \brief QmitkControlVisualizationPropertiesView * * Document your class here. */ -class QmitkControlVisualizationPropertiesView : public QmitkAbstractView//, public berry::ISizeProvider +class QmitkControlVisualizationPropertiesView : public QmitkAbstractView, public mitk::ILifecycleAwarePart { friend struct CvpSelListener; // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject) Q_OBJECT public: static const std::string VIEW_ID; QmitkControlVisualizationPropertiesView(); virtual ~QmitkControlVisualizationPropertiesView(); virtual void CreateQtPartControl(QWidget *parent) override; /// \brief Creation of the connections of main and control widget virtual void CreateConnections(); - /// - /// Sets the focus to an internal widget. - /// - virtual void SetFocus() override; protected slots: void VisibleOdfsON_S(); void VisibleOdfsON_T(); void VisibleOdfsON_C(); void ShowMaxNumberChanged(); void NormalizationDropdownChanged(int); void ScalingFactorChanged(double); void AdditionalScaling(int); void ScalingCheckbox(); void OnThickSlicesModeSelected( QAction* action ); void OnTSNumChanged(int num); void BundleRepresentationResetColoring(); void PlanarFigureFocus(); void Fiber2DfadingEFX(); void FiberSlicingThickness2D(); void FiberSlicingUpdateLabel(int); void LineWidthChanged(); void TubeRadiusChanged(); void SetInteractor(); + void Toggle3DClipping(bool enabled=true); void Welcome(); /// \brief Slot function for switching tensor view between ODF q-balls and ellipsoids from tensors. void OnTensorViewChanged(); /// \brief Slot function for switching colourisation mode of glyphs. void OnColourisationModeChanged(); /// \brief Slot function for switching glyph placement mode. void OnRandomModeChanged(); protected: + virtual void SetFocus() override; + virtual void Activated() override; + virtual void Deactivated() override; + virtual void Visible() override; + virtual void Hidden() override; + virtual void NodeRemoved(const mitk::DataNode* node) override; /// \brief called by QmitkAbstractView when DataManager's selection has changed virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList& nodes) override; virtual void NodeAdded(const mitk::DataNode *node) override; void SetFiberBundleCustomColor(const itk::EventObject& /*e*/); void SetFiberBundleOpacity(const itk::EventObject& /*e*/); bool IsPlaneRotated(); void SliceRotation(const itk::EventObject&); + void OnAxialChanged(const itk::EventObject& e); + void OnCoronalChanged(const itk::EventObject& e); + void OnSagittalChanged(const itk::EventObject& e); + + void Set3DClippingPlane(bool disable, mitk::DataNode *node, std::string plane); + Ui::QmitkControlVisualizationPropertiesViewControls* m_Controls; QScopedPointer m_SelListener; berry::IStructuredSelection::ConstPointer m_CurrentSelection; mitk::DataNode::Pointer m_NodeUsedForOdfVisualization; QIcon* m_IconTexOFF; QIcon* m_IconTexON; QIcon* m_IconGlyOFF_T; QIcon* m_IconGlyON_T; QIcon* m_IconGlyOFF_C; QIcon* m_IconGlyON_C; QIcon* m_IconGlyOFF_S; QIcon* m_IconGlyON_S; bool m_TexIsOn; bool m_GlyIsOn_T; bool m_GlyIsOn_C; bool m_GlyIsOn_S; int currentThickSlicesMode; QLabel* m_TSLabel; QMenu* m_MyMenu; // for planarfigure and bundle handling: mitk::DataNode::Pointer m_SelectedNode; mitk::DataNode* m_CurrentPickingNode; unsigned long m_FiberBundleObserverTag; unsigned long m_FiberBundleObserveOpacityTag; mitk::ColorProperty::Pointer m_Color; mitk::FloatProperty::Pointer m_Opacity; + + int m_SliceObserverTag1; + int m_SliceObserverTag2; + int m_SliceObserverTag3; }; #endif // _QMITKControlVisualizationPropertiesView_H_INCLUDED diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui index e6aef4db05..4840495a9e 100644 --- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui +++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui @@ -1,799 +1,861 @@ QmitkControlVisualizationPropertiesViewControls 0 0 567 619 0 100 0 0 QmitkTemplate 0 0 0 0 QFrame::NoFrame QFrame::Raised 0 0 0 0 0 0 QFrame::NoFrame QFrame::Raised 0 0 0 0 Multislice Projection MIP QToolButton::MenuButtonPopup Qt::NoArrow QFrame::NoFrame QFrame::Plain 0 0 0 0 Toggle visibility of ODF glyphs (axial) :/QmitkDiffusionImaging/glyphsoff_T.png :/QmitkDiffusionImaging/glyphson_T.png:/QmitkDiffusionImaging/glyphsoff_T.png true false Toggle visibility of ODF glyphs (sagittal) :/QmitkDiffusionImaging/glyphsoff_S.png :/QmitkDiffusionImaging/glyphson_S.png:/QmitkDiffusionImaging/glyphsoff_S.png true false Toggle visibility of ODF glyphs (coronal) :/QmitkDiffusionImaging/glyphsoff_C.png :/QmitkDiffusionImaging/glyphson_C.png:/QmitkDiffusionImaging/glyphsoff_C.png true false #Glyphs 9999 Qt::Horizontal 20 20 QFrame::NoFrame QFrame::Raised 0 0 0 0 0 QFrame::NoFrame QFrame::Raised 0 0 0 0 Scaling QFrame::NoFrame QFrame::Plain 0 0 0 0 false None By GFA By ASR * Additional scaling factor 3 999999999.000000000000000 0.100000000000000 1.000000000000000 QFrame::NoFrame QFrame::Plain 0 0 0 0 &ODF View true buttonGroup_2 true &Rainbow colorization true buttonGroup true E&llipsoid View buttonGroup_2 false &Simple colorization buttonGroup ODF normalization false Min-Max Max None true Random Placement true buttonGroup_3 true Orderer Placement buttonGroup_3 QFrame::NoFrame QFrame::Raised 0 0 0 0 QFrame::NoFrame QFrame::Raised 0 0 0 0 Reset to Default Coloring :/QmitkDiffusionImaging/reset.png:/QmitkDiffusionImaging/reset.png Position Crosshair by 3D-Click :/QmitkDiffusionImaging/crosshair.png:/QmitkDiffusionImaging/crosshair.png true false 2D Fiberfading on/off Qt::Horizontal 40 20 QFrame::NoFrame QFrame::Raised 0 0 0 0 2D Clipping 100 10 10 10 Qt::Horizontal 90 0 10000 16777215 Range QFrame::NoFrame QFrame::Raised 0 0 0 0 1 10 - - + + - Line Width + Tube Radius - - + + - Tube Radius + Line Width 4 0.100000000000000 + + + + 3D Fiber Clipping + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + Sagittal + + + + + + + No clipping + + + true + + + + + + + Coronal + + + + + + + Axial + + + + + + + Flipp Clipping Direction + + + + + + 50 false false <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"> <html><head><meta name="qrichtext" content="1" /><style type="text/css"> p, li { white-space: pre-wrap; } </style></head><body style=" font-family:'Ubuntu'; font-size:11pt; font-weight:400; font-style:normal;"> <p align="center" style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#ff0000;">One or more slices are rotated. ODF Visualisation is not possible in rotated planes. Use 'Reinit' on the image node to reset. </span></p></body></html> Qt::AutoText true Qt::Vertical 20 40 QmitkDataStorageComboBox.h