diff --git a/Modules/Core/include/mitkAnnotationService.h b/Modules/Core/include/mitkAnnotationService.h index b98f648f6f..dd537f9cca 100644 --- a/Modules/Core/include/mitkAnnotationService.h +++ b/Modules/Core/include/mitkAnnotationService.h @@ -1,48 +1,46 @@ /*=================================================================== 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 mitkAnnotationService_h #define mitkAnnotationService_h +#include #include #include -#include namespace mitk { class AbstractAnnotationRenderer; class MITKCORE_EXPORT AnnotationService { public: - typedef std::vector > AnnotationRendererServices; + typedef std::vector> AnnotationRendererServices; AnnotationService(); ~AnnotationService(); - static AbstractAnnotationRenderer* GetAnnotationRenderer(const std::string& arTypeID, - const std::string& rendererID); + static AbstractAnnotationRenderer *GetAnnotationRenderer(const std::string &arTypeID, + const std::string &rendererID); - static void RegisterAnnotationRenderer(AbstractAnnotationRenderer* annotationRenderer); + static void RegisterAnnotationRenderer(AbstractAnnotationRenderer *annotationRenderer); private: - - AnnotationService(const AnnotationService&); - AnnotationService& operator=(const AnnotationService&); - + AnnotationService(const AnnotationService &); + AnnotationService &operator=(const AnnotationService &); }; } #endif diff --git a/Modules/Core/src/Rendering/mitkAnnotationService.cpp b/Modules/Core/src/Rendering/mitkAnnotationService.cpp index 99bd0fe0bb..b5581b67de 100644 --- a/Modules/Core/src/Rendering/mitkAnnotationService.cpp +++ b/Modules/Core/src/Rendering/mitkAnnotationService.cpp @@ -1,68 +1,59 @@ /*=================================================================== 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 "mitkAnnotationService.h" #include namespace mitk { - -AnnotationService::AnnotationService() -{ -} - -AnnotationService::~AnnotationService() -{ -} - -AbstractAnnotationRenderer *AnnotationService::GetAnnotationRenderer(const std::string &arTypeID, - const std::string &rendererID) -{ - //get the context - us::ModuleContext* context = us::GetModuleContext(); - - //specify a filter that defines the requested type - std::string filter = "(&(" + AbstractAnnotationRenderer::US_PROPKEY_ID + - "=" + arTypeID + ")("+ AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID + - "=" + rendererID + "))"; - //find the fitting service - std::vector serviceReferences = + AnnotationService::AnnotationService() {} + AnnotationService::~AnnotationService() {} + AbstractAnnotationRenderer *AnnotationService::GetAnnotationRenderer(const std::string &arTypeID, + const std::string &rendererID) + { + // get the context + us::ModuleContext *context = us::GetModuleContext(); + + // specify a filter that defines the requested type + std::string filter = "(&(" + AbstractAnnotationRenderer::US_PROPKEY_ID + "=" + arTypeID + ")(" + + AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID + "=" + rendererID + "))"; + // find the fitting service + std::vector serviceReferences = context->GetServiceReferences(AbstractAnnotationRenderer::US_INTERFACE_NAME, filter); - //check if a service reference was found. It is also possible that several - //services were found. This is not checked here, just the first one is taken. - AbstractAnnotationRenderer* ar = nullptr; - if ( serviceReferences.size() ) - { - ar = context->GetService(serviceReferences.front()); + // check if a service reference was found. It is also possible that several + // services were found. This is not checked here, just the first one is taken. + AbstractAnnotationRenderer *ar = nullptr; + if (serviceReferences.size()) + { + ar = context->GetService(serviceReferences.front()); + } + // no service reference was found or found service reference has no valid source + return ar; } - //no service reference was found or found service reference has no valid source - return ar; -} - -void AnnotationService::RegisterAnnotationRenderer(AbstractAnnotationRenderer *annotationRenderer) -{ - static AnnotationRendererServices AnnotationRendererServices; - // Define ServiceProps - us::ServiceProperties props; - props[ AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID ] = annotationRenderer->GetRendererID(); - props[ AbstractAnnotationRenderer::US_PROPKEY_ID ] = annotationRenderer->GetID(); - - us::GetModuleContext()->RegisterService(annotationRenderer,props); - AnnotationRendererServices.push_back(std::unique_ptr(annotationRenderer)); -} + void AnnotationService::RegisterAnnotationRenderer(AbstractAnnotationRenderer *annotationRenderer) + { + static AnnotationRendererServices AnnotationRendererServices; + // Define ServiceProps + us::ServiceProperties props; + props[AbstractAnnotationRenderer::US_PROPKEY_RENDERER_ID] = annotationRenderer->GetRendererID(); + props[AbstractAnnotationRenderer::US_PROPKEY_ID] = annotationRenderer->GetID(); + + us::GetModuleContext()->RegisterService(annotationRenderer, props); + AnnotationRendererServices.push_back(std::unique_ptr(annotationRenderer)); + } } diff --git a/Modules/Core/src/Rendering/mitkOverlayManager.cpp b/Modules/Core/src/Rendering/mitkOverlayManager.cpp index c0beeeb579..67255f4f56 100644 --- a/Modules/Core/src/Rendering/mitkOverlayManager.cpp +++ b/Modules/Core/src/Rendering/mitkOverlayManager.cpp @@ -1,244 +1,249 @@ /*=================================================================== 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 "mitkOverlayManager.h" #include "mitkBaseRenderer.h" -#include #include "mitkOverlay2DLayouter.h" +#include namespace mitk { itkEventMacroDefinition(OverlayAddEvent, itk::AnyEvent) OverlayManager::OverlayManager() { } OverlayManager::~OverlayManager() { RemoveAllOverlays(); RemoveAllBaseRenderers(); } void OverlayManager::AddBaseRenderer(BaseRenderer *renderer) { - if(!renderer) - return; + if (!renderer) + return; - std::string rendererName = renderer->GetName(); - if(!m_ForegroundRenderer[rendererName]) + std::string rendererName = renderer->GetName(); + if (!m_ForegroundRenderer[rendererName]) { - m_ForegroundRenderer[rendererName] = vtkSmartPointer::New(); - vtkRenderer* rendererVtk = m_ForegroundRenderer[rendererName]; + m_ForegroundRenderer[rendererName] = vtkSmartPointer::New(); + vtkRenderer *rendererVtk = m_ForegroundRenderer[rendererName]; rendererVtk->SetActiveCamera(renderer->GetVtkRenderer()->GetActiveCamera()); VtkLayerController::GetInstance(renderer->GetRenderWindow())->InsertForegroundRenderer(rendererVtk, false); rendererVtk->SetInteractive(false); } - for(auto layouter : mitk::Overlay2DLayouter::CreateLayouter(renderer)) - { - this->AddLayouter(layouter.GetPointer()); - } + for (auto layouter : mitk::Overlay2DLayouter::CreateLayouter(renderer)) + { + this->AddLayouter(layouter.GetPointer()); + } std::pair inSet; - inSet = m_BaseRendererSet.insert(rendererName); + inSet = m_BaseRendererSet.insert(rendererName); if (inSet.second) { OverlaySet::const_iterator it; - for ( it=m_OverlaySet.cbegin() ; it != m_OverlaySet.cend(); it++ ) + for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); it++) { if ((*it)->IsForceInForeground()) - (*it)->AddToRenderer(renderer,m_ForegroundRenderer[rendererName]); + (*it)->AddToRenderer(renderer, m_ForegroundRenderer[rendererName]); else (*it)->AddToBaseRenderer(renderer); } } } - void OverlayManager::RemoveBaseRenderer(BaseRenderer *renderer) + void OverlayManager::RemoveBaseRenderer(BaseRenderer * /*renderer*/) { - if (!renderer) - return; + // if (!renderer) + // return; - std::string rendererName = renderer->GetName(); - vtkRenderer* forgroundRenderer = m_ForegroundRenderer[rendererName]; - OverlaySet::const_iterator it; - for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) - { - (*it)->RemoveFromBaseRenderer(renderer); - if (forgroundRenderer) - (*it)->RemoveFromRenderer(renderer, forgroundRenderer); - } + // std::string rendererName = renderer->GetName(); + // vtkRenderer* forgroundRenderer = m_ForegroundRenderer[rendererName]; + // OverlaySet::const_iterator it; + // for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) + // { + // (*it)->RemoveFromBaseRenderer(renderer); + // if (forgroundRenderer) + // (*it)->RemoveFromRenderer(renderer, forgroundRenderer); + // } - m_ForegroundRenderer.erase(rendererName); - m_LayouterMap.erase(rendererName); + // m_ForegroundRenderer.erase(rendererName); + // m_LayouterMap.erase(rendererName); - BaseRendererSet::const_iterator i = m_BaseRendererSet.find(rendererName); - if (i == m_BaseRendererSet.cend()) - return; + // BaseRendererSet::const_iterator i = m_BaseRendererSet.find(rendererName); + // if (i == m_BaseRendererSet.cend()) + // return; - m_BaseRendererSet.erase(i); -} + // m_BaseRendererSet.erase(i); + } -void OverlayManager::RemoveBaseRenderer(const std::string& rendererName) -{ - RemoveBaseRenderer(mitk::BaseRenderer::GetByName(rendererName)); + void OverlayManager::RemoveBaseRenderer(const std::string &rendererName) + { + RemoveBaseRenderer(mitk::BaseRenderer::GetByName(rendererName)); } void OverlayManager::RemoveAllBaseRenderers() { - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - this->RemoveBaseRenderer(*it); - } + // BaseRendererSet::const_iterator it; + // for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) + // { + // this->RemoveBaseRenderer(*it); + // } } const OverlayManager::OverlaySet &OverlayManager::GetAllOverlays() { return m_OverlaySet; } OverlayManager *OverlayManager::GetInstance() { - auto renderwindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); - for (auto renderwindow : renderwindows) - { - BaseRenderer *renderer = BaseRenderer::GetInstance(renderwindow); - if (renderer && renderer->GetOverlayManager().IsNotNull()) - return renderer->GetOverlayManager(); - } + // auto renderwindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); + // for (auto renderwindow : renderwindows) + // { + // BaseRenderer *renderer = BaseRenderer::GetInstance(renderwindow); + // if (renderer && renderer->GetOverlayManager().IsNotNull()) + // return renderer->GetOverlayManager(); + // } return nullptr; } - void OverlayManager::AddOverlay(const Overlay::Pointer &overlay, bool ForceInForeground) - { - std::pair inSet; - inSet = m_OverlaySet.insert(overlay); - if (inSet.second) - { - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - if (ForceInForeground) - { - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; - overlay->AddToRenderer(*it, forgroundRenderer); - } - else - overlay->AddToBaseRenderer(*it); - this->InvokeEvent(OverlayAddEvent()); - } - } - } - - void OverlayManager::AddOverlay(const Overlay::Pointer &overlay, BaseRenderer *renderer, bool ForceInForeground) - { - std::pair inSet; - inSet = m_OverlaySet.insert(overlay); - if (inSet.second) - { - if (ForceInForeground) - { - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[renderer]; - overlay->AddToRenderer(renderer, forgroundRenderer); - } - else - overlay->AddToBaseRenderer(renderer); - this->InvokeEvent(OverlayAddEvent()); - } - } - - void OverlayManager::RemoveOverlay(const Overlay::Pointer &overlay) - { - OverlaySet::const_iterator overlayIt = m_OverlaySet.find(overlay); - if (overlayIt == m_OverlaySet.cend()) - return; - - BaseRendererSet::const_iterator it; - for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) - { - overlay->RemoveFromBaseRenderer(*it); - vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; - if (forgroundRenderer) - overlay->RemoveFromRenderer(*it, forgroundRenderer); - } - - m_OverlaySet.erase(overlayIt); - this->InvokeEvent(OverlayAddEvent()); + void OverlayManager::AddOverlay(const Overlay::Pointer & /*overlay*/, bool /*ForceInForeground*/) + { + // std::pair inSet; + // inSet = m_OverlaySet.insert(overlay); + // if (inSet.second) + // { + // BaseRendererSet::const_iterator it; + // for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) + // { + // if (ForceInForeground) + // { + // vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; + // overlay->AddToRenderer(*it, forgroundRenderer); + // } + // else + // overlay->AddToBaseRenderer(*it); + // this->InvokeEvent(OverlayAddEvent()); + // } + // } + } + + void OverlayManager::AddOverlay(const Overlay::Pointer & /*overlay*/, + BaseRenderer * /*renderer*/, + bool /*ForceInForeground*/) + { + // std::pair inSet; + // inSet = m_OverlaySet.insert(overlay); + // if (inSet.second) + // { + // if (ForceInForeground) + // { + // vtkRenderer *forgroundRenderer = m_ForegroundRenderer[renderer]; + // overlay->AddToRenderer(renderer, forgroundRenderer); + // } + // else + // overlay->AddToBaseRenderer(renderer); + // this->InvokeEvent(OverlayAddEvent()); + // } + } + + void OverlayManager::RemoveOverlay(const Overlay::Pointer & /*overlay*/) + { + // OverlaySet::const_iterator overlayIt = m_OverlaySet.find(overlay); + // if (overlayIt == m_OverlaySet.cend()) + // return; + + // BaseRendererSet::const_iterator it; + // for (it = m_BaseRendererSet.cbegin(); it != m_BaseRendererSet.cend(); ++it) + // { + // overlay->RemoveFromBaseRenderer(*it); + // vtkRenderer *forgroundRenderer = m_ForegroundRenderer[*it]; + // if (forgroundRenderer) + // overlay->RemoveFromRenderer(*it, forgroundRenderer); + // } + + // m_OverlaySet.erase(overlayIt); + // this->InvokeEvent(OverlayAddEvent()); } void OverlayManager::RemoveAllOverlays() { while (!m_OverlaySet.empty()) RemoveOverlay(*m_OverlaySet.cbegin()); } - void OverlayManager::UpdateOverlays(BaseRenderer *baseRenderer) + void OverlayManager::UpdateOverlays(BaseRenderer * /*baseRenderer*/) { - OverlaySet::const_iterator it; - for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) - { - (*it)->Update(baseRenderer); - } - UpdateLayouts(baseRenderer); + // OverlaySet::const_iterator it; + // for (it = m_OverlaySet.cbegin(); it != m_OverlaySet.cend(); ++it) + // { + // (*it)->Update(baseRenderer); + // } + // UpdateLayouts(baseRenderer); } - void OverlayManager::SetLayouter(Overlay *overlay, const std::string &identifier, BaseRenderer *renderer) + void OverlayManager::SetLayouter(Overlay * /*overlay*/, + const std::string & /*identifier*/, + BaseRenderer * /*renderer*/) { - if (renderer) - { - AbstractOverlayLayouter::Pointer layouter = GetLayouter(renderer, identifier); - if (layouter.IsNull()) - { - MITK_WARN << "Layouter " << identifier << " cannot be found or created!"; - return; - } - else - { - layouter->AddOverlay(overlay); - } - } + // if (renderer) + // { + // AbstractOverlayLayouter::Pointer layouter = GetLayouter(renderer, identifier); + // if (layouter.IsNull()) + // { + // MITK_WARN << "Layouter " << identifier << " cannot be found or created!"; + // return; + // } + // else + // { + // layouter->AddOverlay(overlay); + // } + // } } - void OverlayManager::UpdateLayouts(BaseRenderer *renderer) + void OverlayManager::UpdateLayouts(BaseRenderer * /*renderer*/) { - const LayouterMap layouters = m_LayouterMap[renderer]; - LayouterMap::const_iterator it; - for (it = layouters.cbegin(); it != layouters.cend(); ++it) - { - (it->second)->PrepareLayout(); - } + // const LayouterMap layouters = m_LayouterMap[renderer]; + // LayouterMap::const_iterator it; + // for (it = layouters.cbegin(); it != layouters.cend(); ++it) + // { + // (it->second)->PrepareLayout(); + // } } - AbstractOverlayLayouter::Pointer OverlayManager::GetLayouter(BaseRenderer *renderer, const std::string &identifier) + AbstractOverlayLayouter::Pointer OverlayManager::GetLayouter(BaseRenderer * /*renderer*/, + const std::string & /*identifier*/) { - AbstractOverlayLayouter::Pointer layouter = m_LayouterMap[renderer][identifier]; - return layouter; + // AbstractOverlayLayouter::Pointer layouter = m_LayouterMap[renderer][identifier]; + return nullptr; } - void OverlayManager::AddLayouter(const AbstractOverlayLayouter::Pointer &layouter) - { - if (layouter.IsNotNull()) - { - AbstractOverlayLayouter::Pointer oldLayouter = - m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()]; - if (oldLayouter.IsNotNull() && oldLayouter.GetPointer() != layouter.GetPointer()) - { - MITK_WARN << "Layouter " << layouter->GetIdentifier() << " does already exist!"; - } - else if (oldLayouter.IsNull()) - { - m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()] = layouter; - } - } + void OverlayManager::AddLayouter(const AbstractOverlayLayouter::Pointer & /*layouter*/) + { + // if (layouter.IsNotNull()) + // { + // AbstractOverlayLayouter::Pointer oldLayouter = + // m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()]; + // if (oldLayouter.IsNotNull() && oldLayouter.GetPointer() != layouter.GetPointer()) + // { + // MITK_WARN << "Layouter " << layouter->GetIdentifier() << " does already exist!"; + // } + // else if (oldLayouter.IsNull()) + // { + // m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()] = layouter; + // } + // } } } diff --git a/Modules/Core/test/mitkDataNodeTest.cpp b/Modules/Core/test/mitkDataNodeTest.cpp index c0c4166d2a..44756390c8 100644 --- a/Modules/Core/test/mitkDataNodeTest.cpp +++ b/Modules/Core/test/mitkDataNodeTest.cpp @@ -1,318 +1,317 @@ /*=================================================================== 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 "mitkDataNode.h" #include "mitkVtkPropRenderer.h" #include #include "mitkTestingMacros.h" #include // Basedata Test #include #include -#include #include #include #include // Mapper Test #include #include #include #include #include #include #include // Interactors #include // Property list Test #include /** * Simple example for a test for the (non-existent) class "DataNode". * * argc and argv are the command line parameters which were passed to * the ADD_TEST command in the CMakeLists.txt file. For the automatic * tests, argv is either empty for the simple tests or contains the filename * of a test image for the image tests (see CMakeLists.txt). */ class mitkDataNodeTestClass { public: static void TestDataSetting(mitk::DataNode::Pointer dataNode) { mitk::BaseData::Pointer baseData; // NULL pointer Test dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a NULL pointer was set correctly") baseData = mitk::GeometryData::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a GeometryData object was set correctly") baseData = mitk::PlaneGeometryData::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a PlaneGeometryData object was set correctly") baseData = mitk::PointSet::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a PointSet object was set correctly") baseData = mitk::Image::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a Image object was set correctly") baseData = mitk::Surface::New(); dataNode->SetData(baseData); MITK_TEST_CONDITION(baseData == dataNode->GetData(), "Testing if a Surface object was set correctly") dataNode->SetData(nullptr); MITK_TEST_CONDITION(nullptr == dataNode->GetData(), "Testing if base data (already set) was replaced by a NULL pointer") } static void TestMapperSetting(mitk::DataNode::Pointer dataNode) { // tests the SetMapper() method // in dataNode is a mapper vector which can be accessed by index // in this test method we use only slot 0 (filled with null) and slot 1 // so we also test the destructor of the mapper classes mitk::Mapper::Pointer mapper; dataNode->SetMapper(0, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(0), "Testing if a NULL pointer was set correctly") mapper = mitk::PlaneGeometryDataMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::ImageVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a ImageVtkMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PointSetVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::SurfaceVtkMapper2D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a SurfaceGLMapper2D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PlaneGeometryDataVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PlaneGeometryDataVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::PointSetVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a PointSetVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") mapper = mitk::SurfaceVtkMapper3D::New(); dataNode->SetMapper(1, mapper); MITK_TEST_CONDITION(mapper == dataNode->GetMapper(1), "Testing if a SurfaceVtkMapper3D was set correctly") MITK_TEST_CONDITION(dataNode == mapper->GetDataNode(), "Testing if the mapper returns the right DataNode") } static void TestInteractorSetting(mitk::DataNode::Pointer dataNode) { // this method tests the SetInteractor() and GetInteractor methods // the DataInteractor base class calls the DataNode->SetInteractor method mitk::DataInteractor::Pointer interactor; MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a NULL pointer was set correctly (DataInteractor)") interactor = mitk::PointSetDataInteractor::New(); interactor->SetEventConfig("PointSetConfig.xml"); interactor->SetDataNode(dataNode); MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a PointSetDataInteractor was set correctly") interactor = mitk::PointSetDataInteractor::New(); dataNode->SetDataInteractor(interactor); MITK_TEST_CONDITION(interactor == dataNode->GetDataInteractor(), "Testing if a PointSetDataInteractor was set correctly") } static void TestPropertyList(mitk::DataNode::Pointer dataNode) { mitk::PropertyList::Pointer propertyList = dataNode->GetPropertyList(); MITK_TEST_CONDITION(dataNode->GetPropertyList() != NULL, "Testing if the constructor set the propertylist") dataNode->SetIntProperty("int", -31337); int x; dataNode->GetIntProperty("int", x); MITK_TEST_CONDITION(x == -31337, "Testing Set/GetIntProperty"); dataNode->SetBoolProperty("bool", true); bool b; dataNode->GetBoolProperty("bool", b); MITK_TEST_CONDITION(b == true, "Testing Set/GetBoolProperty"); dataNode->SetFloatProperty("float", -31.337); float y; dataNode->GetFloatProperty("float", y); MITK_TEST_CONDITION(y - -31.337 < 0.01, "Testing Set/GetFloatProperty"); double yd = 0; dataNode->GetDoubleProperty("float", yd); MITK_TEST_CONDITION(mitk::Equal(yd, static_cast(y)), "Testing GetDoubleProperty"); double d = sqrt(2.0); dataNode->SetDoubleProperty("double", d); double read_d; MITK_TEST_CONDITION(dataNode->GetDoubleProperty("double", read_d), "Testing GetDoubleProperty"); MITK_TEST_CONDITION(d == read_d, "Testing Set/GetDoubleProperty"); // Equal does not the same thing dataNode->SetStringProperty("string", "MITK"); std::string s = "GANZVIELPLATZ"; dataNode->GetStringProperty("string", s); MITK_TEST_CONDITION(s == "MITK", "Testing Set/GetStringProperty"); std::string name = "MyTestName"; dataNode->SetName(name.c_str()); MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName"); name = "MySecondTestName"; dataNode->SetName(name); MITK_TEST_CONDITION(dataNode->GetName() == name, "Testing Set/GetName(std::string)"); MITK_TEST_CONDITION(propertyList == dataNode->GetPropertyList(), "Testing if the propertylist has changed during the last tests") } static void TestSelected(mitk::DataNode::Pointer dataNode) { vtkRenderWindow *renderWindow = vtkRenderWindow::New(); mitk::VtkPropRenderer::Pointer base = mitk::VtkPropRenderer::New("the first renderer", renderWindow, mitk::RenderingManager::GetInstance()); // with BaseRenderer==Null MITK_TEST_CONDITION(!dataNode->IsSelected(), "Testing if this node is not set as selected") dataNode->SetSelected(true); MITK_TEST_CONDITION(dataNode->IsSelected(), "Testing if this node is set as selected") dataNode->SetSelected(false); dataNode->SetSelected(true, base); MITK_TEST_CONDITION(dataNode->IsSelected(base), "Testing if this node with right base renderer is set as selected") // Delete RenderWindow correctly renderWindow->Delete(); } static void TestGetMTime(mitk::DataNode::Pointer dataNode) { unsigned long time; time = dataNode->GetMTime(); mitk::PointSet::Pointer pointSet = mitk::PointSet::New(); dataNode->SetData(pointSet); MITK_TEST_CONDITION(time != dataNode->GetMTime(), "Testing if the node timestamp is updated after adding data to the node") mitk::Point3D point; point.Fill(3.0); pointSet->SetPoint(0, point); // less or equal because dataNode timestamp is little later then the basedata timestamp MITK_TEST_CONDITION(pointSet->GetMTime() <= dataNode->GetMTime(), "Testing if the node timestamp is updated after base data was modified") // testing if changing anything in the property list also sets the node in a modified state unsigned long lastModified = dataNode->GetMTime(); dataNode->SetIntProperty("testIntProp", 2344); MITK_TEST_CONDITION(lastModified <= dataNode->GetMTime(), "Testing if the node timestamp is updated after property list was modified") } static void TestSetDataUnderPropertyChange(void) { mitk::Image::Pointer image = mitk::Image::New(); mitk::Image::Pointer additionalImage = mitk::Image::New(); mitk::DataNode::Pointer dataNode = mitk::DataNode::New(); image = mitk::ImageGenerator::GenerateRandomImage(3u, 3u); dataNode->SetData(image); const float defaultOutlineWidth = 1.0; float outlineWidth = 0; dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, defaultOutlineWidth), "Testing if the SetData set the default property list") dataNode->SetProperty("outline width", mitk::FloatProperty::New(42.0)); dataNode->SetData(image); dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, 42.0), "Testing if the SetData does not set anything if image data is identical") dataNode->SetData(additionalImage); dataNode->GetPropertyValue("outline width", outlineWidth); MITK_TEST_CONDITION(mitk::Equal(outlineWidth, 42.0), "Testing if the SetData does not set the default property list if image data is already set") mitk::Surface::Pointer surface = mitk::Surface::New(); dataNode->SetData(surface); MITK_TEST_CONDITION(dataNode->GetPropertyValue("outline width", outlineWidth) == false, "Testing if SetData cleared previous property list and set the default property list if data " "of different type has been set") } }; // mitkDataNodeTestClass int mitkDataNodeTest(int /* argc */, char * /*argv*/ []) { // always start with this! MITK_TEST_BEGIN("DataNode") // let's create an object of our class mitk::DataNode::Pointer myDataNode = mitk::DataNode::New(); // first test: did this work? // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since // it makes no sense to continue without an object. MITK_TEST_CONDITION_REQUIRED(myDataNode.IsNotNull(), "Testing instantiation") // test setData() Method mitkDataNodeTestClass::TestDataSetting(myDataNode); mitkDataNodeTestClass::TestMapperSetting(myDataNode); // // note, that no data is set to the dataNode mitkDataNodeTestClass::TestInteractorSetting(myDataNode); mitkDataNodeTestClass::TestPropertyList(myDataNode); mitkDataNodeTestClass::TestSelected(myDataNode); mitkDataNodeTestClass::TestGetMTime(myDataNode); mitkDataNodeTestClass::TestSetDataUnderPropertyChange(); // write your own tests here and use the macros from mitkTestingMacros.h !!! // do not write to std::cout and do not return from this function yourself! // always end with this! MITK_TEST_END() } diff --git a/Modules/Overlays/include/mitkAnnotationPlacer.h b/Modules/Overlays/include/mitkAnnotationPlacer.h index 33858e755b..6eeaf6dbad 100644 --- a/Modules/Overlays/include/mitkAnnotationPlacer.h +++ b/Modules/Overlays/include/mitkAnnotationPlacer.h @@ -1,54 +1,51 @@ /*=================================================================== 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 ANNOTATIONPLACER_H #define ANNOTATIONPLACER_H #include "MitkOverlaysExports.h" -#include "mitkOverlay.h" #include "mitkAbstractAnnotationRenderer.h" +#include "mitkOverlay.h" -namespace mitk { - -class BaseRenderer; - -/** \brief The AnnotationPlacer updates and manages Overlays and the respective Layouters. */ -/** An Instance of the AnnotationPlacer can be registered to several BaseRenderer instances in order to - * call the update method of each Overlay during the rendering phase of the renderer. - * See \ref OverlaysPage for more info. -*/ -class MITKOVERLAYS_EXPORT AnnotationPlacer : public AbstractAnnotationRenderer { - -public: - /** \brief virtual destructor in order to derive from this class */ - virtual ~AnnotationPlacer(); +namespace mitk +{ + class BaseRenderer; - const std::string GetID() const; + /** \brief The AnnotationPlacer updates and manages Overlays and the respective Layouters. */ + /** An Instance of the AnnotationPlacer can be registered to several BaseRenderer instances in order to + * call the update method of each Overlay during the rendering phase of the renderer. + * See \ref OverlaysPage for more info. + */ + class MITKOVERLAYS_EXPORT AnnotationPlacer : public AbstractAnnotationRenderer + { + public: + /** \brief virtual destructor in order to derive from this class */ + virtual ~AnnotationPlacer(); - static AnnotationPlacer* GetAnnotationRenderer(const std::string& rendererID); + const std::string GetID() const; -private: + static AnnotationPlacer *GetAnnotationRenderer(const std::string &rendererID); - using AbstractAnnotationRenderer::AbstractAnnotationRenderer; + private: + using AbstractAnnotationRenderer::AbstractAnnotationRenderer; - static const std::string ANNOTATIONRENDERER_ID; -}; + static const std::string ANNOTATIONRENDERER_ID; + }; } // namespace mitk #endif // ANNOTATIONPLACER_H - - diff --git a/Modules/Overlays/include/mitkOverlayLayouter2D.h b/Modules/Overlays/include/mitkOverlayLayouter2D.h index e6161f451c..f5eddcab6a 100644 --- a/Modules/Overlays/include/mitkOverlayLayouter2D.h +++ b/Modules/Overlays/include/mitkOverlayLayouter2D.h @@ -1,55 +1,50 @@ /*=================================================================== 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 OVERLAYLAYOUTER2D_H #define OVERLAYLAYOUTER2D_H #include "MitkOverlaysExports.h" #include "mitkAbstractAnnotationRenderer.h" -namespace mitk { +namespace mitk +{ + class BaseRenderer; -class BaseRenderer; + /** \brief The OverlayLayouter2D updates and manages Overlays and the respective Layouters. */ + /** An Instance of the OverlayLayouter2D can be registered to several BaseRenderer instances in order to + * call the update method of each Overlay during the rendering phase of the renderer. + * See \ref OverlaysPage for more info. + */ + class MITKOVERLAYS_EXPORT OverlayLayouter2D : public AbstractAnnotationRenderer + { + public: + /** \brief virtual destructor in order to derive from this class */ + virtual ~OverlayLayouter2D(); -/** \brief The OverlayLayouter2D updates and manages Overlays and the respective Layouters. */ -/** An Instance of the OverlayLayouter2D can be registered to several BaseRenderer instances in order to - * call the update method of each Overlay during the rendering phase of the renderer. - * See \ref OverlaysPage for more info. -*/ -class MITKOVERLAYS_EXPORT OverlayLayouter2D : public AbstractAnnotationRenderer { + const std::string GetID() const; -public: + static OverlayLayouter2D *GetAnnotationRenderer(const std::string &rendererID); - /** \brief virtual destructor in order to derive from this class */ - virtual ~OverlayLayouter2D(); + static const std::string ANNOTATIONRENDERER_ID; - const std::string GetID() const; - - static OverlayLayouter2D *GetAnnotationRenderer(const std::string& rendererID); - - static const std::string ANNOTATIONRENDERER_ID; - -private: - - using AbstractAnnotationRenderer::AbstractAnnotationRenderer; - -}; + private: + using AbstractAnnotationRenderer::AbstractAnnotationRenderer; + }; } // namespace mitk #endif // OVERLAYLAYOUTER2D_H - - diff --git a/Modules/Overlays/src/mitkAnnotationPlacer.cpp b/Modules/Overlays/src/mitkAnnotationPlacer.cpp index a1c3650108..a45c593f12 100644 --- a/Modules/Overlays/src/mitkAnnotationPlacer.cpp +++ b/Modules/Overlays/src/mitkAnnotationPlacer.cpp @@ -1,54 +1,44 @@ /*=================================================================== 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 "mitkAnnotationPlacer.h" #include "mitkBaseRenderer.h" -#include -#include "mitkOverlay2DLayouter.h" #include "mitkAnnotationService.h" +#include "mitkOverlay2DLayouter.h" +#include namespace mitk { + const std::string mitk::AnnotationPlacer::ANNOTATIONRENDERER_ID = "AnnotationPlacer"; -const std::string mitk::AnnotationPlacer::ANNOTATIONRENDERER_ID = "AnnotationPlacer"; - -AnnotationPlacer::~AnnotationPlacer() -{ -} - -const std::string AnnotationPlacer::GetID() const -{ - return ANNOTATIONRENDERER_ID; -} - -AnnotationPlacer *AnnotationPlacer::GetAnnotationRenderer(const std::string &rendererID) -{ - AnnotationPlacer* result = nullptr; - AbstractAnnotationRenderer* registeredService = - AnnotationService::GetAnnotationRenderer(ANNOTATIONRENDERER_ID,rendererID); - if(registeredService) - result = dynamic_cast(registeredService); - if(!result) + AnnotationPlacer::~AnnotationPlacer() {} + const std::string AnnotationPlacer::GetID() const { return ANNOTATIONRENDERER_ID; } + AnnotationPlacer *AnnotationPlacer::GetAnnotationRenderer(const std::string &rendererID) { - result = new AnnotationPlacer(rendererID); - AnnotationService::RegisterAnnotationRenderer(result); + AnnotationPlacer *result = nullptr; + AbstractAnnotationRenderer *registeredService = + AnnotationService::GetAnnotationRenderer(ANNOTATIONRENDERER_ID, rendererID); + if (registeredService) + result = dynamic_cast(registeredService); + if (!result) + { + result = new AnnotationPlacer(rendererID); + AnnotationService::RegisterAnnotationRenderer(result); + } + return result; } - return result; -} - - } diff --git a/Modules/Overlays/src/mitkOverlayLayouter2D.cpp b/Modules/Overlays/src/mitkOverlayLayouter2D.cpp index 012683ede0..bc1c630a95 100644 --- a/Modules/Overlays/src/mitkOverlayLayouter2D.cpp +++ b/Modules/Overlays/src/mitkOverlayLayouter2D.cpp @@ -1,54 +1,44 @@ /*=================================================================== 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 "mitkOverlayLayouter2D.h" #include "mitkBaseRenderer.h" -#include -#include "mitkOverlay2DLayouter.h" #include "mitkAnnotationService.h" +#include "mitkOverlay2DLayouter.h" +#include namespace mitk { + const std::string mitk::OverlayLayouter2D::ANNOTATIONRENDERER_ID = "OverlayLayouter2D"; -const std::string mitk::OverlayLayouter2D::ANNOTATIONRENDERER_ID = "OverlayLayouter2D"; - -OverlayLayouter2D::~OverlayLayouter2D() -{ - -} - -const std::string OverlayLayouter2D::GetID() const -{ - return ANNOTATIONRENDERER_ID; -} - -OverlayLayouter2D *OverlayLayouter2D::GetAnnotationRenderer(const std::string &rendererID) -{ - OverlayLayouter2D* result = nullptr; - AbstractAnnotationRenderer* registeredService = - AnnotationService::GetAnnotationRenderer(ANNOTATIONRENDERER_ID,rendererID); - if(registeredService) - result = dynamic_cast(registeredService); - if(!result) + OverlayLayouter2D::~OverlayLayouter2D() {} + const std::string OverlayLayouter2D::GetID() const { return ANNOTATIONRENDERER_ID; } + OverlayLayouter2D *OverlayLayouter2D::GetAnnotationRenderer(const std::string &rendererID) { - result = new OverlayLayouter2D(rendererID); - AnnotationService::RegisterAnnotationRenderer(result); + OverlayLayouter2D *result = nullptr; + AbstractAnnotationRenderer *registeredService = + AnnotationService::GetAnnotationRenderer(ANNOTATIONRENDERER_ID, rendererID); + if (registeredService) + result = dynamic_cast(registeredService); + if (!result) + { + result = new OverlayLayouter2D(rendererID); + AnnotationService::RegisterAnnotationRenderer(result); + } + return result; } - return result; -} - }