diff --git a/Core/Code/DataManagement/mitkImageToItk.txx b/Core/Code/DataManagement/mitkImageToItk.txx
index 110fcdfdb3..973d5c46af 100644
--- a/Core/Code/DataManagement/mitkImageToItk.txx
+++ b/Core/Code/DataManagement/mitkImageToItk.txx
@@ -1,258 +1,258 @@
/*===================================================================
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 IMAGETOITK_TXX_INCLUDED_C1C2FCD2
#define IMAGETOITK_TXX_INCLUDED_C1C2FCD2
#include "mitkImageToItk.h"
#include "mitkBaseProcess.h"
#include "itkImportMitkImageContainer.h"
#include "mitkImageWriteAccessor.h"
#include "mitkException.h"
template <class TOutputImage>
void mitk::ImageToItk<TOutputImage>::SetInput(mitk::Image *input)
{
if(input == NULL)
itkExceptionMacro( << "image is null" );
if(input->GetDimension()!=TOutputImage::GetImageDimension())
itkExceptionMacro( << "image has dimension " << input->GetDimension() << " instead of " << TOutputImage::GetImageDimension() );
if(!(input->GetPixelType() == mitk::MakePixelType<TOutputImage>()))
itkExceptionMacro( << "image has wrong pixel type " );
// Process object is not const-correct so the const_cast is required here
itk::ProcessObject::SetNthInput(0, input);
}
template<class TOutputImage>
void mitk::ImageToItk<TOutputImage>::SetInput( unsigned int index, mitk::Image * input )
{
if( index+1 > this->GetNumberOfInputs() )
{
this->SetNumberOfRequiredInputs( index + 1 );
}
if(input == NULL)
itkExceptionMacro( << "image is null" );
if(input->GetDimension()!=TOutputImage::GetImageDimension())
itkExceptionMacro( << "image has dimension " << input->GetDimension() << " instead of " << TOutputImage::GetImageDimension() );
if(!(input->GetPixelType() == mitk::MakePixelType<TOutputImage>() ))
itkExceptionMacro( << "image has wrong pixel type " );
// Process object is not const-correct so the const_cast is required here
itk::ProcessObject::SetNthInput(index,input);
}
template<class TOutputImage>
mitk::Image *mitk::ImageToItk<TOutputImage>::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return (mitk::Image*) const_cast<itk::DataObject*>(itk::ProcessObject::GetInput(0));
}
template<class TOutputImage>
mitk::Image *mitk::ImageToItk<TOutputImage>::GetInput(unsigned int idx)
{
return itk::ProcessObject::GetInput(idx);
}
template<class TOutputImage>
void mitk::ImageToItk<TOutputImage>
::GenerateData()
{
// Allocate output
mitk::Image::Pointer input = this->GetInput();
typename Superclass::OutputImageType::Pointer output = this->GetOutput();
unsigned long noBytes = input->GetDimension(0);
for (unsigned int i=1; i<TOutputImage::GetImageDimension(); ++i)
{
noBytes = noBytes * input->GetDimension(i);
}
mitk::ImageWriteAccessor* imageAccess = new mitk::ImageWriteAccessor(input);
// hier wird momentan wohl nur der erste Channel verwendet??!!
if(imageAccess->GetData() == NULL)
{
itkWarningMacro(<< "no image data to import in ITK image");
RegionType bufferedRegion;
output->SetBufferedRegion(bufferedRegion);
return;
}
if (m_CopyMemFlag)
{
itkDebugMacro("copyMem ...");
output->Allocate();
memcpy( (PixelType *) output->GetBufferPointer(), imageAccess->GetData(), sizeof(PixelType)*noBytes);
delete imageAccess;
}
else
{
itkDebugMacro("do not copyMem ...");
typedef itk::ImportMitkImageContainer< unsigned long, PixelType > ImportContainerType;
typename ImportContainerType::Pointer import;
import = ImportContainerType::New();
import->Initialize();
itkDebugMacro( << "size of container = " << import->Size() );
//import->SetImageDataItem(m_ImageDataItem);
import->SetImageAccessor(imageAccess,sizeof(PixelType)*noBytes);
- output->SetPixelContainer(import);
+ output->SetPixelContainer(import);
itkDebugMacro( << "size of container = " << import->Size() );
}
}
template<class TOutputImage>
void mitk::ImageToItk<TOutputImage>
::UpdateOutputInformation()
{
mitk::Image::Pointer input = this->GetInput();
if(input.IsNotNull() && (input->GetSource().IsNotNull()) && input->GetSource()->Updating())
{
typename Superclass::OutputImageType::Pointer output = this->GetOutput();
unsigned long t1 = input->GetUpdateMTime()+1;
if (t1 > this->m_OutputInformationMTime.GetMTime())
{
output->SetPipelineMTime(t1);
this->GenerateOutputInformation();
this->m_OutputInformationMTime.Modified();
}
return;
}
Superclass::UpdateOutputInformation();
}
template<class TOutputImage>
void mitk::ImageToItk<TOutputImage>
::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
typename Superclass::OutputImageType::Pointer output = this->GetOutput();
// allocate size, origin, spacing, direction in types of output image
SizeType size;
const unsigned int itkDimMin3 = (TOutputImage::ImageDimension > 3 ? TOutputImage::ImageDimension : 3);
const unsigned int itkDimMax3 = (TOutputImage::ImageDimension < 3 ? TOutputImage::ImageDimension : 3);
typename Superclass::OutputImageType::PointType::ValueType origin[ itkDimMin3 ];
typename Superclass::OutputImageType::SpacingType::ComponentType spacing[ itkDimMin3 ];
typename Superclass::OutputImageType::DirectionType direction;
// copy as much information as possible into size and spacing
unsigned int i;
for ( i=0; i < itkDimMax3; ++i)
{
size[i] = input->GetDimension(i);
spacing[i] = input->GetGeometry()->GetSpacing()[i];
}
for ( ; i < TOutputImage::ImageDimension; ++i)
{
origin[i] = 0.0;
size[i] = input->GetDimension(i);
spacing[i] = 1.0;
}
// build region from size
IndexType start;
start.Fill( 0 );
RegionType region;
region.SetIndex( start );
region.SetSize( size );
// copy as much information as possible into origin
const mitk::Point3D& mitkorigin = input->GetGeometry()->GetOrigin();
itk2vtk(mitkorigin, origin);
// copy as much information as possible into direction
direction.SetIdentity();
unsigned int j;
const AffineTransform3D::MatrixType& matrix = input->GetGeometry()->GetIndexToWorldTransform()->GetMatrix();
/// \warning 2D MITK images could have a 3D rotation, since they have a 3x3 geometry matrix.
/// If it is only a rotation around the axial plane normal, it can be express with a 2x2 matrix.
/// In this case, the ITK image conservs this information and is identical to the MITK image!
/// If the MITK image contains any other rotation, the ITK image will have no rotation at all.
/// Spacing is of course conserved in both cases.
// the following loop devides by spacing now to normalize columns.
// counterpart of InitializeByItk in mitkImage.h line 372 of revision 15092.
// Check if information is lost
if ( TOutputImage::ImageDimension <= 2)
{
if (( TOutputImage::ImageDimension == 2) && (
( matrix[0][2] != 0) ||
( matrix[1][2] != 0) ||
( matrix[2][0] != 0) ||
( matrix[2][1] != 0) ||
(( matrix[2][2] != 1) && ( matrix[2][2] != -1) )))
{
// The 2D MITK image contains 3D rotation information.
// This cannot be expressed in a 2D ITK image, so the ITK image will have no rotation
}
else
{
// The 2D MITK image can be converted to an 2D ITK image without information loss!
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
direction[i][j] = matrix[i][j]/spacing[j];
}
}
else
{
// Normal 3D image. Conversion possible without problem!
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
direction[i][j] = matrix[i][j]/spacing[j];
}
// set information into output image
output->SetRegions( region );
output->SetOrigin( origin );
output->SetSpacing( spacing );
output->SetDirection( direction );
}
template<class TOutputImage>
void
mitk::ImageToItk<TOutputImage>
::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os,indent);
}
#endif //IMAGETOITK_TXX_INCLUDED_C1C2FCD2
diff --git a/Examples/QtAppExample/Step1.cpp b/Examples/QtAppExample/Step1.cpp
index b488892a2f..4172a82295 100644
--- a/Examples/QtAppExample/Step1.cpp
+++ b/Examples/QtAppExample/Step1.cpp
@@ -1,107 +1,107 @@
/*===================================================================
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 "QmitkRegisterClasses.h"
#include "QmitkRenderWindow.h"
#include <mitkDataNodeFactory.h>
#include <mitkStandaloneDataStorage.h>
#include <itksys/SystemTools.hxx>
#include <QApplication>
// Load image (nrrd format) and display it in a 2D view
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if (argc < 2)
{
fprintf( stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
// The DataStorage manages all data objects. It is used by the
// rendering mechanism to render all data objects
// We use the standard implementation mitk::StandaloneDataStorage.
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading a file
//*************************************************************************
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
const char * filename = argv[1];
try
{
reader->SetFileName(filename);
reader->Update();
//*************************************************************************
// Part III: Put the data into the datastorage
//*************************************************************************
// Add the node to the DataStorage
ds->Add(reader->GetOutput());
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
//*************************************************************************
// Part IV: Create window and pass the datastorage to it
//*************************************************************************
// Create a RenderWindow
QmitkRenderWindow renderWindow;
// Tell the RenderWindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// Initialize the RenderWindow
- mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+ mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews( geo );
//mitk::RenderingManager::GetInstance()->InitializeViews();
// Select a slice
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
if (sliceNaviController)
sliceNaviController->GetSlice()->SetPos( 0 );
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
qtapplication.exec();
// cleanup: Remove References to DataStorage. This will delete the object
ds = NULL;
}
diff --git a/Examples/QtFreeRender/QtFreeRender.cpp b/Examples/QtFreeRender/QtFreeRender.cpp
index cc3e897051..b99a7ad3a7 100644
--- a/Examples/QtFreeRender/QtFreeRender.cpp
+++ b/Examples/QtFreeRender/QtFreeRender.cpp
@@ -1,373 +1,373 @@
/*===================================================================
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 "mitkRenderWindow.h"
#include <mitkDataNodeFactory.h>
#include <mitkStandaloneDataStorage.h>
#include <mitkProperties.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include <mitkRenderingManager.h>
#include <mitkGlobalInteraction.h>
#include "mitkProperties.h"
#include "mitkGeometry2DDataMapper2D.h"
#include "mitkGlobalInteraction.h"
#include "mitkDisplayInteractor.h"
#include "mitkPositionEvent.h"
#include "mitkStateEvent.h"
#include "mitkLine.h"
#include "mitkInteractionConst.h"
#include "mitkVtkLayerController.h"
#include "mitkPositionTracker.h"
#include "mitkDisplayInteractor.h"
#include "mitkSlicesRotator.h"
#include "mitkSlicesSwiveller.h"
#include "mitkRenderWindowFrame.h"
#include "mitkGradientBackground.h"
#include "mitkCoordinateSupplier.h"
#include "mitkDataStorage.h"
#include "vtkTextProperty.h"
#include "vtkCornerAnnotation.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkAnnotatedCubeActor.h"
#include "vtkOrientationMarkerWidget.h"
#include "vtkProperty.h"
// us
#include "mitkGetModuleContext.h"
#include "mitkModule.h"
#include "mitkModuleRegistry.h"
#include "mitkInteractionEventObserver.h"
//##Documentation
//## @brief Example of a NON QT DEPENDENT MITK RENDERING APPLICATION.
mitk::RenderWindow::Pointer mitkWidget1;
mitk::RenderWindow::Pointer mitkWidget2;
mitk::RenderWindow::Pointer mitkWidget3;
mitk::RenderWindow::Pointer mitkWidget4;
mitk::DisplayInteractor::Pointer m_DisplayInteractor;
mitk::CoordinateSupplier::Pointer m_LastLeftClickPositionSupplier;
mitk::GradientBackground::Pointer m_GradientBackground4;
mitk::RenderWindowFrame::Pointer m_RectangleRendering1;
mitk::RenderWindowFrame::Pointer m_RectangleRendering2;
mitk::RenderWindowFrame::Pointer m_RectangleRendering3;
mitk::RenderWindowFrame::Pointer m_RectangleRendering4;
mitk::SliceNavigationController* m_TimeNavigationController = NULL;
mitk::DataStorage::Pointer m_DataStorage;
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
mitk::DataNode::Pointer m_Node;
void InitializeWindows()
{
// Set default view directions for SNCs
mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
//initialize m_TimeNavigationController: send time via sliceNavigationControllers
m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
//reverse connection between sliceNavigationControllers and m_TimeNavigationController
mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
gi->AddListener(m_TimeNavigationController);
m_LastLeftClickPositionSupplier = mitk::CoordinateSupplier::New("navigation", NULL);
mitk::GlobalInteraction::GetInstance()->AddListener(m_LastLeftClickPositionSupplier);
m_GradientBackground4 = mitk::GradientBackground::New();
m_GradientBackground4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
m_GradientBackground4->SetGradientColors(0.1, 0.1, 0.1, 0.5, 0.5, 0.5);
m_GradientBackground4->Enable();
m_RectangleRendering1 = mitk::RenderWindowFrame::New();
m_RectangleRendering1->SetRenderWindow(mitkWidget1->GetVtkRenderWindow());
m_RectangleRendering1->Enable(1.0, 0.0, 0.0);
m_RectangleRendering2 = mitk::RenderWindowFrame::New();
m_RectangleRendering2->SetRenderWindow(mitkWidget2->GetVtkRenderWindow());
m_RectangleRendering2->Enable(0.0, 1.0, 0.0);
m_RectangleRendering3 = mitk::RenderWindowFrame::New();
m_RectangleRendering3->SetRenderWindow(mitkWidget3->GetVtkRenderWindow());
m_RectangleRendering3->Enable(0.0, 0.0, 1.0);
m_RectangleRendering4 = mitk::RenderWindowFrame::New();
m_RectangleRendering4->SetRenderWindow(mitkWidget4->GetVtkRenderWindow());
m_RectangleRendering4->Enable(1.0, 1.0, 0.0);
}
void AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
float white[3] =
{ 1.0f, 1.0f, 1.0f };
mitk::Geometry2DDataMapper2D::Pointer mapper;
mitk::IntProperty::Pointer layer = mitk::IntProperty::New(1000);
// ... of widget 1
m_PlaneNode1 = (mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode1->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New("widget1Plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("layer", layer);
m_PlaneNode1->SetColor(1.0, 0.0, 0.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
m_PlaneNode2 = (mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode2->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New("widget2Plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("layer", layer);
m_PlaneNode2->SetColor(0.0, 1.0, 0.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
m_PlaneNode3 = (mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow()))->GetCurrentWorldGeometry2DNode();
m_PlaneNode3->SetColor(white, mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow()));
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New("widget3Plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("layer", layer);
m_PlaneNode3->SetColor(0.0, 0.0, 1.0);
mapper = mitk::Geometry2DDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_Node = mitk::DataNode::New();
m_Node->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_Node->SetProperty("helper object", mitk::BoolProperty::New(true));
//AddPlanesToDataStorage
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() && m_Node.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_Node);
m_DataStorage->Add(m_PlaneNode1, m_Node);
m_DataStorage->Add(m_PlaneNode2, m_Node);
m_DataStorage->Add(m_PlaneNode3, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode1->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode2->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
static_cast<mitk::Geometry2DDataMapper2D*>(m_PlaneNode3->GetMapper(mitk::BaseRenderer::Standard2D))->SetDatastorageAndGeometryBaseNode(
m_DataStorage, m_Node);
}
}
}
void Fit()
{
vtkRenderer * vtkrenderer;
mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetDisplayGeometry()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetVtkRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkObject::SetGlobalWarningDisplay(w);
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
fprintf(stderr, "Usage: %s [filename1] [filename2] ...\n\n", "");
return 1;
}
// Create a DataStorage
m_DataStorage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for (i = 1; i < argc; ++i)
{
// For testing
if (strcmp(argv[i], "-testing") == 0)
continue;
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
const char * filename = argv[i];
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
mitk::DataNode::Pointer node = nodeReader->GetOutput();
m_DataStorage->Add(node);
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if (image.IsNotNull())
{
// Set the property "volumerendering" to the Boolean value "true"
node->SetProperty("volumerendering", mitk::BoolProperty::New(false));
node->SetProperty("name", mitk::StringProperty::New("testimage"));
node->SetProperty("layer", mitk::IntProperty::New(1));
}
} catch (...)
{
fprintf(stderr, "Could not open file %s \n\n", filename);
exit(2);
}
}
//*************************************************************************
// Part V: Create window and pass the tree to it
//*************************************************************************
// Global Interaction initialize
// legacy because window manager relies still on existence if global interaction
mitk::GlobalInteraction::GetInstance()->Initialize("global");
//mitk::GlobalInteraction::GetInstance()->AddListener(m_DisplayInteractor);
// Create renderwindows
mitkWidget1 = mitk::RenderWindow::New();
mitkWidget2 = mitk::RenderWindow::New();
mitkWidget3 = mitk::RenderWindow::New();
mitkWidget4 = mitk::RenderWindow::New();
// Tell the renderwindow which (part of) the datastorage to render
mitkWidget1->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget2->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget3->GetRenderer()->SetDataStorage(m_DataStorage);
mitkWidget4->GetRenderer()->SetDataStorage(m_DataStorage);
// Let NavigationControllers listen to GlobalInteraction
mitk::GlobalInteraction *gi = mitk::GlobalInteraction::GetInstance();
gi->AddListener(mitkWidget1->GetSliceNavigationController());
gi->AddListener(mitkWidget2->GetSliceNavigationController());
gi->AddListener(mitkWidget3->GetSliceNavigationController());
gi->AddListener(mitkWidget4->GetSliceNavigationController());
// instantiate display interactor
if (m_DisplayInteractor.IsNull())
{
m_DisplayInteractor = mitk::DisplayInteractor::New();
m_DisplayInteractor->LoadStateMachine("DisplayInteraction.xml");
m_DisplayInteractor->SetEventConfig("DisplayConfigMITK.xml");
// Register as listener via micro services
mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
context->RegisterService<mitk::InteractionEventObserver>(
m_DisplayInteractor.GetPointer());
}
// Use it as a 2D View
mitkWidget1->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget2->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget3->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard2D);
mitkWidget4->GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
mitkWidget1->SetSize(400, 400);
mitkWidget2->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1]);
mitkWidget2->SetSize(400, 400);
mitkWidget3->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0],
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget3->SetSize(400, 400);
mitkWidget4->GetVtkRenderWindow()->SetPosition(mitkWidget1->GetVtkRenderWindow()->GetPosition()[0] + 420,
mitkWidget1->GetVtkRenderWindow()->GetPosition()[1] + 450);
mitkWidget4->SetSize(400, 400);
InitializeWindows();
AddDisplayPlaneSubTree();
Fit();
// Initialize the RenderWindows
- mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
+ mitk::TimeGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
m_DataStorage->Print(std::cout);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
// reinit the mitkVTKEventProvider;
// this is only necessary once after calling
// ForceImmediateUpdateAll() for the first time
mitkWidget1->ReinitEventProvider();
mitkWidget2->ReinitEventProvider();
mitkWidget3->ReinitEventProvider();
mitkWidget1->GetVtkRenderWindow()->Render();
mitkWidget2->GetVtkRenderWindow()->Render();
mitkWidget3->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindow()->Render();
mitkWidget4->GetVtkRenderWindowInteractor()->Start();
return 0;
}
diff --git a/Examples/Tutorial/Step1.cpp b/Examples/Tutorial/Step1.cpp
index 836be5912d..140bd8a6f5 100644
--- a/Examples/Tutorial/Step1.cpp
+++ b/Examples/Tutorial/Step1.cpp
@@ -1,115 +1,115 @@
/*===================================================================
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 "QmitkRegisterClasses.h"
#include "QmitkRenderWindow.h"
#include <mitkDataNodeFactory.h>
#include <mitkStandaloneDataStorage.h>
#include <itksys/SystemTools.hxx>
#include <QApplication>
//##Documentation
//## @brief Load image (nrrd format) and display it in a 2D view
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if (argc < 2)
{
fprintf( stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a DataStorage
// The DataStorage manages all data objects. It is used by the
// rendering mechanism to render all data objects
// We use the standard implementation mitk::StandaloneDataStorage.
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading a file
//*************************************************************************
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer reader=mitk::DataNodeFactory::New();
const char * filename = argv[1];
try
{
reader->SetFileName(filename);
reader->Update();
//*************************************************************************
// Part III: Put the data into the datastorage
//*************************************************************************
// Add the node to the DataStorage
ds->Add(reader->GetOutput());
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
//*************************************************************************
// Part IV: Create window and pass the datastorage to it
//*************************************************************************
// Create a RenderWindow
QmitkRenderWindow renderWindow;
// Tell the RenderWindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(ds);
// Initialize the RenderWindow
- mitk::TimeSlicedGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
+ mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews( geo );
//mitk::RenderingManager::GetInstance()->InitializeViews();
// Select a slice
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
if (sliceNaviController)
sliceNaviController->GetSlice()->SetPos( 0 );
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
// for testing
#include "QtTesting.h"
if (strcmp(argv[argc-1], "-testing") != 0)
return qtapplication.exec();
else
return QtTesting();
// cleanup: Remove References to DataStorage. This will delete the object
ds = NULL;
}
/**
\example Step1.cpp
*/
diff --git a/Examples/Tutorial/Step2.cpp b/Examples/Tutorial/Step2.cpp
index a01d21dd0e..94dc282bb5 100644
--- a/Examples/Tutorial/Step2.cpp
+++ b/Examples/Tutorial/Step2.cpp
@@ -1,118 +1,118 @@
/*===================================================================
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 "QmitkRegisterClasses.h"
#include "QmitkRenderWindow.h"
#include <mitkDataNodeFactory.h>
#include <mitkStandaloneDataStorage.h>
#include <itksys/SystemTools.hxx>
#include <QApplication>
//##Documentation
//## @brief Load one or more data sets (many image, surface
//## and other formats) and display it in a 2D view
int main(int argc, char* argv[])
{
QApplication qtapplication( argc, argv );
if(argc<2)
{
fprintf( stderr, "Usage: %s [filename1] [filename2] ...\n\n",
itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
return 1;
}
// Register Qmitk-dependent global instances
QmitkRegisterClasses();
//*************************************************************************
// Part I: Basic initialization
//*************************************************************************
// Create a data storage object. We will use it as a singleton
mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
//*************************************************************************
// Part II: Create some data by reading files
//*************************************************************************
int i;
for(i=1; i<argc; ++i)
{
// For testing
if(strcmp(argv[i], "-testing")==0) continue;
// Create a DataNodeFactory to read a data format supported
// by the DataNodeFactory (many image formats, surface formats, etc.)
mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
const char * filename = argv[i];
try
{
nodeReader->SetFileName(filename);
nodeReader->Update();
//*********************************************************************
// Part III: Put the data into the datastorage
//*********************************************************************
// Since the DataNodeFactory directly creates a node,
// use the datastorage to add the read node
storage->Add(nodeReader->GetOutput());
}
catch(...)
{
fprintf( stderr, "Could not open file %s \n\n", filename );
exit(2);
}
}
//*************************************************************************
// Part IV: Create window and pass the datastorage to it
//*************************************************************************
// Create a RenderWindow
QmitkRenderWindow renderWindow;
// Tell the RenderWindow which (part of) the datastorage to render
renderWindow.GetRenderer()->SetDataStorage(storage);
// Initialize the RenderWindow
- mitk::TimeSlicedGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
+ mitk::TimeGeometry::Pointer geo = storage->ComputeBoundingGeometry3D(storage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews( geo );
// Select a slice
mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
if (sliceNaviController)
sliceNaviController->GetSlice()->SetPos( 2 );
//*************************************************************************
// Part V: Qt-specific initialization
//*************************************************************************
renderWindow.show();
renderWindow.resize( 256, 256 );
// for testing
#include "QtTesting.h"
if(strcmp(argv[argc-1], "-testing")!=0)
return qtapplication.exec();
else
return QtTesting();
}
/**
\example Step2.cpp
*/
diff --git a/Examples/Tutorial/Step8.cpp b/Examples/Tutorial/Step8.cpp
index fa378c4c64..28555a588d 100644
--- a/Examples/Tutorial/Step8.cpp
+++ b/Examples/Tutorial/Step8.cpp
@@ -1,88 +1,88 @@
/*===================================================================
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 "Step8.h"
#include "QmitkStdMultiWidget.h"
#include "mitkGlobalInteraction.h"
#include "mitkRenderingManager.h"
#include <QHBoxLayout>
#include <QVBoxLayout>
//##Documentation
//## @brief As Step6, but with QmitkStdMultiWidget as widget
Step8::Step8(int argc, char* argv[], QWidget *parent) :
Step6(argc, argv, parent)
{
}
void Step8::SetupWidgets()
{
//*************************************************************************
// Part I: Create windows and pass the tree to it
//*************************************************************************
// Create toplevel widget with vertical layout
QVBoxLayout* vlayout = new QVBoxLayout(this);
vlayout->setMargin(0);
vlayout->setSpacing(2);
// Create viewParent widget with horizontal layout
QWidget* viewParent = new QWidget(this);
vlayout->addWidget(viewParent);
QHBoxLayout* hlayout = new QHBoxLayout(viewParent);
hlayout->setMargin(0);
//*************************************************************************
// Part Ia: create and initialize QmitkStdMultiWidget
//*************************************************************************
QmitkStdMultiWidget* multiWidget = new QmitkStdMultiWidget(viewParent);
hlayout->addWidget(multiWidget);
// Tell the multiWidget which DataStorage to render
multiWidget->SetDataStorage(m_DataStorage);
// Initialize views as axial, sagittal, coronar (from
// top-left to bottom)
- mitk::TimeSlicedGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(
+ mitk::TimeGeometry::Pointer geo = m_DataStorage->ComputeBoundingGeometry3D(
m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
// Initialize bottom-right view as 3D view
multiWidget->GetRenderWindow4()->GetRenderer()->SetMapperID(
mitk::BaseRenderer::Standard3D);
// Enable standard handler for levelwindow-slider
multiWidget->EnableStandardLevelWindow();
// Add the displayed views to the DataStorage to see their positions in 2D and 3D
multiWidget->AddDisplayPlaneSubTree();
multiWidget->AddPlanesToDataStorage();
multiWidget->SetWidgetPlanesVisibility(true);
//*************************************************************************
// Part II: Setup standard interaction with the mouse
//*************************************************************************
// Moving the cut-planes to click-point
multiWidget->EnableNavigationControllerEventListening();
}
/**
\example Step8.cpp
*/
diff --git a/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp b/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
index e5919e6c21..3bf009669c 100644
--- a/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
+++ b/Modules/InputDevices/WiiMote/mitkWiiMoteInteractor.cpp
@@ -1,776 +1,776 @@
/*===================================================================
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 <mitkWiiMoteInteractor.h>
// mitk
#include <mitkInteractionConst.h>
#include <mitkVector.h>
#include <mitkSurface.h>
#include <mitkRenderingManager.h>
#include <mitkVector.h>
#include <mitkGlobalInteraction.h>
#include <mitkDataStorage.h>
#include <mitkRenderingManager.h>
#include <mitkVtkPropRenderer.h>
// vtk
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkTransform.h>
#include <vtkRenderer.h>
#include <vtkMath.h>
// vnl
#include <vnl/vnl_quaternion.h>
#include <vnl/vnl_inverse.h>
#define _USE_MATH_DEFINES // otherwise, constants will not work
#include <math.h>
const double DELTATIME = 0.01;
mitk::WiiMoteInteractor::WiiMoteInteractor(const char* type, DataNode* dataNode)
: Interactor(type, dataNode)
, m_OrientationX(0)
, m_OrientationY(0)
, m_OrientationZ(0)
, m_xVelocity (0)
, m_yVelocity (0)
, m_zVelocity (0)
, m_xAngle (0)
, m_yAngle (0)
, m_zAngle (0)
, m_xValue (0)
, m_yValue (0)
, m_zValue (0)
, m_InRotation(false)
, m_TranslationMode(1)
, m_OriginalGeometry(NULL)
, m_SurfaceInteractionMode(1)
{
// save original geometry
mitk::Geometry3D* temp = this->TransformCurrentDataInGeometry3D();
try
{
m_OriginalGeometry = dynamic_cast<mitk::Geometry3D*>(temp->Clone().GetPointer());
}
catch(...)
{
MITK_WARN << "Original geometry could not be stored!";
}
// connect actions to methods
CONNECT_ACTION(mitk::AcONWIIMOTEINPUT,OnWiiMoteInput);
CONNECT_ACTION(mitk::AcONWIIMOTEBUTTONRELEASED,OnWiiMoteReleaseButton);
CONNECT_ACTION(mitk::AcRESETVIEW,OnWiiMoteResetButton);
}
mitk::WiiMoteInteractor::~WiiMoteInteractor()
{
}
bool mitk::WiiMoteInteractor::OnWiiMoteResetButton(Action* action, const mitk::StateEvent* stateEvent)
{
// resets the geometry, so that the
// object will be returned to its
// initial state
try
{
mitk::Surface* surface
= dynamic_cast<mitk::Surface*>(m_DataNode->GetData());
mitk::Geometry3D::Pointer temp
= dynamic_cast<mitk::Geometry3D*>(m_OriginalGeometry->Clone().GetPointer());
surface->SetGeometry(temp);
if(surface == NULL)
{
MITK_WARN << "Original geometry could not be used for reset!";
}
m_DataNode->SetData(surface);
m_DataNode->Modified();
}
catch(...)
{
MITK_ERROR << "Original geometry could not be retrieved";
}
//reset the camera, so that the objects shown in the scene can be seen.
const mitk::BaseRenderer* br = mitk::GlobalInteraction::GetInstance()->GetFocus();
const mitk::VtkPropRenderer* glRenderer
= dynamic_cast<const mitk::VtkPropRenderer*>(br);
if (glRenderer)
{
vtkRenderer* vtkRenderer = glRenderer->GetVtkRenderer();
mitk::DataStorage* ds = br->GetDataStorage();
if (ds == NULL)
return false;
mitk::BoundingBox::Pointer bb = ds->ComputeBoundingBox();
mitk::Point3D middle = bb->GetCenter();
vtkRenderer->GetActiveCamera()->SetFocalPoint(middle[0],middle[1],middle[2]);
vtkRenderer->ResetCamera();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
return false;
}
bool mitk::WiiMoteInteractor::OnWiiMoteInput(Action* action, const mitk::StateEvent* stateEvent)
{
const mitk::WiiMoteAllDataEvent* wiiMoteEvent;
try
{
wiiMoteEvent =
dynamic_cast<const mitk::WiiMoteAllDataEvent*>(stateEvent->GetEvent());
}
catch(...)
{
MITK_ERROR << "Event is not wiimote event and could not be transformed\n";
}
m_SurfaceInteractionMode = wiiMoteEvent->GetSurfaceInteractionMode();
//this->FixedRotationAndTranslation(wiiMoteEvent);
// -------------------- values for translation --------------------
float xAccel = wiiMoteEvent->GetXAcceleration();
float yAccel = wiiMoteEvent->GetYAcceleration();
float zAccel = wiiMoteEvent->GetZAcceleration();
float pitch = wiiMoteEvent->GetPitch();
float roll = wiiMoteEvent->GetRoll();
m_OrientationX = wiiMoteEvent->GetOrientationX();
m_OrientationY = wiiMoteEvent->GetOrientationY();
m_OrientationZ = wiiMoteEvent->GetOrientationZ();
// substracts the proportionate force
// applied by gravity depending on the
// orientation
float sinP = sin(pitch/180.0 * M_PI);
float cosP = cos(pitch/180.0 * M_PI);
float sinR = sin(roll/180.0 * M_PI);
float cosR = cos(roll/180.0 * M_PI);
// x acceleration
if(m_OrientationZ >= 0)
{
m_xValue = xAccel - sinR * cosP;
}
else
{
m_xValue = xAccel + sinR * cosP;
}
//// against drift
//if(std::abs(xAccel) < 0.2)
//{
// m_xValue = 0;
//}
// y acceleration
m_yValue = yAccel + sinP;
//// against drift
//if(std::abs(yAccel) < 0.2)
//{
// m_yValue = 0;
//}
// z acceleration
m_zValue = zAccel - cosP * cosR;
//// against drift
//if(std::abs(zAccel) < 0.3)
//{
// m_zValue = 0;
//}
m_xVelocity += m_xValue;
m_yVelocity += m_yValue;
m_zVelocity -= m_zValue;
// -------------------- values for rotation --------------------
ScalarType pitchSpeed = wiiMoteEvent->GetPitchSpeed();
ScalarType rollSpeed = wiiMoteEvent->GetRollSpeed();
ScalarType yawSpeed = wiiMoteEvent->GetYawSpeed();
// x angle
if(std::abs(pitchSpeed) > 50
&& std::abs(pitchSpeed) < 1000)
{
if(m_SurfaceInteractionMode == 1)
{
m_xAngle = (pitchSpeed * DELTATIME);
}
else
{
m_xAngle = (-pitchSpeed * DELTATIME);
}
}
else
{
m_xAngle = 0;
}
// y angle
if(std::abs(rollSpeed) > 50
&& std::abs(rollSpeed) < 1000)
{
m_yAngle = (rollSpeed * DELTATIME);
}
else
{
m_yAngle = 0;
}
// z angle
if(std::abs(yawSpeed) > 50
&& std::abs(yawSpeed) < 1000)
{
if(m_SurfaceInteractionMode == 1)
{
m_zAngle = (yawSpeed * DELTATIME);
}
else
{
m_zAngle = (-yawSpeed * DELTATIME);
}
}
else
{
m_zAngle = 0;
}
// -------------------- rotation and translation --------------------
bool result = false;
result = this->DynamicRotationAndTranslation(this->TransformCurrentDataInGeometry3D());
return result;
}
bool mitk::WiiMoteInteractor::OnWiiMoteReleaseButton(Action* action, const mitk::StateEvent* stateEvent)
{
m_xVelocity = 0;
m_yVelocity = 0;
m_zVelocity = 0;
m_xValue = 0;
m_yValue = 0;
m_zValue = 0;
m_xAngle = 0;
m_yAngle = 0;
m_zAngle = 0;
// only for fixed translation
m_InRotation = false;
m_TranslationMode = 1;
return true;
}
mitk::Geometry3D* mitk::WiiMoteInteractor::TransformCurrentDataInGeometry3D()
{
//checking corresponding Data; has to be a surface or a subclass
mitk::Surface* surface = dynamic_cast<mitk::Surface*>(m_DataNode->GetData());
if ( surface == NULL )
{
MITK_WARN<<"Wiimote Interactor got wrong type of data! Aborting interaction!\n";
return NULL;
}
- Geometry3D* geometry = surface->GetUpdatedTimeSlicedGeometry()->GetGeometry3D( m_TimeStep );
+ Geometry3D* geometry = surface->GetUpdatedTimeGeometry()->GetGeometryForTimeStep( m_TimeStep );
return geometry;
}
vnl_matrix_fixed<double, 4, 4> mitk::WiiMoteInteractor::ComputeCurrentCameraPosition( vtkCamera* vtkCamera )
{
vnl_matrix_fixed<double, 4, 4> cameraMat;
//first we need the position of the camera
mitk::Vector3D camPosition;
double camPositionTemp[3];
vtkCamera->GetPosition(camPositionTemp);
camPosition[0] = camPositionTemp[0];
camPosition[1] = camPositionTemp[1];
camPosition[2] = camPositionTemp[2];
//then the upvector of the camera
mitk::Vector3D upCamVector;
double upCamTemp[3];
vtkCamera->GetViewUp(upCamTemp);
upCamVector[0] = upCamTemp[0];
upCamVector[1] = upCamTemp[1];
upCamVector[2] = upCamTemp[2];
upCamVector.Normalize();
//then the vector to which the camera is heading at (focalpoint)
mitk::Vector3D focalPoint;
double focalPointTemp[3];
vtkCamera->GetFocalPoint(focalPointTemp);
focalPoint[0] = focalPointTemp[0];
focalPoint[1] = focalPointTemp[1];
focalPoint[2] = focalPointTemp[2];
mitk::Vector3D focalVector;
focalVector = focalPoint - camPosition;
focalVector.Normalize();
//orthogonal vector to focalVector and upCamVector
mitk::Vector3D crossVector;
crossVector = CrossProduct(upCamVector, focalVector);
crossVector.Normalize();
cameraMat.put(0,0,crossVector[0]);
cameraMat.put(1,0,crossVector[1]);
cameraMat.put(2,0,crossVector[2]);
cameraMat.put(3,0,0);
cameraMat.put(0,1,focalVector[0]);
cameraMat.put(1,1,focalVector[1]);
cameraMat.put(2,1,focalVector[2]);
cameraMat.put(3,1,0);
cameraMat.put(0,2,upCamVector[0]);
cameraMat.put(1,2,upCamVector[1]);
cameraMat.put(2,2,upCamVector[2]);
cameraMat.put(3,2,0);
cameraMat.put(0,3,camPosition[0]);
cameraMat.put(1,3,camPosition[1]);
cameraMat.put(2,3,camPosition[2]);
cameraMat.put(3,3,1);
return cameraMat;
}
bool mitk::WiiMoteInteractor::DynamicRotationAndTranslation(Geometry3D* geometry)
{
// computation of the delta transformation
if(m_SurfaceInteractionMode == 1)
{
// necessary because the wiimote has
// a different orientation when loaded
// as an object file
ScalarType temp = m_yAngle;
m_yAngle = m_zAngle;
m_zAngle = temp;
}
//vnl_quaternion<double> Rx(m_OrientationX
// ,m_OrientationY
// ,m_OrientationZ
// , m_xAngle);
//vnl_quaternion<double> Ry(Rx.axis()[0]
// , Rx.axis()[1]
// , Rx.axis()[2]
// , m_yAngle);
//vnl_quaternion<double> Rz(Ry.axis()[0]
// , Ry.axis()[1]
// , Ry.axis()[2]
// , m_zAngle);
vnl_quaternion<double> q(
vtkMath::RadiansFromDegrees( m_xAngle ),
vtkMath::RadiansFromDegrees( m_yAngle ),
vtkMath::RadiansFromDegrees( m_zAngle ) );
//q = Rz * Ry * Rx;
//q.normalize();
vnl_matrix_fixed<double, 4, 4> deltaTransformMat = q.rotation_matrix_transpose_4();
// fill translation column
deltaTransformMat(0,3) = m_xVelocity;
deltaTransformMat(1,3) = m_yVelocity;
deltaTransformMat(2,3) = m_zVelocity;
// invert matrix to apply
// correct order for the transformation
deltaTransformMat = vnl_inverse(deltaTransformMat);
vtkMatrix4x4* deltaTransform = vtkMatrix4x4::New();
// copy into matrix
for(size_t i=0; i<4; ++i)
for(size_t j=0; j<4; ++j)
deltaTransform->SetElement(i,j, deltaTransformMat(i,j));
vtkMatrix4x4* objectTransform = vtkMatrix4x4::New();
if(m_SurfaceInteractionMode == 2)
{
// additional computation for transformation
// relative to the camera view
// get renderer
const RenderingManager::RenderWindowVector& renderWindows
= RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
for ( RenderingManager::RenderWindowVector::const_iterator iter = renderWindows.begin();
iter != renderWindows.end();
++iter )
{
if ( mitk::BaseRenderer::GetInstance((*iter))->GetMapperID() == BaseRenderer::Standard3D )
{
m_BaseRenderer = mitk::BaseRenderer::GetInstance((*iter));
}
}
vtkCamera* camera
= m_BaseRenderer->GetVtkRenderer()->GetActiveCamera();
//vtkMatrix4x4* cameraMat = vtkMatrix4x4::New();
vnl_matrix_fixed<double, 4, 4> cameraMat;
vnl_matrix_fixed<double, 4, 4> objectMat;
// copy object matrix
for(size_t i=0; i<4; ++i)
for(size_t j=0; j<4; ++j)
objectMat.put(i,j, geometry->GetVtkTransform()->GetMatrix()->GetElement(i,j));
cameraMat = this->ComputeCurrentCameraPosition(camera);
vnl_matrix_fixed<double, 4, 4> newObjectMat;
vnl_matrix_fixed<double, 4, 4> objectToCameraMat;
objectToCameraMat = vnl_inverse(cameraMat) * objectMat;
newObjectMat = vnl_inverse(objectToCameraMat)
* deltaTransformMat
* objectToCameraMat
* vnl_inverse(objectMat);
newObjectMat = vnl_inverse(newObjectMat);
newObjectMat.put(0,3,objectMat(0,3)+deltaTransformMat(0,3));
newObjectMat.put(1,3,objectMat(1,3)+deltaTransformMat(1,3));
newObjectMat.put(2,3,objectMat(2,3)+deltaTransformMat(2,3));
// copy result
for(size_t i=0; i<4; ++i)
for(size_t j=0; j<4; ++j)
objectTransform->SetElement(i,j, newObjectMat(i,j));
}
//copy m_vtkMatrix to m_VtkIndexToWorldTransform
geometry->TransferItkToVtkTransform();
vtkTransform* vtkTransform = vtkTransform::New();
if(m_SurfaceInteractionMode == 1)
{
//m_VtkIndexToWorldTransform as vtkLinearTransform*
vtkTransform->SetMatrix( geometry->GetVtkTransform()->GetMatrix() );
vtkTransform->Concatenate( deltaTransform );
geometry->SetIndexToWorldTransformByVtkMatrix( vtkTransform->GetMatrix() );
}
else
{
geometry->SetIndexToWorldTransformByVtkMatrix( objectTransform );
}
geometry->Modified();
m_DataNode->Modified();
vtkTransform->Delete();
objectTransform->Delete();
deltaTransform->Delete();
//update rendering
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
bool mitk::WiiMoteInteractor::FixedRotationAndTranslation(const mitk::WiiMoteAllDataEvent* wiiMoteEvent)
{
Geometry3D* geometry = this->TransformCurrentDataInGeometry3D();
m_OrientationX = wiiMoteEvent->GetOrientationX();
m_OrientationY = wiiMoteEvent->GetOrientationY();
m_OrientationZ = wiiMoteEvent->GetOrientationZ();
ScalarType pitchSpeed = wiiMoteEvent->GetPitchSpeed();
ScalarType rollSpeed = wiiMoteEvent->GetRollSpeed();
ScalarType yawSpeed = wiiMoteEvent->GetYawSpeed();
// angle x
if(std::abs(pitchSpeed) < 200)
pitchSpeed = 0;
m_xAngle += (pitchSpeed / 1500);
// angle y
if(std::abs(rollSpeed) < 200)
rollSpeed = 0;
m_yAngle += (rollSpeed / 1500);
// angle z
if(std::abs(yawSpeed) < 200)
yawSpeed = 0;
m_zAngle += (yawSpeed / 1500);
if( std::abs(pitchSpeed) > 200
|| std::abs(rollSpeed) > 200
|| std::abs(yawSpeed) > 200)
{
m_InRotation = true;
//// depending on a combination of the
//// orientation the angleX wil be altered
//// because the range from roll is limited
//// range: -90� to 90� by the wiimote
//if(wiiMoteEvent->GetOrientationZ() < 0)
//{
// // value is positive
// if(wiiMoteEvent->GetOrientationX() > 0)
// {
// // the degree measured decreases after it reaches
// // in the "real" world the 90 degree angle
// // (rotation to the right side)
// // therefore it needs to artificially increased
// // measured value drops -> computated angle increases
// angleX = 90 - angleX;
// // now add the "new" angle to 90 degree threshold
// angleX += 90;
// }
// // value is negative
// else if(wiiMoteEvent->GetOrientationX() < 0)
// {
// // the degree measured increases after it reaches
// // in the "real" world -90 degree
// // (rotation to the left side)
// // therefore it needs to be artificially decreased
// // (example -90 -> -70, but -110 is needed)
// // measured value increases -> computated angle decreases
// angleX = 90 + angleX;
// // invert the algebraic sign, because it is the "negative"
// // side of the rotation
// angleX = -angleX;
// // now add the negative value to the -90 degree threshold
// // to decrease the value further
// angleX -= 90;
// }
// else if(wiiMoteEvent->GetOrientationX() == 0)
// {
// // i.e. wiimote is flipped upside down
// angleX = 180;
// }
//}
//rotation
vtkTransform *vtkTransform = vtkTransform::New();
//copy m_vtkMatrix to m_VtkIndexToWorldTransform
geometry->TransferItkToVtkTransform();
//////m_VtkIndexToWorldTransform as vtkLinearTransform*
vtkTransform->SetMatrix(geometry->GetVtkTransform()->GetMatrix());
// rotation from center is different
// from rotation while translated
// hence one needs the center of the object
Point3D center = geometry->GetOrigin();
vtkTransform->PostMultiply();
vtkTransform->Translate(-center[0], -center[1], -center[2]);
//vtkTransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
vtkTransform->RotateX(m_xAngle);
vtkTransform->RotateY(m_zAngle);
vtkTransform->RotateZ(m_yAngle);
vtkTransform->Translate(center[0], center[1], center[2]);
vtkTransform->PreMultiply();
geometry->SetIndexToWorldTransformByVtkMatrix(vtkTransform->GetMatrix());
geometry->Modified();
// indicate modification of data tree node
m_DataNode->Modified();
vtkTransform->Delete();
//update rendering
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
else if(!m_InRotation)
{
float xValue = wiiMoteEvent->GetXAcceleration();
float yValue = wiiMoteEvent->GetYAcceleration();
float zValue = wiiMoteEvent->GetZAcceleration();
float pitch = wiiMoteEvent->GetPitch();
float roll = wiiMoteEvent->GetRoll();
// substracts the proportionate force
// applied by gravity depending on the
// orientation
float sinP = sin(pitch/180.0 * M_PI);
float cosP = cos(pitch/180.0 * M_PI);
float sinR = sin(roll/180.0 * M_PI);
float cosR = cos(roll/180.0 * M_PI);
// x acceleration
if(m_OrientationZ >= 0)
xValue = xValue - sinR * cosP;
else
xValue = xValue + sinR * cosP;
// against drift
if(std::abs(xValue) < 0.2)
xValue = 0;
// y acceleration
yValue = yValue + sinP;
// against drift
if(std::abs(yValue) < 0.2)
yValue = 0;
// z acceleration
zValue = zValue - cosP * cosR;
// against drift
if(std::abs(zValue) < 0.3)
zValue = 0;
// simple integration over time
// resulting in velocity
switch(m_TranslationMode)
{
case 1:
m_xVelocity -= xValue;
m_yVelocity -= yValue;
m_zVelocity += zValue;
// 1 = movement to the right
// initially starts with negative acceleration
// 2 = movement to the left
// initially starts with positive acceleration
if( m_xVelocity > 0 && xValue > 0 // 1
|| m_xVelocity < 0 && xValue < 0) // 2
{
m_xVelocity += xValue;
}
else if( m_xVelocity > 0 && xValue < 0 // 1
|| m_xVelocity < 0 && xValue > 0) // 2
{
m_xVelocity -= xValue;
}
break;
case 3:
m_yVelocity -= yValue;
break;
case 4:
// 1 = movement up
// initially starts with positive acceleration
// 2 = movement down
// initially starts with negative acceleration
if( m_zVelocity > 0 && zValue < 0 // 1
|| m_zVelocity < 0 && zValue > 0) // 2
{
m_zVelocity -= zValue;
}
else if(m_zVelocity > 0 && zValue > 0 // 1
|| m_zVelocity < 0 && zValue < 0) // 2
{
m_zVelocity += zValue;
}
break;
}
// sets the mode of the translation
// depending on the initial velocity
if( std::abs(m_xVelocity) > std::abs(m_yVelocity)
&& std::abs(m_xVelocity) > std::abs(m_zVelocity) )
{
m_TranslationMode = 2;
m_yVelocity = 0;
m_zVelocity = 0;
}
else if( std::abs(m_yVelocity) > std::abs(m_xVelocity)
&& std::abs(m_yVelocity) > std::abs(m_zVelocity) )
{
m_TranslationMode = 3;
m_xVelocity = 0;
m_zVelocity = 0;
}
else if(std::abs(m_zVelocity) > std::abs(m_xVelocity)
&& std::abs(m_zVelocity) > std::abs(m_yVelocity) )
{
m_TranslationMode = 4;
m_xVelocity = 0;
m_yVelocity = 0;
}
// translation
mitk::Vector3D movementVector;
movementVector.SetElement(0,m_xVelocity);
movementVector.SetElement(1,m_yVelocity);
movementVector.SetElement(2,m_zVelocity);
geometry->Translate(movementVector);
// indicate modification of data tree node
m_DataNode->Modified();
// update rendering
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return true;
}
return false;
}
diff --git a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
index c903b223e0..61d8c765cf 100644
--- a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
@@ -1,186 +1,170 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetToCurvedGeometryFilter.h"
#include "mitkThinPlateSplineCurvedGeometry.h"
#include "mitkPlaneGeometry.h"
#include "mitkImage.h"
-#include "mitkTimeSlicedGeometry.h"
#include "mitkDataNode.h"
#include "mitkGeometryData.h"
#include "mitkGeometry2DData.h"
#include "mitkProperties.h"
#include "itkMesh.h"
#include "itkPointSet.h"
mitk::PointSetToCurvedGeometryFilter::PointSetToCurvedGeometryFilter()
{
m_ProjectionMode = YZPlane;
m_PCAPlaneCalculator = mitk::PlaneFit::New();
m_ImageToBeMapped = NULL;
m_Sigma = 1000;
mitk::Geometry2DData::Pointer output = static_cast<mitk::Geometry2DData*> ( this->MakeOutput ( 0 ).GetPointer() );
output->Initialize();
Superclass::SetNumberOfRequiredOutputs ( 1 );
Superclass::SetNthOutput ( 0, output.GetPointer() );
}
mitk::PointSetToCurvedGeometryFilter::~PointSetToCurvedGeometryFilter()
{}
void mitk::PointSetToCurvedGeometryFilter::GenerateOutputInformation()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::Geometry2DData::Pointer output = dynamic_cast<mitk::Geometry2DData*> ( this->GetOutput() );
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
if ( input->GetTimeGeometry()->GetNumberOfTimeSteps() != 1 )
itkWarningMacro ( "More than one time step is not yet supported!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "Output is NULL!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
bool update = false;
if ( output->GetGeometry() == NULL || output->GetGeometry2D() == NULL || output->GetTimeGeometry() == NULL )
update = true;
if ( ( ! update ) && ( output->GetTimeGeometry()->GetNumberOfTimeSteps() != input->GetTimeGeometry()->GetNumberOfTimeSteps() ) )
update = true;
if ( update )
{
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
output->SetGeometry(curvedGeometry);
-
- /*
- mitk::TimeSlicedGeometry::Pointer timeGeometry = mitk::TimeSlicedGeometry::New();
- mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
-
- timeGeometry->InitializeEvenlyTimed ( curvedGeometry, input->GetPointSetSeriesSize() );
-
- for ( unsigned int t = 1; t < input->GetPointSetSeriesSize(); ++t )
- {
- mitk::ThinPlateSplineCurvedGeometry::Pointer tmpCurvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
- timeGeometry->SetGeometry3D ( tmpCurvedGeometry.GetPointer(), t );
- }
- output->SetGeometry ( timeGeometry );
- output->SetGeometry2D ( curvedGeometry ); // @FIXME SetGeometry2D of mitk::Geometry2DData reinitializes the TimeSlicedGeometry to 1 time step
- */
}
}
void mitk::PointSetToCurvedGeometryFilter::GenerateData()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
//
// check preconditions
//
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "output geometry data is NULL!" );
if ( output->GetTimeGeometry() == NULL )
itkGenericExceptionMacro ( "Output time sliced geometry is NULL!" );
if ( output->GetTimeGeometry()->GetGeometryForTimeStep ( 0 ) == NULL )
itkGenericExceptionMacro ( "Output geometry3d is NULL!" );
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = dynamic_cast<mitk::ThinPlateSplineCurvedGeometry*> ( output->GetTimeGeometry()->GetGeometryForTimeStep( 0 ) );
if ( curvedGeometry.IsNull() )
itkGenericExceptionMacro ( "Output geometry3d is not an instance of mitk::ThinPlateSPlineCurvedGeometry!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
//
// initialize members if needed
//
if ( m_XYPlane.IsNull() || m_XZPlane.IsNull() || m_YZPlane.IsNull() )
{
m_ImageToBeMapped->UpdateOutputInformation();
const mitk::Geometry3D* imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
m_XYPlane = mitk::PlaneGeometry::New();
m_XZPlane = mitk::PlaneGeometry::New();
m_YZPlane = mitk::PlaneGeometry::New();
m_XYPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Axial );
m_YZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Sagittal );
m_XZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Frontal );
}
if ( m_PlaneLandmarkProjector.IsNull() )
{
m_PlaneLandmarkProjector = mitk::PlaneLandmarkProjector::New();
m_SphereLandmarkProjector = mitk::SphereLandmarkProjector::New();
}
//
// set up geometry according to the current settings
//
if ( m_ProjectionMode == Sphere )
{
curvedGeometry->SetLandmarkProjector ( m_SphereLandmarkProjector );
}
else
{
if ( m_ProjectionMode == XYPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XYPlane );
else if ( m_ProjectionMode == XZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XZPlane );
else if ( m_ProjectionMode == YZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_YZPlane );
else if ( m_ProjectionMode == PCAPlane )
{
itkExceptionMacro ( "PCAPlane not yet implemented!" );
m_PCAPlaneCalculator->SetInput ( input );
m_PCAPlaneCalculator->Update();
m_PlaneLandmarkProjector->SetProjectionPlane ( dynamic_cast<mitk::PlaneGeometry*> ( m_PCAPlaneCalculator->GetOutput() ) );
}
else
itkExceptionMacro ( "Unknown projection mode" );
curvedGeometry->SetLandmarkProjector ( m_PlaneLandmarkProjector );
}
//curvedGeometry->SetReferenceGeometry( m_ImageToBeMapped->GetGeometry() );
curvedGeometry->SetTargetLandmarks ( input->GetPointSet ( 0 )->GetPoints() );
curvedGeometry->SetSigma ( m_Sigma );
curvedGeometry->ComputeGeometry();
curvedGeometry->SetOversampling ( 1.0 );
}
mitk::GeometryDataSource::DataObjectPointer mitk::PointSetToCurvedGeometryFilter::MakeOutput ( unsigned int )
{
return static_cast<itk::DataObject*> ( mitk::Geometry2DData::New().GetPointer() );
}
void mitk::PointSetToCurvedGeometryFilter::SetDefaultCurvedGeometryProperties ( mitk::DataNode* node )
{
if ( node == NULL )
{
itkGenericOutputMacro ( "Warning: node is NULL!" );
return;
}
node->SetIntProperty ( "xresolution", 50 );
node->SetIntProperty ( "yresolution", 50 );
node->SetProperty ( "name", mitk::StringProperty::New ( "Curved Plane" ) );
// exclude extent of this plane when calculating DataStorage bounding box
node->SetProperty ( "includeInBoundingBox", mitk::BoolProperty::New ( false ) );
}
diff --git a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
index 57da13dfef..d4de54da9b 100644
--- a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
@@ -1,218 +1,217 @@
/*===================================================================
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 "mitkProbeFilter.h"
#include "mitkSurface.h"
#include "mitkImage.h"
-#include "mitkTimeSlicedGeometry.h"
#include <vtkPolyDataSource.h>
#include <vtkProbeFilter.h>
#include <itkImageRegion.h>
#include <vtkDataSet.h>
#include <vtkPolyData.h>
#include <vtkImageData.h>
#include <itkSmartPointerForwardReference.txx>
mitk::ProbeFilter::ProbeFilter()
{
}
mitk::ProbeFilter::~ProbeFilter()
{
}
const mitk::Surface *mitk::ProbeFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast< const mitk::Surface * >(this->ProcessObject::GetInput(0) );
}
const mitk::Image *mitk::ProbeFilter::GetSource(void)
{
return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
}
void mitk::ProbeFilter::SetInput(const mitk::Surface *input)
{
this->ProcessObject::SetNthInput( 0, const_cast< mitk::Surface * >( input ) );
}
void mitk::ProbeFilter::SetSource(const mitk::Image *source)
{
this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
}
void mitk::ProbeFilter::GenerateOutputInformation()
{
mitk::Surface::ConstPointer input = this->GetInput();
mitk::Image::ConstPointer source = this->GetSource();
mitk::Surface::Pointer output = this->GetOutput();
if(input.IsNull()) return;
if(source.IsNull()) return;
if(input->GetGeometry()==NULL) return;
if(source->GetGeometry()==NULL) return;
if( (input->GetTimeGeometry()->GetNumberOfTimeSteps()==1) && (source->GetTimeGeometry()->GetNumberOfTimeSteps()>1) )
{
Geometry3D::Pointer geometry3D = Geometry3D::New();
geometry3D->Initialize();
geometry3D->SetBounds(source->GetTimeGeometry()->GetBoundsInWorld());
geometry3D->SetTimeBounds(source->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetTimeBounds());
- TimeSlicedGeometry::Pointer outputTimeSlicedGeometry = TimeSlicedGeometry::New();
- outputTimeSlicedGeometry->InitializeEvenlyTimed(geometry3D, source->GetTimeGeometry()->GetNumberOfTimeSteps());
+ ProportionalTimeGeometry::Pointer outputTimeGeometry = ProportionalTimeGeometry::New();
+ outputTimeGeometry->Initialize(geometry3D, source->GetTimeGeometry()->GetNumberOfTimeSteps());
- output->Expand(outputTimeSlicedGeometry->GetTimeSteps());
- output->SetGeometry( outputTimeSlicedGeometry );
+ output->Expand(outputTimeGeometry->GetNumberOfTimeSteps());
+ output->SetTimeGeometry( outputTimeGeometry );
}
else
output->SetGeometry( static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()) );
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ProbeFilter::GenerateData()
{
mitk::Surface *input = const_cast< mitk::Surface * >(this->GetInput());
mitk::Image *source = const_cast< mitk::Image * >(this->GetSource());
mitk::Surface::Pointer output = this->GetOutput();
itkDebugMacro(<<"Generating Data");
if(output.IsNull())
{
itkDebugMacro(<<"Output is NULL.");
return;
}
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
TimePointType timeInMS;
int timestep=0;
int tstart, tmax;
tstart=outputRegion.GetIndex(3);
tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
vtkProbeFilter* probe = vtkProbeFilter::New();
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
probe->SetInput( input->GetVtkPolyData(timestep) );
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
probe->SetSource( source->GetVtkImageData(timestep) );
output->SetVtkPolyData( probe->GetPolyDataOutput(), t );
probe->Update();
probe->Delete();
}
}
void mitk::ProbeFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Surface *input = const_cast< mitk::Surface * >( this->GetInput() );
mitk::Image *source = const_cast< mitk::Image * >( this->GetSource() );
if(input==NULL) return;
if(source==NULL) return;
mitk::Surface::Pointer output = this->GetOutput();
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
mitk::Surface::RegionType inputSurfaceRegion = outputRegion;
Image::RegionType sourceImageRegion = source->GetLargestPossibleRegion();
if(outputRegion.GetSize(3)<1)
{
mitk::Surface::RegionType::SizeType surfacesize;
surfacesize.Fill(0);
inputSurfaceRegion.SetSize(surfacesize);
input->SetRequestedRegion( &inputSurfaceRegion );
mitk::Image::RegionType::SizeType imagesize;
imagesize.Fill(0);
sourceImageRegion.SetSize(imagesize);
source->SetRequestedRegion( &sourceImageRegion );
return;
}
//create and set input requested region for the input surface
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
ScalarType timeInMS;
int timestep=0;
// convert the start-index-time of output in start-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTimeStep( timestep ) ) )
inputSurfaceRegion.SetIndex( 3, timestep );
else
inputSurfaceRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
inputSurfaceRegion.SetSize( 3, timestep - inputSurfaceRegion.GetIndex(3) + 1 );
else
inputSurfaceRegion.SetSize( 3, 1 );
input->SetRequestedRegion( &inputSurfaceRegion );
//create and set input requested region for the source image
const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
// convert the start-index-time of output in start-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( sourceTimeGeometry->IsValidTimeStep( timestep ) ) )
sourceImageRegion.SetIndex( 3, timestep );
else
sourceImageRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
sourceImageRegion.SetSize( 3, timestep - sourceImageRegion.GetIndex(3) + 1 );
else
sourceImageRegion.SetSize( 3, 1 );
sourceImageRegion.SetIndex( 4, 0 );
sourceImageRegion.SetSize( 4, 1 );
source->SetRequestedRegion( &sourceImageRegion );
}
diff --git a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
index 4bbbc5fc54..73004052af 100644
--- a/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
+++ b/Modules/QmitkExt/QmitkSlicesInterpolator.cpp
@@ -1,1079 +1,1079 @@
/*===================================================================
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 "QmitkSlicesInterpolator.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkSelectableGLWidget.h"
#include "mitkToolManager.h"
#include "mitkDataNodeFactory.h"
#include "mitkLevelWindowProperty.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkRenderingManager.h"
#include "mitkOverwriteSliceImageFilter.h"
#include "mitkProgressBar.h"
#include "mitkGlobalInteraction.h"
#include "mitkOperationEvent.h"
#include "mitkUndoController.h"
#include "mitkInteractionConst.h"
#include "mitkApplyDiffImageOperation.h"
#include "mitkDiffImageApplier.h"
#include "mitkSegTool2D.h"
#include "mitkCoreObjectFactory.h"
#include "mitkSurfaceToImageFilter.h"
#include <itkCommand.h>
#include <QCheckBox>
#include <QPushButton>
#include <QMenu>
#include <QCursor>
#include <QHBoxLayout>
#include <QMessageBox>
#define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
const std::map<QAction*, unsigned int> QmitkSlicesInterpolator::createActionToSliceDimension()
{
std::map<QAction*, unsigned int> actionToSliceDimension;
actionToSliceDimension[new QAction("Axial (red window)", 0)] = 2;
actionToSliceDimension[new QAction("Sagittal (green window)", 0)] = 0;
actionToSliceDimension[new QAction("Coronal (blue window)", 0)] = 1;
return actionToSliceDimension;
}
QmitkSlicesInterpolator::QmitkSlicesInterpolator(QWidget* parent, const char* /*name*/)
:QWidget(parent),
ACTION_TO_SLICEDIMENSION( createActionToSliceDimension() ),
m_Interpolator( mitk::SegmentationInterpolationController::New() ),
m_MultiWidget(NULL),
m_ToolManager(NULL),
m_Initialized(false),
m_LastSliceDimension(2),
m_LastSliceIndex(0),
m_2DInterpolationEnabled(false),
m_3DInterpolationEnabled(false)
{
m_SurfaceInterpolator = mitk::SurfaceInterpolationController::GetInstance();
QHBoxLayout* layout = new QHBoxLayout(this);
m_GroupBoxEnableExclusiveInterpolationMode = new QGroupBox("Interpolation", this);
QGridLayout* grid = new QGridLayout(m_GroupBoxEnableExclusiveInterpolationMode);
m_RBtnEnable3DInterpolation = new QRadioButton("3D",this);
connect(m_RBtnEnable3DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
m_RBtnEnable3DInterpolation->setChecked(true);
m_RBtnEnable3DInterpolation->setToolTip("Interpolate a binary volume from a set of arbitrarily arranged contours.");
grid->addWidget(m_RBtnEnable3DInterpolation,0,0);
m_BtnAccept3DInterpolation = new QPushButton("Accept", this);
m_BtnAccept3DInterpolation->setEnabled(false);
connect(m_BtnAccept3DInterpolation, SIGNAL(clicked()), this, SLOT(OnAccept3DInterpolationClicked()));
grid->addWidget(m_BtnAccept3DInterpolation, 0,1);
m_CbShowMarkers = new QCheckBox("Show Position Nodes", this);
m_CbShowMarkers->setChecked(false);
connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SLOT(OnShowMarkers(bool)));
connect(m_CbShowMarkers, SIGNAL(toggled(bool)), this, SIGNAL(SignalShowMarkerNodes(bool)));
grid->addWidget(m_CbShowMarkers,0,2);
m_RBtnEnable2DInterpolation = new QRadioButton("2D",this);
connect(m_RBtnEnable2DInterpolation, SIGNAL(toggled(bool)), this, SLOT(On2DInterpolationEnabled(bool)));
m_RBtnEnable2DInterpolation ->setToolTip("Interpolate contours in left-out slices from a set of slice-by-slice arranged contours.");
grid->addWidget(m_RBtnEnable2DInterpolation,1,0);
m_BtnAcceptInterpolation = new QPushButton("Accept", this);
m_BtnAcceptInterpolation->setEnabled( false );
connect( m_BtnAcceptInterpolation, SIGNAL(clicked()), this, SLOT(OnAcceptInterpolationClicked()) );
grid->addWidget(m_BtnAcceptInterpolation,1,1);
m_BtnAcceptAllInterpolations = new QPushButton("... for all slices", this);
m_BtnAcceptAllInterpolations->setEnabled( false );
connect( m_BtnAcceptAllInterpolations, SIGNAL(clicked()), this, SLOT(OnAcceptAllInterpolationsClicked()) );
grid->addWidget(m_BtnAcceptAllInterpolations,1,2);
m_RBtnDisableInterpolation = new QRadioButton("Disable", this);
connect(m_RBtnDisableInterpolation, SIGNAL(toggled(bool)), this, SLOT(OnInterpolationDisabled(bool)));
m_RBtnDisableInterpolation->setToolTip("Disable interpolation.");
grid->addWidget(m_RBtnDisableInterpolation, 2,0);
layout->addWidget(m_GroupBoxEnableExclusiveInterpolationMode);
this->setLayout(layout);
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnInterpolationInfoChanged );
InterpolationInfoChangedObserverTag = m_Interpolator->AddObserver( itk::ModifiedEvent(), command );
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command2 = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command2->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged );
SurfaceInterpolationInfoChangedObserverTag = m_SurfaceInterpolator->AddObserver( itk::ModifiedEvent(), command2 );
// feedback node and its visualization properties
m_FeedbackNode = mitk::DataNode::New();
mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties( m_FeedbackNode );
m_FeedbackNode->SetProperty( "binary", mitk::BoolProperty::New(true) );
m_FeedbackNode->SetProperty( "outline binary", mitk::BoolProperty::New(true) );
m_FeedbackNode->SetProperty( "color", mitk::ColorProperty::New(255.0, 255.0, 0.0) );
m_FeedbackNode->SetProperty( "texture interpolation", mitk::BoolProperty::New(false) );
m_FeedbackNode->SetProperty( "layer", mitk::IntProperty::New( 20 ) );
m_FeedbackNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( mitk::LevelWindow(0, 1) ) );
m_FeedbackNode->SetProperty( "name", mitk::StringProperty::New("Interpolation feedback") );
m_FeedbackNode->SetProperty( "opacity", mitk::FloatProperty::New(0.8) );
m_FeedbackNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
m_InterpolatedSurfaceNode = mitk::DataNode::New();
m_InterpolatedSurfaceNode->SetProperty( "color", mitk::ColorProperty::New(255.0,255.0,0.0) );
m_InterpolatedSurfaceNode->SetProperty( "name", mitk::StringProperty::New("Surface Interpolation feedback") );
m_InterpolatedSurfaceNode->SetProperty( "opacity", mitk::FloatProperty::New(0.5) );
m_InterpolatedSurfaceNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
m_InterpolatedSurfaceNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
m_InterpolatedSurfaceNode->SetVisibility(false);
m_3DContourNode = mitk::DataNode::New();
m_3DContourNode->SetProperty( "color", mitk::ColorProperty::New(0.0, 0.0, 0.0) );
m_3DContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty( "name", mitk::StringProperty::New("Drawn Contours") );
m_3DContourNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New(VTK_WIREFRAME));
m_3DContourNode->SetProperty("material.wireframeLineWidth", mitk::FloatProperty::New(2.0f));
m_3DContourNode->SetProperty("3DContourContainer", mitk::BoolProperty::New(true));
m_3DContourNode->SetProperty( "includeInBoundingBox", mitk::BoolProperty::New(false));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget2")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
m_3DContourNode->SetVisibility(false, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
QWidget::setContentsMargins(0, 0, 0, 0);
if ( QWidget::layout() != NULL )
{
QWidget::layout()->setContentsMargins(0, 0, 0, 0);
}
//For running 3D Interpolation in background
// create a QFuture and a QFutureWatcher
connect(&m_Watcher, SIGNAL(started()), this, SLOT(StartUpdateInterpolationTimer()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(OnSurfaceInterpolationFinished()));
connect(&m_Watcher, SIGNAL(finished()), this, SLOT(StopUpdateInterpolationTimer()));
m_Timer = new QTimer(this);
connect(m_Timer, SIGNAL(timeout()), this, SLOT(ChangeSurfaceColor()));
}
void QmitkSlicesInterpolator::SetDataStorage( mitk::DataStorage& storage )
{
m_DataStorage = &storage;
m_SurfaceInterpolator->SetDataStorage(storage);
}
mitk::DataStorage* QmitkSlicesInterpolator::GetDataStorage()
{
if ( m_DataStorage.IsNotNull() )
{
return m_DataStorage;
}
else
{
return NULL;
}
}
void QmitkSlicesInterpolator::Initialize(mitk::ToolManager* toolManager, QmitkStdMultiWidget* multiWidget)
{
if (m_Initialized)
{
// remove old observers
if (m_ToolManager)
{
m_ToolManager->WorkingDataChanged
-= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
m_ToolManager->ReferenceDataChanged
-= mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
}
if (m_MultiWidget)
{
disconnect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( TSliceObserverTag );
slicer->RemoveObserver( TTimeObserverTag );
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( SSliceObserverTag );
slicer->RemoveObserver( STimeObserverTag );
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( FSliceObserverTag );
slicer->RemoveObserver( FTimeObserverTag );
}
//return;
}
m_MultiWidget = multiWidget;
connect( m_MultiWidget, SIGNAL(destroyed(QObject*)), this, SLOT(OnMultiWidgetDeleted(QObject*)) );
m_ToolManager = toolManager;
if (m_ToolManager)
{
// set enabled only if a segmentation is selected
mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
QWidget::setEnabled( node != NULL );
// react whenever the set of selected segmentation changes
m_ToolManager->WorkingDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerWorkingDataModified );
m_ToolManager->ReferenceDataChanged += mitk::MessageDelegate<QmitkSlicesInterpolator>( this, &QmitkSlicesInterpolator::OnToolManagerReferenceDataModified );
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
if (m_MultiWidget)
{
mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
m_TimeStep.resize(3);
m_TimeStep[2] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialTimeChanged );
TTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnAxialSliceChanged );
TSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
m_TimeStep[0] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalTimeChanged );
STimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnSagittalSliceChanged );
SSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
// connect to the steppers of the three multi widget widgets. after each change, call the interpolator
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
m_TimeStep[1] = slicer->GetTime()->GetPos();
{
itk::MemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::MemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalTimeChanged );
FTimeObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), command );
}
{
itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::Pointer command = itk::ReceptorMemberCommand<QmitkSlicesInterpolator>::New();
command->SetCallbackFunction( this, &QmitkSlicesInterpolator::OnFrontalSliceChanged );
FSliceObserverTag = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
}
}
}
m_Initialized = true;
}
QmitkSlicesInterpolator::~QmitkSlicesInterpolator()
{
if (m_MultiWidget)
{
mitk::SliceNavigationController* slicer;
if(m_MultiWidget->mitkWidget1 != NULL)
{
slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
slicer->RemoveObserver( TSliceObserverTag );
slicer->RemoveObserver( TTimeObserverTag );
}
if(m_MultiWidget->mitkWidget2 != NULL)
{
slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
slicer->RemoveObserver( SSliceObserverTag );
slicer->RemoveObserver( STimeObserverTag );
}
if(m_MultiWidget->mitkWidget3 != NULL)
{
slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
slicer->RemoveObserver( FSliceObserverTag );
slicer->RemoveObserver( FTimeObserverTag );
}
}
if(m_DataStorage->Exists(m_3DContourNode))
m_DataStorage->Remove(m_3DContourNode);
if(m_DataStorage->Exists(m_InterpolatedSurfaceNode))
m_DataStorage->Remove(m_InterpolatedSurfaceNode);
// remove observer
m_Interpolator->RemoveObserver( InterpolationInfoChangedObserverTag );
m_SurfaceInterpolator->RemoveObserver( SurfaceInterpolationInfoChangedObserverTag );
delete m_Timer;
}
void QmitkSlicesInterpolator::On2DInterpolationEnabled(bool status)
{
OnInterpolationActivated(status);
m_Interpolator->Activate2DInterpolation(status);
}
void QmitkSlicesInterpolator::On3DInterpolationEnabled(bool status)
{
On3DInterpolationActivated(status);
}
void QmitkSlicesInterpolator::OnInterpolationDisabled(bool status)
{
if (status)
{
OnInterpolationActivated(!status);
On3DInterpolationActivated(!status);
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnShowMarkers(bool state)
{
mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = m_DataStorage->GetSubset(mitk::NodePredicateProperty::New("isContourMarker"
, mitk::BoolProperty::New(true)));
for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
{
it->Value()->SetProperty("helper object", mitk::BoolProperty::New(!state));
}
}
void QmitkSlicesInterpolator::OnToolManagerWorkingDataModified()
{
//Check if the new working data has already a contourlist for 3D interpolation
this->SetCurrentContourListID();
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated( true ); // re-initialize if needed
}
if (m_3DInterpolationEnabled)
{
//On3DInterpolationActivated( true);
SetCurrentContourListID();
}
}
void QmitkSlicesInterpolator::OnToolManagerReferenceDataModified()
{
if (m_2DInterpolationEnabled)
{
OnInterpolationActivated( true ); // re-initialize if needed
}
if (m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnAxialTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[2] = event.GetPos();
if (m_LastSliceDimension == 2)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnTransversalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
this->OnAxialTimeChanged(sender, e);
}
void QmitkSlicesInterpolator::OnSagittalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[0] = event.GetPos();
if (m_LastSliceDimension == 0)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnFrontalTimeChanged(itk::Object* sender, const itk::EventObject& e)
{
const mitk::SliceNavigationController::GeometryTimeEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent&>(e);
m_TimeStep[1] = event.GetPos();
if (m_LastSliceDimension == 1)
{
mitk::SliceNavigationController* snc = dynamic_cast<mitk::SliceNavigationController*>( sender );
if (snc) snc->SendSlice(); // will trigger a new interpolation
}
}
void QmitkSlicesInterpolator::OnAxialSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 2 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RequestUpdate();
}
}
}
void QmitkSlicesInterpolator::OnTransversalSliceChanged(const itk::EventObject& e)
{
this->OnAxialSliceChanged(e);
}
void QmitkSlicesInterpolator::OnSagittalSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 0 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget2->GetRenderWindow())->RequestUpdate();
}
}
}
void QmitkSlicesInterpolator::OnFrontalSliceChanged(const itk::EventObject& e)
{
if ( TranslateAndInterpolateChangedSlice( e, 1 ) )
{
if (m_MultiWidget)
{
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget3->GetRenderWindow())->RequestUpdate();
}
}
}
bool QmitkSlicesInterpolator::TranslateAndInterpolateChangedSlice(const itk::EventObject& e, unsigned int windowID)
{
if (!m_2DInterpolationEnabled) return false;
try
{
const mitk::SliceNavigationController::GeometrySliceEvent& event = dynamic_cast<const mitk::SliceNavigationController::GeometrySliceEvent&>(e);
mitk::TimeGeometry* tsg = event.GetTimeGeometry();
if (tsg && m_TimeStep.size() > windowID)
{
mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(tsg->GetGeometryForTimeStep(m_TimeStep[windowID]));
if (slicedGeometry)
{
mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( event.GetPos() ));
if (plane)
Interpolate( plane, m_TimeStep[windowID] );
return true;
}
}
}
catch(std::bad_cast)
{
return false; // so what
}
return false;
}
void QmitkSlicesInterpolator::Interpolate( mitk::PlaneGeometry* plane, unsigned int timeStep )
{
if (m_ToolManager)
{
mitk::DataNode* node = m_ToolManager->GetWorkingData(0);
if (node)
{
m_Segmentation = dynamic_cast<mitk::Image*>(node->GetData());
if (m_Segmentation)
{
int clickedSliceDimension(-1);
int clickedSliceIndex(-1);
- // calculate real slice position, i.e. slice of the image and not slice of the TimeSlicedGeometry
+ // calculate real slice position, i.e. slice of the image and not slice of the TimeGeometry
mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, clickedSliceDimension, clickedSliceIndex );
mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( clickedSliceDimension, clickedSliceIndex, timeStep );
m_FeedbackNode->SetData( interpolation );
// Workaround for Bug 11318
if ((interpolation.IsNotNull()) && (interpolation->GetGeometry() != NULL))
{
if(clickedSliceDimension == 1)
{
mitk::Point3D orig = interpolation->GetGeometry()->GetOrigin();
orig[0] = orig[0];
orig[1] = orig[1] + 0.5;
orig[2] = orig[2];
interpolation->GetGeometry()->SetOrigin(orig);
}
}
// Workaround for Bug 11318 END
m_LastSliceDimension = clickedSliceDimension;
m_LastSliceIndex = clickedSliceIndex;
}
}
}
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationFinished()
{
mitk::Surface::Pointer interpolatedSurface = m_SurfaceInterpolator->GetInterpolationResult();
if(interpolatedSurface.IsNotNull())
{
m_BtnAccept3DInterpolation->setEnabled(true);
m_InterpolatedSurfaceNode->SetData(interpolatedSurface);
m_3DContourNode->SetData(m_SurfaceInterpolator->GetContoursAsSurface());
this->Show3DInterpolationResult(true);
if( !m_DataStorage->Exists(m_InterpolatedSurfaceNode) && !m_DataStorage->Exists(m_3DContourNode))
{
m_DataStorage->Add(m_3DContourNode);
m_DataStorage->Add(m_InterpolatedSurfaceNode);
}
}
else if (interpolatedSurface.IsNull())
{
m_BtnAccept3DInterpolation->setEnabled(false);
if (m_DataStorage->Exists(m_InterpolatedSurfaceNode))
{
this->Show3DInterpolationResult(false);
}
}
if (m_MultiWidget)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::OnAcceptInterpolationClicked()
{
if (m_Segmentation && m_FeedbackNode->GetData())
{
//making interpolation separately undoable
mitk::UndoStackItem::IncCurrObjectEventId();
mitk::UndoStackItem::IncCurrGroupEventId();
mitk::UndoStackItem::ExecuteIncrement();
mitk::OverwriteSliceImageFilter::Pointer slicewriter = mitk::OverwriteSliceImageFilter::New();
slicewriter->SetInput( m_Segmentation );
slicewriter->SetCreateUndoInformation( true );
slicewriter->SetSliceImage( dynamic_cast<mitk::Image*>(m_FeedbackNode->GetData()) );
slicewriter->SetSliceDimension( m_LastSliceDimension );
slicewriter->SetSliceIndex( m_LastSliceIndex );
slicewriter->SetTimeStep( m_TimeStep[m_LastSliceDimension] );
slicewriter->Update();
m_FeedbackNode->SetData(NULL);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::AcceptAllInterpolations(unsigned int windowID)
{
// first creates a 3D diff image, then applies this diff to the segmentation
if (m_Segmentation)
{
int sliceDimension(-1);
int dummySliceIndex(-1);
if (!GetSliceForWindowsID(windowID, sliceDimension, dummySliceIndex))
{
return; // cannot determine slice orientation
}
//making interpolation separately undoable
mitk::UndoStackItem::IncCurrObjectEventId();
mitk::UndoStackItem::IncCurrGroupEventId();
mitk::UndoStackItem::ExecuteIncrement();
// create a diff image for the undo operation
mitk::Image::Pointer diffImage = mitk::Image::New();
diffImage->Initialize( m_Segmentation );
mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>() );
diffImage->Initialize( pixelType, 3, m_Segmentation->GetDimensions() );
memset( diffImage->GetData(), 0, (pixelType.GetBpe() >> 3) * diffImage->GetDimension(0) * diffImage->GetDimension(1) * diffImage->GetDimension(2) );
// now the diff image is all 0
unsigned int timeStep( m_TimeStep[windowID] );
// a slicewriter to create the diff image
mitk::OverwriteSliceImageFilter::Pointer diffslicewriter = mitk::OverwriteSliceImageFilter::New();
diffslicewriter->SetCreateUndoInformation( false );
diffslicewriter->SetInput( diffImage );
diffslicewriter->SetSliceDimension( sliceDimension );
diffslicewriter->SetTimeStep( timeStep );
unsigned int totalChangedSlices(0);
unsigned int zslices = m_Segmentation->GetDimension( sliceDimension );
mitk::ProgressBar::GetInstance()->AddStepsToDo(zslices);
for (unsigned int sliceIndex = 0; sliceIndex < zslices; ++sliceIndex)
{
mitk::Image::Pointer interpolation = m_Interpolator->Interpolate( sliceDimension, sliceIndex, timeStep );
if (interpolation.IsNotNull()) // we don't check if interpolation is necessary/sensible - but m_Interpolator does
{
diffslicewriter->SetSliceImage( interpolation );
diffslicewriter->SetSliceIndex( sliceIndex );
diffslicewriter->Update();
++totalChangedSlices;
}
mitk::ProgressBar::GetInstance()->Progress();
}
if (totalChangedSlices > 0)
{
// store undo stack items
if ( true )
{
// create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
mitk::ApplyDiffImageOperation* doOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
mitk::ApplyDiffImageOperation* undoOp = new mitk::ApplyDiffImageOperation( mitk::OpTEST, m_Segmentation, diffImage, timeStep );
undoOp->SetFactor( -1.0 );
std::stringstream comment;
comment << "Accept all interpolations (" << totalChangedSlices << ")";
mitk::OperationEvent* undoStackItem = new mitk::OperationEvent( mitk::DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, comment.str() );
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
// acutally apply the changes here
mitk::DiffImageApplier::GetInstanceForUndo()->ExecuteOperation( doOp );
}
}
m_FeedbackNode->SetData(NULL);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkSlicesInterpolator::FinishInterpolation(int windowID)
{
//this redirect is for calling from outside
if (windowID < 0)
OnAcceptAllInterpolationsClicked();
else
AcceptAllInterpolations( (unsigned int)windowID );
}
void QmitkSlicesInterpolator::OnAcceptAllInterpolationsClicked()
{
QMenu orientationPopup(this);
std::map<QAction*, unsigned int>::const_iterator it;
for(it = ACTION_TO_SLICEDIMENSION.begin(); it != ACTION_TO_SLICEDIMENSION.end(); it++)
orientationPopup.addAction(it->first);
connect( &orientationPopup, SIGNAL(triggered(QAction*)), this, SLOT(OnAcceptAllPopupActivated(QAction*)) );
orientationPopup.exec( QCursor::pos() );
}
void QmitkSlicesInterpolator::OnAccept3DInterpolationClicked()
{
if (m_InterpolatedSurfaceNode.IsNotNull() && m_InterpolatedSurfaceNode->GetData())
{
mitk::SurfaceToImageFilter::Pointer s2iFilter = mitk::SurfaceToImageFilter::New();
s2iFilter->MakeOutputBinaryOn();
s2iFilter->SetInput(dynamic_cast<mitk::Surface*>(m_InterpolatedSurfaceNode->GetData()));
// check if ToolManager holds valid ReferenceData
if (m_ToolManager->GetReferenceData(0) == NULL)
{
return;
}
s2iFilter->SetImage(dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData()));
s2iFilter->Update();
mitk::DataNode* segmentationNode = m_ToolManager->GetWorkingData(0);
segmentationNode->SetData(s2iFilter->GetOutput());
m_RBtnDisableInterpolation->setChecked(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->Show3DInterpolationResult(false);
}
}
void QmitkSlicesInterpolator::OnAcceptAllPopupActivated(QAction* action)
{
try
{
std::map<QAction*, unsigned int>::const_iterator iter = ACTION_TO_SLICEDIMENSION.find( action );
if (iter != ACTION_TO_SLICEDIMENSION.end())
{
int windowID = iter->second;
AcceptAllInterpolations( windowID );
}
}
catch(...)
{
/* Showing message box with possible memory error */
QMessageBox errorInfo;
errorInfo.setWindowTitle("Interpolation Process");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during interpolation. Possible cause: Not enough memory!");
errorInfo.exec();
//additional error message on std::cerr
std::cerr << "Ill construction in " __FILE__ " l. " << __LINE__ << std::endl;
}
}
void QmitkSlicesInterpolator::OnInterpolationActivated(bool on)
{
m_2DInterpolationEnabled = on;
try
{
if ( m_DataStorage.IsNotNull() )
{
if (on && !m_DataStorage->Exists(m_FeedbackNode))
{
m_DataStorage->Add( m_FeedbackNode );
}
//else
//{
// m_DataStorage->Remove( m_FeedbackNode );
//}
}
}
catch(...)
{
// don't care (double add/remove)
}
if (m_ToolManager)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
QWidget::setEnabled( workingNode != NULL );
m_BtnAcceptAllInterpolations->setEnabled( on );
m_BtnAcceptInterpolation->setEnabled( on );
m_FeedbackNode->SetVisibility( on );
if (!on)
{
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
if (workingNode)
{
mitk::Image* segmentation = dynamic_cast<mitk::Image*>(workingNode->GetData());
if (segmentation)
{
m_Interpolator->SetSegmentationVolume( segmentation );
if (referenceNode)
{
mitk::Image* referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
m_Interpolator->SetReferenceVolume( referenceImage ); // may be NULL
}
}
}
}
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::Run3DInterpolation()
{
m_SurfaceInterpolator->Interpolate();
}
void QmitkSlicesInterpolator::StartUpdateInterpolationTimer()
{
m_Timer->start(500);
}
void QmitkSlicesInterpolator::StopUpdateInterpolationTimer()
{
m_Timer->stop();
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,0.0));
mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::ChangeSurfaceColor()
{
float currentColor[3];
m_InterpolatedSurfaceNode->GetColor(currentColor);
float yellow[3] = {255.0,255.0,0.0};
if( currentColor[2] == yellow[2])
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(255.0,255.0,255.0));
}
else
{
m_InterpolatedSurfaceNode->SetProperty("color", mitk::ColorProperty::New(yellow));
}
m_InterpolatedSurfaceNode->Update();
mitk::RenderingManager::GetInstance()->RequestUpdate(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetRenderWindow());
}
void QmitkSlicesInterpolator::On3DInterpolationActivated(bool on)
{
m_3DInterpolationEnabled = on;
try
{
if ( m_DataStorage.IsNotNull() && m_ToolManager && m_3DInterpolationEnabled)
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
if ((workingNode->IsSelected() &&
workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
!isInterpolationResult && m_3DInterpolationEnabled)
{
int ret = QMessageBox::Yes;
if (m_SurfaceInterpolator->EstimatePortionOfNeededMemory() > 0.5)
{
QMessageBox msgBox;
msgBox.setText("Due to short handed system memory the 3D interpolation may be very slow!");
msgBox.setInformativeText("Are you sure you want to activate the 3D interpolation?");
msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
ret = msgBox.exec();
}
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
if (ret == QMessageBox::Yes)
{
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
else
{
m_RBtnDisableInterpolation->toggle();
}
}
else if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
}
}
else
{
QWidget::setEnabled( false );
m_CbShowMarkers->setEnabled(m_3DInterpolationEnabled);
}
}
if (!m_3DInterpolationEnabled)
{
this->Show3DInterpolationResult(false);
m_BtnAccept3DInterpolation->setEnabled(m_3DInterpolationEnabled);
}
}
catch(...)
{
MITK_ERROR<<"Error with 3D surface interpolation!";
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::EnableInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
OnInterpolationActivated(on);
}
void QmitkSlicesInterpolator::Enable3DInterpolation(bool on)
{
// only to be called from the outside world
// just a redirection to OnInterpolationActivated
On3DInterpolationActivated(on);
}
void QmitkSlicesInterpolator::UpdateVisibleSuggestion()
{
if (m_2DInterpolationEnabled)
{
// determine which one is the current view, try to do an initial interpolation
mitk::BaseRenderer* renderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
if (renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
- const mitk::TimeGeometry* timeSlicedGeometry = dynamic_cast<const mitk::TimeGeometry*>( renderer->GetWorldGeometry() );
- if (timeSlicedGeometry)
+ const mitk::TimeGeometry* timeGeometry = dynamic_cast<const mitk::TimeGeometry*>( renderer->GetWorldGeometry() );
+ if (timeGeometry)
{
- mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeGeometry*>(timeSlicedGeometry), renderer->GetSlice() );
+ mitk::SliceNavigationController::GeometrySliceEvent event( const_cast<mitk::TimeGeometry*>(timeGeometry), renderer->GetSlice() );
if ( renderer->GetCurrentWorldGeometry2DNode() )
{
if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane1() )
{
TranslateAndInterpolateChangedSlice( event, 2 );
}
else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane2() )
{
TranslateAndInterpolateChangedSlice( event, 0 );
}
else if ( renderer->GetCurrentWorldGeometry2DNode()==this->m_MultiWidget->GetWidgetPlane3() )
{
TranslateAndInterpolateChangedSlice( event, 1 );
}
}
}
}
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkSlicesInterpolator::OnInterpolationInfoChanged(const itk::EventObject& /*e*/)
{
// something (e.g. undo) changed the interpolation info, we should refresh our display
UpdateVisibleSuggestion();
}
void QmitkSlicesInterpolator::OnSurfaceInterpolationInfoChanged(const itk::EventObject& /*e*/)
{
if(m_3DInterpolationEnabled)
{
if (m_Watcher.isRunning())
m_Watcher.waitForFinished();
m_Future = QtConcurrent::run(this, &QmitkSlicesInterpolator::Run3DInterpolation);
m_Watcher.setFuture(m_Future);
}
}
bool QmitkSlicesInterpolator::GetSliceForWindowsID(unsigned windowID, int& sliceDimension, int& sliceIndex)
{
mitk::BaseRenderer* renderer(NULL);
// find sliceDimension for windowID:
// windowID 2: axial window = renderWindow1
// windowID 1: frontal window = renderWindow3
// windowID 0: sagittal window = renderWindow2
if ( m_MultiWidget )
{
switch (windowID)
{
case 2:
default:
renderer = m_MultiWidget->mitkWidget1->GetRenderer();
break;
case 1:
renderer = m_MultiWidget->mitkWidget3->GetRenderer();
break;
case 0:
renderer = m_MultiWidget->mitkWidget2->GetRenderer();
break;
}
}
if ( m_Segmentation && renderer && renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
const mitk::TimeGeometry* timeGeometry = renderer->GetTimeWorldGeometry();
if (timeGeometry)
{
mitk::SlicedGeometry3D* slicedGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(timeGeometry->GetGeometryForTimeStep(m_TimeStep[windowID]));
if (slicedGeometry)
{
mitk::PlaneGeometry* plane = dynamic_cast<mitk::PlaneGeometry*>(slicedGeometry->GetGeometry2D( renderer->GetSlice() ));
Interpolate( plane, m_TimeStep[windowID] );
return mitk::SegTool2D::DetermineAffectedImageSlice( m_Segmentation, plane, sliceDimension, sliceIndex );
}
}
}
return false;
}
void QmitkSlicesInterpolator::OnMultiWidgetDeleted(QObject*)
{
if (m_MultiWidget)
{
m_MultiWidget = NULL;
}
}
void QmitkSlicesInterpolator:: SetCurrentContourListID()
{
if ( m_DataStorage.IsNotNull() && m_ToolManager )
{
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
if (workingNode)
{
//int listID;
bool isInterpolationResult(false);
workingNode->GetBoolProperty("3DInterpolationResult",isInterpolationResult);
if ((m_MultiWidget != NULL && workingNode->IsSelected() &&
workingNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")))) &&
!isInterpolationResult)
{
QWidget::setEnabled( true );
mitk::Vector3D spacing = workingNode->GetData()->GetGeometry( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetTimeStep() )->GetSpacing();
double minSpacing (100);
double maxSpacing (0);
for (int i =0; i < 3; i++)
{
if (spacing[i] < minSpacing)
{
minSpacing = spacing[i];
}
else if (spacing[i] > maxSpacing)
{
maxSpacing = spacing[i];
}
}
m_SurfaceInterpolator->SetSegmentationImage(dynamic_cast<mitk::Image*>(workingNode->GetData()));
m_SurfaceInterpolator->SetMaxSpacing(maxSpacing);
m_SurfaceInterpolator->SetMinSpacing(minSpacing);
m_SurfaceInterpolator->SetDistanceImageVolume(50000);
m_SurfaceInterpolator->SetCurrentSegmentationInterpolationList(dynamic_cast<mitk::Image*>(workingNode->GetData()));
}
}
}
}
void QmitkSlicesInterpolator::Show3DInterpolationResult(bool status)
{
if (m_InterpolatedSurfaceNode.IsNotNull())
m_InterpolatedSurfaceNode->SetVisibility(status);
if (m_3DContourNode.IsNotNull())
m_3DContourNode->SetVisibility(status, mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
diff --git a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
index 2b817b7be9..4cf36b6c75 100644
--- a/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
+++ b/Modules/Segmentation/Algorithms/mitkCorrectorAlgorithm.cpp
@@ -1,515 +1,502 @@
/*===================================================================
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 "mitkCorrectorAlgorithm.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkImageDataItem.h"
#include "mitkContourUtils.h"
mitk::CorrectorAlgorithm::CorrectorAlgorithm()
:ImageToImageFilter()
{
}
mitk::CorrectorAlgorithm::~CorrectorAlgorithm()
{
}
void mitk::CorrectorAlgorithm::GenerateData()
{
Image::Pointer inputImage = const_cast<Image*>(ImageToImageFilter::GetInput(0));
if (inputImage.IsNull() || inputImage->GetDimension() != 2)
{
itkExceptionMacro("CorrectorAlgorithm needs a 2D image as input.");
}
if (m_Contour.IsNull())
{
itkExceptionMacro("CorrectorAlgorithm needs a Contour object as input.");
}
// copy the input (since m_WorkingImage will be changed later)
m_WorkingImage = Image::New();
m_WorkingImage->Initialize( inputImage );
m_WorkingImage->SetVolume( inputImage.GetPointer()->GetData() );
TimeGeometry::Pointer originalGeometry = NULL;
if (inputImage->GetTimeGeometry() )
{
m_WorkingImage->SetTimeGeometry(inputImage->GetTimeGeometry()->Clone().GetPointer());
}
else
{
itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
}
Image::Pointer temporarySlice;
// Convert to ipMITKSegmentationTYPE (because TobiasHeimannCorrectionAlgorithm relys on that data type)
{
itk::Image< ipMITKSegmentationTYPE, 2 >::Pointer correctPixelTypeImage;
CastToItkImage( m_WorkingImage, correctPixelTypeImage );
assert (correctPixelTypeImage.IsNotNull() );
// possible bug in CastToItkImage ?
// direction maxtrix is wrong/broken/not working after CastToItkImage, leading to a failed assertion in
// mitk/Core/DataStructures/mitkSlicedGeometry3D.cpp, 479:
// virtual void mitk::SlicedGeometry3D::SetSpacing(const mitk::Vector3D&): Assertion `aSpacing[0]>0 && aSpacing[1]>0 && aSpacing[2]>0' failed
// solution here: we overwrite it with an unity matrix
itk::Image< ipMITKSegmentationTYPE, 2 >::DirectionType imageDirection;
imageDirection.SetIdentity();
//correctPixelTypeImage->SetDirection(imageDirection);
temporarySlice = this->GetOutput();
// temporarySlice = ImportItkImage( correctPixelTypeImage );
CastToMitkImage( correctPixelTypeImage, temporarySlice );
}
mitkIpPicDescriptor* temporarySlicePic = mitkIpPicNew();
CastToIpPicDescriptor( temporarySlice, temporarySlicePic );
TobiasHeimannCorrectionAlgorithm( temporarySlicePic );
temporarySlice->SetTimeGeometry(originalGeometry);
- // temporarySlice is our return value (user can get it by calling GetOutput() )
-
-// CalculateDifferenceImage( temporarySlice, inputImage );
-// if ( m_DifferenceImage.IsNotNull() && inputImage->GetTimeGeometry() )
-// {
-// AffineGeometryFrame3D::Pointer originalGeometryAGF = inputImage->GetTimeGeometry()->Clone();
-// TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
-// m_DifferenceImage->SetGeometry( originalGeometry );
-// }
-// else
-// {
-// itkExceptionMacro("Original image does not have a 'Time sliced geometry'! Cannot copy.");
-// }
}
void mitk::CorrectorAlgorithm::TobiasHeimannCorrectionAlgorithm(mitkIpPicDescriptor* pic)
{
/*!
Some documentation (not by the original author)
TobiasHeimannCorrectionAlgorithm will be called, when the user has finished drawing a freehand line.
There should be different results, depending on the line's properties:
1. Without any prior segmentation, the start point and the end point of the drawn line will be
connected to a contour and the area enclosed by the contour will be marked as segmentation.
2. When the whole line is inside a segmentation, start and end point will be connected to
a contour and the area of this contour will be subtracted from the segmentation.
3. When the line starts inside a segmentation and ends outside with only a single
transition from segmentation to no-segmentation, nothing will happen.
4. When there are multiple transitions between inside-segmentation and
outside-segmentation, the line will be divided in so called segments. Each segment is
either fully inside or fully outside a segmentation. When it is inside a segmentation, its
enclosed area will be subtracted from the segmentation. When the segment is outside a
segmentation, its enclosed area it will be added to the segmentation.
The algorithm is described in full length in Tobias Heimann's diploma thesis
(MBI Technical Report 145, p. 37 - 40).
*/
int oaSize = 1000000; // if we need a fixed number, then let it be big
int* _ofsArray = new int[ oaSize ];
for (int i=0; i<oaSize; i++) _ofsArray[i] = 0;
std::vector<TSegData> segData;
segData.reserve( 16 );
Contour* contour3D = const_cast<Contour*>(m_Contour.GetPointer());
ContourUtils::Pointer contourUtils = ContourUtils::New();
Contour::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice( m_WorkingImage, contour3D, true, false );
if (projectedContour.IsNull())
{
delete[] _ofsArray;
return;
}
if (projectedContour->GetNumberOfPoints() < 2)
{
delete[] _ofsArray;
return;
}
// convert the projected contour into a ipSegmentation format
mitkIpInt4_t* _points = new mitkIpInt4_t[2 * projectedContour->GetNumberOfPoints()];
const Contour::PathType::VertexListType* pointsIn2D = projectedContour->GetContourPath()->GetVertexList();
unsigned int index(0);
for ( Contour::PathType::VertexListType::const_iterator iter = pointsIn2D->begin();
iter != pointsIn2D->end();
++iter, ++index )
{
_points[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)[0] + 0.5 );
_points[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)[1] + 0.5 );
}
// store ofsets of the drawn line in array
int _ofsNum = 0;
unsigned int num = projectedContour->GetNumberOfPoints();
int lastOfs = -1;
for (unsigned int i=0; i<num-1; i++)
{
float x = _points [2*i] + 0.5;
float y = _points [2*i+1] + 0.5;
float difX = _points [2*i+2] - x + 0.5;
float difY = _points [2*i+3] - y + 0.5;
float length = sqrt( difX*difX + difY*difY );
float dx = difX / length;
float dy = difY / length;
for (int p=0; ((float)p)<length; p++)
{
// if ofs is out of bounds, very nasty things will happen, so better check coordinates:
if (x<0) x=0.5;
else if (x>=pic->n[0]) x = pic->n[0]-0.5;
if (y<0) y=0.5;
else if (y>=pic->n[1]) y = pic->n[1]-0.5;
// ok, now store safe ofs
int ofs = (int)(x) + pic->n[0]*((int)(y));
x += dx;
y += dy;
if (ofs != lastOfs)
{
_ofsArray[_ofsNum++] = ofs;
lastOfs = ofs;
}
}
}
if (_ofsNum == 0)
{
// contour was completely outside the binary image
delete[] _ofsArray;
delete[] _points;
return;
}
ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
// divide line in logical segments:
int numSegments = 0;
ipMITKSegmentationTYPE state = *(picdata + _ofsArray[0]);
int ofsP = 1;
int modifyStart, modifyEnd; // start of first and end of last segment
bool nextSegment;
segData.clear();
do
{
nextSegment = false;
while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
if (ofsP<_ofsNum)
{
int lineStart = ofsP-1;
if (numSegments==0) modifyStart = ofsP;
state = *(picdata + _ofsArray[ofsP]);
while (ofsP<_ofsNum && *(picdata + _ofsArray[ofsP])==state) ofsP++;
if (ofsP<_ofsNum)
{
int lineEnd = ofsP;
modifyEnd = lineEnd;
nextSegment = true;
// now we've got a valid segment from lineStart to lineEnd
TSegData thisSegData;
thisSegData.lineStart = lineStart;
thisSegData.lineEnd = lineEnd;
thisSegData.modified = modifySegment( lineStart, lineEnd, state, pic, _ofsArray );
segData.push_back( thisSegData );
numSegments++;
}
}
} while (nextSegment);
for (int segNr=0; segNr < numSegments; segNr++)
{
// draw line if modified:
if ( segData[segNr].modified )
{
for (int i=segData[segNr].lineStart+1; i<segData[segNr].lineEnd; i++)
{
*(picdata + _ofsArray[i]) = 1;
}
}
}
if (numSegments == 0)
{
if (num <= 1)
{ // only a single pixel. _ofsArray[_ofsNum-1] in else statement would crash, so don't do anything
// no movement: delete operation
// This behaviour would probably confuse users when they use the correction
// tool to change a segmentation and it deletes much more than selected
// if (state == 1) ipMITKSegmentationReplaceRegion4N( pic, _ofsArray[0], 0 );
}
else if ( *(picdata + _ofsArray[_ofsNum-1]) == *(picdata + _ofsArray[0]))
{
// start point and end point both inside or both outside any segmentation
// normal paint operation
mitkIpInt4_t* p = new mitkIpInt4_t[2 * num];
for (unsigned int i = 0; i < num; i++)
{
p[2 * i] = (mitkIpInt4_t) _points [2 * i];
p[2 * i + 1] = (mitkIpInt4_t) _points [2 * i + 1];
}
if (state == 0) ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_OR, 1);
else ipMITKSegmentationCombineRegion (pic, p, num, 0, IPSEGMENTATION_AND, 0);
delete[] p;
}
}
int numberOfContourPoints( 0 );
int oneContourOffset( 0 );
int newBufferSize( 0 );
int imageSize = pic->n[0]*pic->n[1];
for (oneContourOffset = 0; oneContourOffset < imageSize; oneContourOffset++)
if ( ((ipMITKSegmentationTYPE*) pic->data)[oneContourOffset]> 0) break;
float* contourPoints = ipMITKSegmentationGetContour8N( pic, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
if (contourPoints)
{
// copy point from float* to mitk::Contour
Contour::Pointer contourInImageIndexCoordinates = Contour::New();
contourInImageIndexCoordinates->Initialize();
Point3D newPoint;
for (int index = 0; index < numberOfContourPoints; ++index)
{
newPoint[0] = contourPoints[ 2 * index + 0 ];
newPoint[1] = contourPoints[ 2 * index + 1];
newPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex( newPoint );
}
free(contourPoints);
ContourUtils::Pointer contourUtils = ContourUtils::New();
contourUtils->FillContourInSlice( contourInImageIndexCoordinates, m_WorkingImage );
}
delete[] _ofsArray;
delete[] _points;
}
bool mitk::CorrectorAlgorithm::modifySegment( int lineStart, int lineEnd, ipMITKSegmentationTYPE state, mitkIpPicDescriptor *pic, int* _ofsArray )
{
// offsets for pixels right, top, left, bottom
int nbDelta4[4];
nbDelta4[0]=1; nbDelta4[1]=pic->n[0]; nbDelta4[1]*=-1; // necessary because of unsigned declaration of pic->n
nbDelta4[2]=-1; nbDelta4[3]=pic->n[0];
// offsets for pixels right, top-right, top, top-left left, bottom-left, bottom, bottom-right
int nbDelta8[8];
nbDelta8[0] = 1; nbDelta8[1] = nbDelta4[1]+1; nbDelta8[2] = nbDelta4[1]; nbDelta8[3] = nbDelta4[1]-1;
nbDelta8[4] = -1; nbDelta8[5] = nbDelta4[3]-1; nbDelta8[6] = nbDelta4[3]; nbDelta8[7] = nbDelta4[3]+1;
ipMITKSegmentationTYPE* picdata = static_cast<ipMITKSegmentationTYPE*>(pic->data);
ipMITKSegmentationTYPE saveStart = *(picdata + _ofsArray[lineStart]);
ipMITKSegmentationTYPE saveEnd = *(picdata + _ofsArray[lineEnd]);
ipMITKSegmentationTYPE newState = ((!state)&1) + 2; // probably equal to: ipMITKSegmentationTYPE newState = 3 - state;
// make two copies of pic:
mitkIpPicDescriptor *seg1 = mitkIpPicClone( pic );
mitkIpPicDescriptor *seg2 = mitkIpPicClone( pic );
int i;
// mark line in original
for (i=lineStart; i<=lineEnd; i++) {
*(picdata + _ofsArray[i]) = 3;
}
// mark the first side in copy 1:
bool firstPix = true;
bool modified;
int line = pic->n[0]; // #pixels in line
int maxOfs = (int)(line * pic->n[1]); // #pixels in slice
for (i=lineStart+1; i<lineEnd; i++) {
do {
modified = false;
for (int nb=0; nb<8; nb++) {
int nbOfs = _ofsArray[i] + nbDelta8[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE nbVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE destVal = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (nbVal!=3 && destVal!=newState) { // get only neigbhours that are not part of the line itself
if (firstPix) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // this one is used to mark the side!
firstPix = false;
modified = true;
}
else {
int tnb = 0;
while ( tnb < 4
&& ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs)
&& *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs + nbDelta4[tnb]) != newState
)
tnb++;
if (tnb < 4 && ((nbOfs + nbDelta4[tnb]) >= 0) && ((nbOfs + nbDelta4[tnb]) < maxOfs) ) {
*(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs) = newState; // we've got a buddy close
modified = true;
}
}
}
}
} while (modified);
}
// mark the other side in copy 2:
for (i=lineStart+1; i<lineEnd; i++) {
for (int nb=0; nb<4; nb++) {
int nbOfs = _ofsArray[i] + nbDelta4[nb];
if ( nbOfs < 0 // above first line
|| nbOfs >= maxOfs // below last line
) continue;
ipMITKSegmentationTYPE lineVal = *(picdata + nbOfs);
ipMITKSegmentationTYPE side1Val = *(((ipMITKSegmentationTYPE*)seg1->data) + nbOfs);
if (lineVal != 3 && side1Val != newState) {
*(((ipMITKSegmentationTYPE*)seg2->data) + nbOfs) = newState;
}
}
}
// take care of line ends for multiple segments:
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[lineEnd]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineStart]) = newState;
*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[lineEnd]) = newState;
// replace regions:
newState = (!state)&1;
int sizeRegion1 = 0, sizeRegion2 = 0;
for (i=lineStart+1; i<lineEnd; i++) {
if (*(((ipMITKSegmentationTYPE*)seg1->data) + _ofsArray[i]) != newState) {
sizeRegion1 += ipMITKSegmentationReplaceRegion4N( seg1, _ofsArray[i], newState );
}
if (*(((ipMITKSegmentationTYPE*)seg2->data) + _ofsArray[i]) != newState) {
sizeRegion2 += ipMITKSegmentationReplaceRegion4N( seg2, _ofsArray[i], newState );
}
}
// combine image:
//printf( "Size Region1 = %8i Size Region2 = %8i\n", sizeRegion1, sizeRegion2 );
int sizeDif;
ipMITKSegmentationTYPE *current, *segSrc;
if (sizeRegion1 < sizeRegion2) {
segSrc = (ipMITKSegmentationTYPE*)seg1->data;
sizeDif = sizeRegion2 - sizeRegion1;
}
else {
segSrc = (ipMITKSegmentationTYPE*)seg2->data;
sizeDif = sizeRegion1 - sizeRegion2;
}
modified = false;
if (sizeDif > 2*(lineEnd-lineStart)) {
// decision is safe enough:
ipMITKSegmentationTYPE *end = picdata + (pic->n[0]*pic->n[1]);
for (current = picdata; current<end; current++) {
if (*segSrc == newState) *current = newState;
segSrc++;
}
modified = true;
}
// restore line:
for (int i=lineStart+1; i<lineEnd; i++) {
*(picdata + _ofsArray[i]) = state;
}
// restore end points:
*(picdata + _ofsArray[lineStart]) = saveStart;
*(picdata + _ofsArray[lineEnd]) = saveEnd;
mitkIpPicFree( seg1 );
mitkIpPicFree( seg2 );
return modified;
}
void mitk::CorrectorAlgorithm::CalculateDifferenceImage( Image* modifiedImage, Image* originalImage )
{
/*
* modifiedImage has ipMITKSegmentationTYPE
* originalImage may be any type
*
* --> we calculate a diff image using ITK, switching for the correct type of originalImage
*/
m_DifferenceImage = NULL;
Image::Pointer tmpPtr = originalImage;
AccessFixedDimensionByItk_1( tmpPtr, ItkCalculateDifferenceImage, 2, modifiedImage );
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::CorrectorAlgorithm::ItkCalculateDifferenceImage( itk::Image<TPixel, VImageDimension>* originalImage, Image* modifiedMITKImage )
{
typedef itk::Image<ipMITKSegmentationTYPE, VImageDimension> ModifiedImageType;
typedef itk::Image<short signed int, VImageDimension> DiffImageType;
typedef itk::ImageRegionConstIterator< itk::Image<TPixel,VImageDimension> > OriginalSliceIteratorType;
typedef itk::ImageRegionConstIterator< ModifiedImageType > ModifiedSliceIteratorType;
typedef itk::ImageRegionIterator< DiffImageType > DiffSliceIteratorType;
typename ModifiedImageType::Pointer modifiedImage;
CastToItkImage( modifiedMITKImage, modifiedImage );
// create new image as a copy of the input
// this new image is the output of this filter class
typename DiffImageType::Pointer diffImage;
m_DifferenceImage = Image::New();
PixelType pixelType( mitk::MakeScalarPixelType<short>() );
m_DifferenceImage->Initialize( pixelType, 2, modifiedMITKImage->GetDimensions() );
CastToItkImage( m_DifferenceImage, diffImage );
// iterators over both input images (original and modified) and the output image (diff)
ModifiedSliceIteratorType modifiedIterator( modifiedImage, diffImage->GetLargestPossibleRegion() );
OriginalSliceIteratorType originalIterator( originalImage, diffImage->GetLargestPossibleRegion() );
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
modifiedIterator.GoToBegin();
originalIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !diffIterator.IsAtEnd() )
{
short signed int difference = static_cast<short signed int>( static_cast<signed int>(modifiedIterator.Get()) -
static_cast<signed int>(originalIterator.Get())); // not good for bigger values ?!
diffIterator.Set( difference );
++modifiedIterator;
++originalIterator;
++diffIterator;
}
}
diff --git a/Modules/Segmentation/DataManagement/mitkContourModel.h b/Modules/Segmentation/DataManagement/mitkContourModel.h
index 9980cbb6a4..604e1acd4c 100644
--- a/Modules/Segmentation/DataManagement/mitkContourModel.h
+++ b/Modules/Segmentation/DataManagement/mitkContourModel.h
@@ -1,397 +1,397 @@
/*===================================================================
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 _MITK_CONTOURMODEL_H_
#define _MITK_CONTOURMODEL_H_
#include "mitkCommon.h"
#include "SegmentationExports.h"
#include "mitkBaseData.h"
#include <mitkContourElement.h>
namespace mitk
{
/**
\brief ContourModel is a structure of linked vertices defining a contour in 3D space.
The vertices are stored in a mitk::ContourElement is stored for each timestep.
The contour line segments are implicitly defined by the given linked vertices.
By default two control points are are linked by a straight line.It is possible to add
vertices at front and end of the contour and to iterate in both directions.
Points are specified containing coordinates and additional (data) information,
see mitk::ContourElement.
For accessing a specific vertex either an index or a position in 3D Space can be used.
The vertices are best accessed by using a VertexIterator.
Interaction with the contour is thus available without any mitk interactor class using the
api of ContourModel. It is possible to shift single vertices also as shifting the whole
contour.
A contour can be either open like a single curved line segment or
closed. A closed contour can for example represent a jordan curve.
\section mitkPointSetDisplayOptions
The default mappers for this data structure are mitk::ContourModelGLMapper2D and
mitk::ContourModelMapper3D. See these classes for display options which can
can be set via properties.
*/
class Segmentation_EXPORT ContourModel : public BaseData
{
public:
mitkClassMacro(ContourModel, BaseData);
itkNewMacro(Self);
mitkCloneMacro(Self);
/*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
typedef mitk::ContourElement::VertexType VertexType;
typedef mitk::ContourElement::VertexListType VertexListType;
typedef mitk::ContourElement::VertexIterator VertexIterator;
typedef std::vector< mitk::ContourElement::Pointer > ContourModelSeries;
/*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
/** \brief Possible interpolation of the line segments between control points */
enum LineSegmentInterpolation{
LINEAR, B_SPLINE
};
/*++++++++++++++++ inline methods +++++++++++++++++++++++*/
/** \brief Get the current selected vertex.
*/
VertexType* GetSelectedVertex()
{
return this->m_SelectedVertex;
}
/** \brief Deselect vertex.
*/
void Deselect()
{
this->m_SelectedVertex = NULL;
}
/** \brief Deselect vertex.
*/
void SetSelectedVertexAsControlPoint(bool isControlPoint=true)
{
if(this->m_SelectedVertex && (this->m_SelectedVertex->IsControlPoint != isControlPoint) )
{
m_SelectedVertex->IsControlPoint = isControlPoint;
this->Modified();
}
}
/** \brief Set the interpolation of the line segments between control points.
*/
void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
{
this->m_lineInterpolation = interpolation;
this->Modified();
}
/** \brief Get the interpolation of the line segments between control points.
*/
LineSegmentInterpolation GetLineSegmentInterpolation()
{
return this->m_lineInterpolation;
}
/*++++++++++++++++ END inline methods +++++++++++++++++++++++*/
/** \brief Add a vertex to the contour at given timestep.
The vertex is added at the end of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertex(mitk::Point3D &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep.
The vertex is added at the end of contour.
\param vertex - coordinate representation of a control point
\param timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertex(VertexType &vertex, int timestep=0);
/** \brief Add a vertex to the contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
\pararm isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertexAtFront(mitk::Point3D &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
The vertex is added at the FRONT of contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertexAtFront(VertexType &vertex, int timestep=0);
/** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
\pararm vertex - coordinate representation of a control point
\pararm timestep - the timestep at which the vertex will be add ( default 0)
\pararm isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
will be rendered).
@Note Adding a vertex to a timestep which exceeds the timebounds of the contour
- will not be added, the TimeSlicedGeometry will not be expanded.
+ will not be added, the TimeGeometry will not be expanded.
*/
void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep=0);
/** \brief Insert a vertex at given index.
*/
void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint=false, int timestep=0);
/** \brief Return if the contour is closed or not.
*/
bool IsClosed( int timestep=0);
/** \brief Concatenate two contours.
The starting control point of the other will be added at the end of the contour.
*/
void Concatenate(mitk::ContourModel* other, int timestep=0);
/** \brief Returns a const VertexIterator at the start element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
VertexIterator IteratorBegin( int timestep=0);
/** \brief Close the contour.
The last control point will be linked with the first point.
*/
virtual void Close( int timestep=0);
/** \brief Set isClosed to false contour.
The link between the last control point the first point will be removed.
*/
virtual void Open( int timestep=0);
/** \brief Set isClosed to given boolean.
false - The link between the last control point the first point will be removed.
true - The last control point will be linked with the first point.
*/
virtual void SetIsClosed(bool isClosed, int timestep=0);
/** \brief Returns a const VertexIterator at the end element of the contour.
@throw mitk::Exception if the timestep is invalid.
*/
VertexIterator IteratorEnd( int timestep=0);
/** \brief Returns the number of vertices at a given timestep.
\pararm timestep - default = 0
*/
int GetNumberOfVertices( int timestep=0);
/** \brief Returns the vertex at the index position within the container.
*/
virtual const VertexType* GetVertexAt(int index, int timestep=0) const;
/** \brief Check if there isn't something at this timestep.
*/
virtual bool IsEmptyTimeStep( int t) const;
/** \brief Mark a vertex at an index in the container as selected.
*/
bool SelectVertexAt(int index, int timestep=0);
/** \brief Mark a vertex at a given position in 3D space.
\pararm point - query point in 3D space
\pararm eps - radius for nearest neighbour search (error bound).
\pararm timestep - search at this timestep
@return true = vertex found; false = no vertex found
*/
bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep=0);
/** \brief Remove a vertex at given index within the container.
@return true = the vertex was successfuly removed; false = wrong index.
*/
bool RemoveVertexAt(int index, int timestep=0);
/** \brief Remove a vertex at given timestep within the container.
@return true = the vertex was successfuly removed.
*/
bool RemoveVertex(VertexType* vertex, int timestep=0);
/** \brief Remove a vertex at a query position in 3D space.
The vertex to be removed will be search by nearest neighbour search.
Note that possibly no vertex at this position and eps is stored inside
the contour.
@return true = the vertex was successfuly removed; false = no vertex found.
*/
bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep=0);
/** \brief Shift the currently selected vertex by a translation vector.
\pararm translate - the translation vector.
*/
void ShiftSelectedVertex(mitk::Vector3D &translate);
/** \brief Shift the whole contour by a translation vector at given timestep.
\pararm translate - the translation vector.
\pararm timestep - at this timestep the contour will be shifted.
*/
void ShiftContour(mitk::Vector3D &translate, int timestep=0);
/** \brief Clear the storage container at given timestep.
All control points are removed at
timestep.
*/
virtual void Clear(int timestep);
/*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual void SetRequestedRegionToLargestPossibleRegion ();
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion ();
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual bool VerifyRequestedRegion ();
/**
\brief Get the updated geometry with recomputed bounds.
*/
virtual const mitk::Geometry3D* GetUpdatedGeometry (int t=0);
/**
\brief Get the Geometry3D for timestep t.
*/
virtual mitk::Geometry3D* GetGeometry (int t=0) const;
/**
\brief Inherit from base data - no region support available for contourModel objects.
*/
virtual void SetRequestedRegion (itk::DataObject *data);
/**
- \brief Expand the timebounds of the TimeSlicedGeometry to given number of timesteps.
+ \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
*/
virtual void Expand( int timeSteps );
/**
\brief Update the OutputInformation of a ContourModel object
The BoundingBox of the contour will be updated, if necessary.
*/
virtual void UpdateOutputInformation();
/**
\brief Clear the storage container.
The object is set to initial state. All control points are removed and the number of
timesteps are set to 1.
*/
virtual void Clear();
/**
\brief overwrite if the Data can be called by an Interactor (StateMachine).
*/
void ExecuteOperation(Operation* operation);
protected:
ContourModel();
ContourModel(const mitk::ContourModel &other);
virtual ~ContourModel();
//inherit from BaseData. called by Clear()
virtual void ClearData();
//inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
virtual void InitializeEmpty();
//Shift a vertex
void ShiftVertex(VertexType* vertex, mitk::Vector3D &vector);
//Storage with time resolved support.
ContourModelSeries m_ContourSeries;
//The currently selected vertex.
VertexType* m_SelectedVertex;
//The interpolation of the line segment between control points.
LineSegmentInterpolation m_lineInterpolation;
};
itkEventMacro( ContourModelEvent, itk::AnyEvent );
itkEventMacro( ContourModelShiftEvent, ContourModelEvent );
itkEventMacro( ContourModelSizeChangeEvent, ContourModelEvent );
itkEventMacro( ContourModelAddEvent, ContourModelSizeChangeEvent );
itkEventMacro( ContourModelRemoveEvent, ContourModelSizeChangeEvent );
itkEventMacro( ContourModelExpandTimeBoundsEvent, ContourModelEvent );
itkEventMacro( ContourModelClosedEvent, ContourModelEvent );
}
#endif
diff --git a/Modules/Simulation/mitkSimulation.cpp b/Modules/Simulation/mitkSimulation.cpp
index c499c7b059..7ab52b4bfc 100644
--- a/Modules/Simulation/mitkSimulation.cpp
+++ b/Modules/Simulation/mitkSimulation.cpp
@@ -1,238 +1,238 @@
/*===================================================================
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 "mitkSimulation.h"
#include "mitkSimulationPropAssemblyVisitor.h"
#include <mitkDataNode.h>
#include <mitkSurface.h>
#include <sofa/core/visual/VisualParams.h>
#include <sofa/simulation/bgl/BglSimulation.h>
#include <sofa/simulation/graph/DAGSimulation.h>
#include <sofa/simulation/tree/TreeSimulation.h>
#include <vtkActor.h>
#include <vtkAppendPolyData.h>
#include <vtkMapper.h>
#include <vtkPolyData.h>
#include <vtkPropAssembly.h>
#include <vtkPropCollection.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
const float mitk::Simulation::ScaleFactor = 1000.0f;
static sofa::simulation::Simulation::SPtr CreateSimulation(mitk::Simulation::SimulationType type = mitk::Simulation::Tree)
{
if (type == mitk::Simulation::DAG)
return sofa::core::objectmodel::New<sofa::simulation::graph::DAGSimulation>();
else if (type == mitk::Simulation::Bgl)
return sofa::core::objectmodel::New<sofa::simulation::bgl::BglSimulation>();
else
return sofa::core::objectmodel::New<sofa::simulation::tree::TreeSimulation>();
}
void mitk::Simulation::SetActiveSimulation(mitk::Simulation* simulation)
{
if (simulation == NULL)
{
sofa::simulation::setSimulation(NULL);
sofa::core::visual::VisualParams::defaultInstance()->drawTool() = NULL;
}
else
{
sofa::simulation::Simulation* sofaSimulation = simulation->m_Simulation.get();
if (sofa::simulation::getSimulation() != sofaSimulation)
{
sofa::simulation::setSimulation(sofaSimulation);
sofa::core::visual::VisualParams::defaultInstance()->drawTool() = &simulation->m_DrawTool;
}
}
}
mitk::Simulation::Simulation()
: m_Simulation(CreateSimulation()),
m_DefaultDT(0.0)
{
}
mitk::Simulation::~Simulation()
{
if (m_Simulation != NULL)
{
if (m_RootNode != NULL)
m_Simulation->unload(m_RootNode);
if (sofa::simulation::getSimulation() == m_Simulation.get())
SetActiveSimulation(NULL);
}
}
void mitk::Simulation::AppendSnapshot(mitk::Surface::Pointer surface) const
{
if (surface.IsNull())
return;
vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
if (snapshot != NULL)
{
unsigned int timeStep = surface->GetSizeOfPolyDataSeries();
if (timeStep != 0 && surface->GetVtkPolyData(timeStep - 1) == NULL)
--timeStep;
surface->SetVtkPolyData(snapshot, timeStep);
}
}
vtkSmartPointer<vtkPolyData> mitk::Simulation::CreateSnapshot() const
{
if (m_RootNode == NULL)
return NULL;
vtkSmartPointer<vtkPropAssembly> propAssembly = vtkSmartPointer<vtkPropAssembly>::New();
SimulationPropAssemblyVisitor propAssemblyVisitor(propAssembly);
m_RootNode->executeVisitor(&propAssemblyVisitor);
vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
vtkPropCollection* propCollection = propAssembly->GetParts();
vtkProp* prop = NULL;
for (propCollection->InitTraversal(); (prop = propCollection->GetNextProp()) != NULL; )
{
vtkActor* actor = vtkActor::SafeDownCast(prop);
vtkPolyData* polyData = vtkPolyData::SafeDownCast(actor->GetMapper()->GetInput());
appendFilter->AddInput(polyData);
}
vtkSmartPointer<vtkTransform> scaleTransform = vtkSmartPointer<vtkTransform>::New();
scaleTransform->Scale(ScaleFactor, ScaleFactor, ScaleFactor);
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter->SetInputConnection(appendFilter->GetOutputPort());
transformFilter->SetTransform(scaleTransform);
transformFilter->Update();
vtkSmartPointer<vtkPolyData> snapshot = vtkSmartPointer<vtkPolyData>::New();
snapshot->ShallowCopy(transformFilter->GetOutputDataObject(0));
return snapshot;
}
double mitk::Simulation::GetDefaultDT() const
{
return m_DefaultDT;
}
mitk::SimulationDrawTool* mitk::Simulation::GetDrawTool()
{
return &m_DrawTool;
}
sofa::simulation::Node::SPtr mitk::Simulation::GetRootNode() const
{
return m_RootNode;
}
sofa::simulation::Simulation::SPtr mitk::Simulation::GetSimulation() const
{
return m_Simulation;
}
bool mitk::Simulation::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
void mitk::Simulation::SetAsActiveSimulation()
{
SetActiveSimulation(this);
}
void mitk::Simulation::SetDefaultDT(double dt)
{
m_DefaultDT = std::max(0.0, dt);
}
void mitk::Simulation::SetRequestedRegion(itk::DataObject*)
{
}
void mitk::Simulation::SetRequestedRegionToLargestPossibleRegion()
{
}
void mitk::Simulation::SetRootNode(sofa::simulation::Node* rootNode)
{
m_RootNode.reset(rootNode);
}
mitk::Surface::Pointer mitk::Simulation::TakeSnapshot() const
{
vtkSmartPointer<vtkPolyData> snapshot = this->CreateSnapshot();
if (snapshot == NULL)
return NULL;
Surface::Pointer surface = Surface::New();
surface->SetVtkPolyData(snapshot);
return surface;
}
void mitk::Simulation::UpdateOutputInformation()
{
if (this->GetSource().IsNotNull())
this->GetSource()->UpdateOutputInformation();
if (m_RootNode != NULL)
{
const sofa::defaulttype::BoundingBox& boundingBox = m_RootNode->f_bbox.getValue();
const sofa::defaulttype::Vector3& min = boundingBox.minBBox();
const sofa::defaulttype::Vector3& max = boundingBox.maxBBox();
mitk::Geometry3D::BoundsArrayType bounds;
bounds[0] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.x() * ScaleFactor);
bounds[1] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.x() * ScaleFactor);
bounds[2] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.y() * ScaleFactor);
bounds[3] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.y() * ScaleFactor);
bounds[4] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(min.z() * ScaleFactor);
bounds[5] = static_cast<mitk::Geometry3D::BoundsArrayType::ValueType>(max.z() * ScaleFactor);
if(this->GetGeometry() != NULL)
{
this->GetGeometry()->SetBounds(bounds);
}
else
{
Geometry3D::Pointer geometry = Geometry3D::New();
geometry->SetBounds(bounds);
this->SetGeometry(geometry);
}
}
- this->GetTimeSlicedGeometry()->UpdateInformation();
+ this->GetTimeGeometry()->Update();
}
bool mitk::Simulation::VerifyRequestedRegion()
{
return true;
}
diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
index 548d80464d..5b7bcc51f3 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
@@ -1,393 +1,393 @@
/*===================================================================
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 <mitkToFCompositeFilter.h>
#include <mitkInstantiateAccessFunctions.h>
//#include <mitkOclToFCompositeFilter.h>
#include <itkImage.h>
mitk::ToFCompositeFilter::ToFCompositeFilter() : m_SegmentationMask(NULL), m_ImageWidth(0), m_ImageHeight(0), m_ImageSize(0),
m_IplDistanceImage(NULL), m_IplOutputImage(NULL), m_ItkInputImage(NULL), m_ApplyTemporalMedianFilter(false), m_ApplyAverageFilter(false),
m_ApplyMedianFilter(false), m_ApplyThresholdFilter(false), m_ApplyMaskSegmentation(false), m_ApplyBilateralFilter(false), m_DataBuffer(NULL),
m_DataBufferCurrentIndex(0), m_DataBufferMaxSize(0), m_TemporalMedianFilterNumOfFrames(10), m_ThresholdFilterMin(1),
m_ThresholdFilterMax(7000), m_BilateralFilterDomainSigma(2), m_BilateralFilterRangeSigma(60), m_BilateralFilterKernelRadius(0)
{
}
mitk::ToFCompositeFilter::~ToFCompositeFilter()
{
cvReleaseImage(&(this->m_IplDistanceImage));
cvReleaseImage(&(this->m_IplOutputImage));
if (m_DataBuffer!=NULL)
{
delete [] m_DataBuffer;
}
}
void mitk::ToFCompositeFilter::SetInput( mitk::Image* distanceImage )
{
this->SetInput(0, distanceImage);
}
void mitk::ToFCompositeFilter::SetInput( unsigned int idx, mitk::Image* distanceImage )
{
if ((distanceImage == NULL) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to NULL, reduce the number of inputs by one
{
this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
}
else
{
if (idx==0) //create IPL image holding distance data
{
if (distanceImage->GetData())
{
this->m_ImageWidth = distanceImage->GetDimension(0);
this->m_ImageHeight = distanceImage->GetDimension(1);
this->m_ImageSize = this->m_ImageWidth * this->m_ImageHeight * sizeof(float);
if (this->m_IplDistanceImage != NULL)
{
cvReleaseImage(&(this->m_IplDistanceImage));
}
float* distanceFloatData = (float*)distanceImage->GetSliceData(0, 0, 0)->GetData();
this->m_IplDistanceImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
if (this->m_IplOutputImage != NULL)
{
cvReleaseImage(&(this->m_IplOutputImage));
}
this->m_IplOutputImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
CreateItkImage(this->m_ItkInputImage);
}
}
this->ProcessObject::SetNthInput(idx, distanceImage); // Process object is not const-correct so the const_cast is required here
}
this->CreateOutputsForAllInputs();
}
mitk::Image* mitk::ToFCompositeFilter::GetInput()
{
return this->GetInput(0);
}
mitk::Image* mitk::ToFCompositeFilter::GetInput( unsigned int idx )
{
if (this->GetNumberOfInputs() < 1)
return NULL; //TODO: geeignete exception werfen
return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ToFCompositeFilter::GenerateData()
{
// copy input 1...n to output 1...n
for (unsigned int idx=0; idx<this->GetNumberOfOutputs(); idx++)
{
mitk::Image::Pointer outputImage = this->GetOutput(idx);
mitk::Image::Pointer inputImage = this->GetInput(idx);
if (outputImage.IsNotNull()&&inputImage.IsNotNull())
{
outputImage->CopyInformation(inputImage);
outputImage->Initialize(inputImage->GetPixelType(),inputImage->GetDimension(),inputImage->GetDimensions());
outputImage->SetSlice(inputImage->GetSliceData()->GetData());
}
}
mitk::Image::Pointer outputDistanceImage = this->GetOutput(0);
float* outputDistanceFloatData = (float*)outputDistanceImage->GetSliceData(0, 0, 0)->GetData();
mitk::Image::Pointer inputDistanceImage = this->GetInput();
// copy initial distance image to ipl image
float* distanceFloatData = (float*)inputDistanceImage->GetSliceData(0, 0, 0)->GetData();
memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
if (m_ApplyThresholdFilter||m_ApplyMaskSegmentation)
{
ProcessSegmentation(this->m_IplDistanceImage);
}
if (this->m_ApplyTemporalMedianFilter||this->m_ApplyAverageFilter)
{
ProcessStreamedQuickSelectMedianImageFilter(this->m_IplDistanceImage);
}
if (this->m_ApplyMedianFilter)
{
ProcessCVMedianFilter(this->m_IplDistanceImage, this->m_IplOutputImage);
memcpy( this->m_IplDistanceImage->imageData, this->m_IplOutputImage->imageData, this->m_ImageSize );
}
if (this->m_ApplyBilateralFilter)
{
float* itkFloatData = this->m_ItkInputImage->GetBufferPointer();
memcpy(itkFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
ItkImageType2D::Pointer itkOutputImage = ProcessItkBilateralFilter(this->m_ItkInputImage);
memcpy( this->m_IplDistanceImage->imageData, itkOutputImage->GetBufferPointer(), this->m_ImageSize );
//ProcessCVBilateralFilter(this->m_IplDistanceImage, this->m_OutputIplImage, domainSigma, rangeSigma, kernelRadius);
//memcpy( distanceFloatData, this->m_OutputIplImage->imageData, distanceImageSize );
}
memcpy( outputDistanceFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
}
void mitk::ToFCompositeFilter::CreateOutputsForAllInputs()
{
this->SetNumberOfOutputs(this->GetNumberOfInputs()); // create outputs for all inputs
for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
if (this->GetOutput(idx) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
void mitk::ToFCompositeFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if (output->IsInitialized())
return;
itkDebugMacro(<<"GenerateOutputInformation()");
- output->Initialize(input->GetPixelType(), *input->GetTimeSlicedGeometry());
+ output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
output->SetPropertyList(input->GetPropertyList()->Clone());
}
void mitk::ToFCompositeFilter::ProcessSegmentation(IplImage* inputIplImage)
{
char* segmentationMask;
if (m_SegmentationMask.IsNotNull())
{
segmentationMask = (char*)m_SegmentationMask->GetSliceData(0, 0, 0)->GetData();
}
else
{
segmentationMask = NULL;
}
float *f = (float*)inputIplImage->imageData;
for(int i=0; i<this->m_ImageWidth*this->m_ImageHeight; i++)
{
if (this->m_ApplyThresholdFilter)
{
if (f[i]<=m_ThresholdFilterMin)
{
f[i] = 0.0;
}
else if (f[i]>=m_ThresholdFilterMax)
{
f[i] = 0.0;
}
}
if (this->m_ApplyMaskSegmentation)
{
if (segmentationMask)
{
if (segmentationMask[i]==0)
{
f[i] = 0.0;
}
}
}
}
}
ItkImageType2D::Pointer mitk::ToFCompositeFilter::ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage)
{
ItkImageType2D::Pointer outputItkImage;
BilateralFilterType::Pointer bilateralFilter = BilateralFilterType::New();
bilateralFilter->SetInput(inputItkImage);
bilateralFilter->SetDomainSigma(m_BilateralFilterDomainSigma);
bilateralFilter->SetRangeSigma(m_BilateralFilterRangeSigma);
//bilateralFilter->SetRadius(m_BilateralFilterKernelRadius);
outputItkImage = bilateralFilter->GetOutput();
outputItkImage->Update();
return outputItkImage;
}
void mitk::ToFCompositeFilter::ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage)
{
int diameter = m_BilateralFilterKernelRadius;
double sigmaColor = m_BilateralFilterRangeSigma;
double sigmaSpace = m_BilateralFilterDomainSigma;
cvSmooth(inputIplImage, outputIplImage, CV_BILATERAL, diameter, 0, sigmaColor, sigmaSpace);
}
void mitk::ToFCompositeFilter::ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius)
{
cvSmooth(inputIplImage, outputIplImage, CV_MEDIAN, radius, 0, 0, 0);
}
void mitk::ToFCompositeFilter::ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage)
{
float* data = (float*)inputIplImage->imageData;
int imageSize = inputIplImage->width * inputIplImage->height;
float* tmpArray;
if (this->m_TemporalMedianFilterNumOfFrames == 0)
{
return;
}
if (m_TemporalMedianFilterNumOfFrames != this->m_DataBufferMaxSize) // reset
{
//delete current buffer
for( int i=0; i<this->m_DataBufferMaxSize; i++ ) {
delete[] this->m_DataBuffer[i];
}
if (this->m_DataBuffer != NULL)
{
delete[] this->m_DataBuffer;
}
this->m_DataBufferMaxSize = m_TemporalMedianFilterNumOfFrames;
// create new buffer with current size
this->m_DataBuffer = new float*[this->m_DataBufferMaxSize];
for(int i=0; i<this->m_DataBufferMaxSize; i++)
{
this->m_DataBuffer[i] = NULL;
}
this->m_DataBufferCurrentIndex = 0;
}
int currentBufferSize = this->m_DataBufferMaxSize;
tmpArray = new float[this->m_DataBufferMaxSize];
// copy data to buffer
if (this->m_DataBuffer[this->m_DataBufferCurrentIndex] == NULL)
{
this->m_DataBuffer[this->m_DataBufferCurrentIndex] = new float[imageSize];
currentBufferSize = this->m_DataBufferCurrentIndex + 1;
}
for(int j=0; j<imageSize; j++)
{
this->m_DataBuffer[this->m_DataBufferCurrentIndex][j] = data[j];
}
float tmpValue = 0.0f;
for(int i=0; i<imageSize; i++)
{
if (m_ApplyAverageFilter)
{
tmpValue = 0.0f;
for(int j=0; j<currentBufferSize; j++)
{
tmpValue+=this->m_DataBuffer[j][i];
}
data[i] = tmpValue/currentBufferSize;
}
else if (m_ApplyTemporalMedianFilter)
{
for(int j=0; j<currentBufferSize; j++)
{
tmpArray[j] = this->m_DataBuffer[j][i];
}
data[i] = quick_select(tmpArray, currentBufferSize);
}
}
this->m_DataBufferCurrentIndex = (this->m_DataBufferCurrentIndex + 1) % this->m_DataBufferMaxSize;
delete[] tmpArray;
}
#define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }
float mitk::ToFCompositeFilter::quick_select(float arr[], int n)
{
int low = 0;
int high = n-1;
int median = (low + high)/2;
int middle = 0;
int ll = 0;
int hh = 0;
for (;;) {
if (high <= low) /* One element only */
return arr[median] ;
if (high == low + 1) { /* Two elements only */
if (arr[low] > arr[high])
ELEM_SWAP(arr[low], arr[high]) ;
return arr[median] ;
}
/* Find median of low, middle and high items; swap into position low */
middle = (low + high) / 2;
if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
/* Swap low item (now in position middle) into position (low+1) */
ELEM_SWAP(arr[middle], arr[low+1]) ;
/* Nibble from each end towards middle, swapping items when stuck */
ll = low + 1;
hh = high;
for (;;) {
do ll++; while (arr[low] > arr[ll]) ;
do hh--; while (arr[hh] > arr[low]) ;
if (hh < ll)
break;
ELEM_SWAP(arr[ll], arr[hh]) ;
}
/* Swap middle item (in position low) back into correct position */
ELEM_SWAP(arr[low], arr[hh]) ;
/* Re-set active partition */
if (hh <= median)
low = ll;
if (hh >= median)
high = hh - 1;
}
}
#undef ELEM_SWAP
void mitk::ToFCompositeFilter::SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames)
{
this->m_TemporalMedianFilterNumOfFrames = tmporalMedianFilterNumOfFrames;
}
void mitk::ToFCompositeFilter::SetThresholdFilterParameter(int min, int max)
{
if (min > max)
{
min = max;
}
this->m_ThresholdFilterMin = min;
this->m_ThresholdFilterMax = max;
}
void mitk::ToFCompositeFilter::SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius = 0)
{
this->m_BilateralFilterDomainSigma = domainSigma;
this->m_BilateralFilterRangeSigma = rangeSigma;
this->m_BilateralFilterKernelRadius = kernelRadius;
}
void mitk::ToFCompositeFilter::CreateItkImage(ItkImageType2D::Pointer &itkInputImage)
{
itkInputImage = ItkImageType2D::New();
ItkImageType2D::IndexType startIndex;
startIndex[0] = 0; // first index on X
startIndex[1] = 0; // first index on Y
ItkImageType2D::SizeType size;
size[0] = this->m_ImageWidth; // size along X
size[1] = this->m_ImageHeight; // size along Y
ItkImageType2D::RegionType region;
region.SetSize( size );
region.SetIndex( startIndex );
itkInputImage->SetRegions( region );
itkInputImage->Allocate();
}
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
index d63125f25a..5466955b11 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderingManager.h
@@ -1,162 +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.
===================================================================*/
#ifndef MITKIRENDERINGMANAGER_H
#define MITKIRENDERINGMANAGER_H
#include <mitkRenderingManager.h>
#include <org_mitk_gui_common_Export.h>
#include <QList>
#include <QtPlugin>
namespace mitk {
/**
* \ingroup org_mitk_gui_common
*
* \brief An interface for accessing a mitk::RenderingManager instance.
*
* This interface acts as a wrapper to a mitk::RenderingManager instance, hiding some
* methods from the user.
*
* \see MakeRenderingManagerInterface
*/
struct IRenderingManager {
virtual ~IRenderingManager() {}
/** Get a list of all registered RenderWindows */
virtual QList<vtkRenderWindow*> GetAllRegisteredVtkRenderWindows() const = 0;
/**
* Requests an update for the specified RenderWindow, to be executed as
* soon as the main loop is ready for rendering.
*/
virtual void RequestUpdate( vtkRenderWindow *renderWindow ) = 0;
/** Immediately executes an update of the specified RenderWindow. */
virtual void ForceImmediateUpdate( vtkRenderWindow *renderWindow ) = 0;
/**
* Requests all currently registered RenderWindows to be updated.
* If only 2D or 3D windows should be updated, this can be specified
* via the parameter requestType.
*/
virtual void RequestUpdateAll( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
/**
* Immediately executes an update of all registered RenderWindows.
* If only 2D or 3D windows should be updated, this can be specified
* via the parameter requestType.
*/
virtual void ForceImmediateUpdateAll( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
/** Initializes the windows specified by requestType to the given geometry. */
virtual bool InitializeViews( const Geometry3D *geometry,
RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
bool preserveRoughOrientationInWorldSpace = false ) = 0;
virtual bool InitializeViews( const TimeGeometry *geometry,
RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL,
bool preserveRoughOrientationInWorldSpace = false ) = 0;
/**
* Initializes the windows to the default viewing direction
* (geomtry information is NOT changed).
*/
virtual bool InitializeViews( RenderingManager::RequestType type = RenderingManager::REQUEST_UPDATE_ALL ) = 0;
/**
* Initializes the specified window to the given geometry. Set
* "initializeGlobalTimeSNC" to true in order to use this geometry as
- * global TimeSlicedGeometry.
+ * global TimeGeometry.
*/
virtual bool InitializeView( vtkRenderWindow *renderWindow, const Geometry3D *geometry,
bool initializeGlobalTimeSNC = false) = 0;
/**
* Initializes the specified window to the default viewing direction
* (geomtry information is NOT changed).
*/
virtual bool InitializeView( vtkRenderWindow *renderWindow ) = 0;
/** Gets the SliceNavigationController responsible for time-slicing. */
virtual const SliceNavigationController *GetTimeNavigationController() const = 0;
/** Gets the SliceNavigationController responsible for time-slicing. */
virtual SliceNavigationController *GetTimeNavigationController() = 0;
virtual bool IsRendering() const = 0;
virtual void AbortRendering() = 0;
/** En-/Disable LOD increase globally. */
virtual void SetLODIncreaseBlocked(bool blocked) = 0;
/** Get LOD blocked status. */
virtual bool GetLODIncreaseBlocked() const = 0;
/** En-/Disable LOD abort mechanism. */
virtual void SetLODAbortMechanismEnabled(bool abort) = 0;
/** Get LOD abort mechanism status. */
virtual bool GetLODAbortMechanismEnabled() const = 0;
/** En-/Disable depth peeling for all renderers */
virtual void SetDepthPeelingEnabled(bool enabled) = 0;
/** Set maximum number of peels for all renderers */
virtual void SetMaxNumberOfPeels(int maxNumber) = 0;
virtual int GetNextLOD( BaseRenderer* renderer ) const = 0;
/** Set current LOD (NULL means all renderers)*/
virtual void SetMaximumLOD( unsigned int max ) = 0;
virtual void SetShading( bool state, unsigned int lod ) = 0;
virtual bool GetShading( unsigned int lod ) = 0;
virtual void SetClippingPlaneStatus( bool status ) = 0;
virtual bool GetClippingPlaneStatus() = 0;
virtual void SetShadingValues( float ambient, float diffuse,
float specular, float specpower ) = 0;
virtual QList<float> GetShadingValues() const = 0;
};
}
Q_DECLARE_INTERFACE(mitk::IRenderingManager, "org.mitk.ui.IRenderingManager")
namespace mitk {
/**
* Create a IRenderManager interface for a given RenderingManager. Ownership of the
* returned pointer is transferred to the caller of this function.
*
* \param manager The RenderingManager instance for which to create a interface.
* \return A pointer to the interface object. The caller is responsible for deleting the pointer.
*/
MITK_GUI_COMMON_PLUGIN IRenderingManager* MakeRenderingManagerInterface(RenderingManager::Pointer manager);
}
#endif // MITKIRENDERINGMANAGER_H
diff --git a/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
index 2516a8faae..cc95852578 100644
--- a/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanagerlight/src/internal/QmitkDataManagerLightView.cpp
@@ -1,268 +1,268 @@
/*===================================================================
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 "QmitkDataManagerLightView.h"
#include "mitkNodePredicateDataType.h"
#include <QtGui>
#include <mitkCoreObjectFactory.h>
#include <mitkDataNodeFactory.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkIRenderingManager.h>
const std::string QmitkDataManagerLightView::VIEW_ID = "org.mitk.views.datamanagerlight";
struct QmitkDataManagerLightViewData
{
// static
mitk::NodePredicateBase::Pointer m_Predicate;
QIcon m_ItemIcon;
// data
QList<mitk::DataNode*> m_DataNodes;
int m_CurrentIndex;
// widget
QListWidget* m_ListWidget;
QLabel* m_ImageInfoLabel;
QPushButton* m_RemoveButton;
};
QmitkDataManagerLightView::QmitkDataManagerLightView()
: d( new QmitkDataManagerLightViewData )
{
d->m_Predicate = mitk::NodePredicateDataType::New("Image");
d->m_ItemIcon = QIcon(":/org.mitk.gui.qt.datamanagerlight/Image_24.png");
d->m_CurrentIndex = -1;
d->m_ListWidget = 0;
d->m_ImageInfoLabel = 0;
d->m_RemoveButton = 0;
}
QmitkDataManagerLightView::~QmitkDataManagerLightView()
{
delete d;
}
void QmitkDataManagerLightView::NodeAdded(const mitk::DataNode *node)
{
if( d->m_Predicate->CheckNode(node) )
{
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
d->m_DataNodes.append(nonConstNode);
d->m_ListWidget->addItem( new QListWidgetItem( d->m_ItemIcon, QString::fromStdString( node->GetName() ) ) );
}
}
void QmitkDataManagerLightView::NodeRemoved(const mitk::DataNode *node)
{
this->RemoveNode( const_cast<mitk::DataNode*>(node) );
}
void QmitkDataManagerLightView::NodeChanged(const mitk::DataNode *node)
{
MITK_DEBUG << "NodeChanged";
if( d->m_DataNodes.contains(const_cast<mitk::DataNode*>(node)) )
this->ToggleVisibility();
}
void QmitkDataManagerLightView::RemoveNode(mitk::DataNode *node)
{
mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
int index = d->m_DataNodes.indexOf(nonConstNode);
if( index >= 0 )
{
MITK_DEBUG << "removing node at: " << index;
QListWidgetItem* item = d->m_ListWidget->takeItem(index);
delete item;
d->m_DataNodes.removeAt(index);
MITK_DEBUG << "item deleted";
}
}
void QmitkDataManagerLightView::CreateQtPartControl(QWidget* parent)
{
QPushButton* loadButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Load_48.png"), "Load");
d->m_RemoveButton = new QPushButton(QIcon(":/org.mitk.gui.qt.datamanagerlight/Remove_48.png"), "Remove");
d->m_RemoveButton->setEnabled(false);
d->m_ListWidget = new QListWidget;
d->m_ImageInfoLabel = new QLabel;
QGridLayout* layout = new QGridLayout;
layout->addWidget( loadButton, 0,0 );
layout->addWidget( d->m_RemoveButton, 0,1 );
layout->addWidget( d->m_ImageInfoLabel, 1,0, 1, 2 );
layout->addWidget( d->m_ListWidget, 2,0,1,2 );
parent->setLayout(layout);
connect(d->m_ListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(on_DataItemList_currentRowChanged(int)) );
connect(loadButton, SIGNAL(pressed()), this, SLOT(on_Load_pressed()) );
connect(d->m_RemoveButton, SIGNAL(pressed()), this, SLOT(on_Remove_pressed()) );
this->ListSelectionChanged();
}
void QmitkDataManagerLightView::SetFocus()
{
d->m_ListWidget->setFocus();
}
void QmitkDataManagerLightView::on_DataItemList_currentRowChanged(int currentRow)
{
MITK_DEBUG << "DataItemList currentRowChanged: " << currentRow;
Q_UNUSED(currentRow)
this->ListSelectionChanged();
}
void QmitkDataManagerLightView::ListSelectionChanged()
{
d->m_CurrentIndex = d->m_ListWidget->currentRow();
MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
QString newLabelText = "Current patient: ";
if( d->m_CurrentIndex >= 0 )
{
// TODO WHERE IS THE PATIENT NAME?
std::string name = d->m_DataNodes.at(d->m_CurrentIndex)->GetName();
newLabelText.append( QString("<strong>%1</strong>" ).arg( QString::fromStdString(name) ) );
d->m_RemoveButton->setEnabled(true);
}
else
{
newLabelText.append("<strong>Unknown</strong>");
d->m_RemoveButton->setEnabled(false);
}
d->m_ImageInfoLabel->setText(newLabelText);
this->ToggleVisibility();
}
void QmitkDataManagerLightView::on_Load_pressed()
{
MITK_DEBUG << "on_Load_pressed";
QStringList fileNames = QFileDialog::getOpenFileNames(NULL, "Load data", "", mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
for ( QStringList::Iterator it = fileNames.begin(); it != fileNames.end(); ++it )
{
FileOpen((*it).toAscii(), 0);
}
}
void QmitkDataManagerLightView::FileOpen( const char * fileName, mitk::DataNode* parentNode )
{
mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
try
{
factory->SetFileName( fileName );
QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
factory->Update();
for ( unsigned int i = 0 ; i < factory->GetNumberOfOutputs( ); ++i )
{
mitk::DataNode::Pointer node = factory->GetOutput( i );
if ( ( node.IsNotNull() ) && ( node->GetData() != NULL ) )
{
this->GetDataStorage()->Add(node, parentNode);
mitk::BaseData::Pointer basedata = node->GetData();
mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
catch ( itk::ExceptionObject & ex )
{
MITK_ERROR << "Exception during file open: " << ex;
}
QApplication::restoreOverrideCursor();
}
void QmitkDataManagerLightView::on_Remove_pressed()
{
d->m_CurrentIndex = d->m_ListWidget->currentRow();
MITK_DEBUG << "the currently selected index: " << d->m_CurrentIndex;
mitk::DataNode* node = d->m_DataNodes.at(d->m_CurrentIndex);
QString question = tr("Do you really want to remove ");
// TODO patient name?
question.append( QString::fromStdString( node->GetName() ) );
question.append(" ?");
QMessageBox::StandardButton answerButton = QMessageBox::question( NULL
, tr("DataManagerLight")
, question
, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if(answerButton == QMessageBox::Yes)
{
this->GetDataStorage()->Remove(node);
this->GlobalReinit();
}
}
void QmitkDataManagerLightView::GlobalReinit()
{
mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
// no render window available
if (renderWindow == NULL) return;
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
renderWindow->GetRenderingManager()->InitializeViews(bounds);
}
void QmitkDataManagerLightView::ToggleVisibility()
{
bool changedAnything = false;
bool isVisible = false;
for(size_t i=0; i<d->m_DataNodes.size(); ++i)
{
isVisible = false;
d->m_DataNodes.at(i)->GetVisibility(isVisible, 0 );
if( d->m_CurrentIndex == i && isVisible == false )
{
d->m_DataNodes.at(i)->SetVisibility(true);
changedAnything = true;
}
else if( d->m_CurrentIndex != i && isVisible == true )
{
d->m_DataNodes.at(i)->SetVisibility(false);
changedAnything = true;
}
}
if( changedAnything )
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
index ccee2f9b5d..0bc0ef41e2 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
@@ -1,99 +1,99 @@
/*===================================================================
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 "mitkPluginActivator.h"
#include "DicomEventHandler.h"
#include <service/event/ctkEventConstants.h>
#include <ctkDictionary.h>
#include <mitkLogMacros.h>
#include <mitkDicomSeriesReader.h>
#include <mitkDataNode.h>
#include <QmitkBaseFunctionalityComponent.h>
#include <mitkIDataStorageService.h>
#include <service/event/ctkEventAdmin.h>
#include <ctkServiceReference.h>
#include <mitkRenderingManager.h>
#include <QVector>
DicomEventHandler::DicomEventHandler()
{
}
DicomEventHandler::~DicomEventHandler()
{
}
void DicomEventHandler::OnSignalAddSeriesToDataManager(const ctkEvent& ctkEvent)
{
QStringList listOfFilesForSeries;
mitk::DicomSeriesReader::StringContainer seriesToLoad;
listOfFilesForSeries = ctkEvent.getProperty("FilesForSeries").toStringList();
if (!listOfFilesForSeries.isEmpty()){
QStringListIterator it(listOfFilesForSeries);
while (it.hasNext())
{
seriesToLoad.push_back(it.next().toStdString());
}
mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries(seriesToLoad);
if (node.IsNull())
{
MITK_ERROR << "Error loading series: " << ctkEvent.getProperty("SeriesName").toString().toStdString()
<< " id: " <<ctkEvent.getProperty("SeriesUID").toString().toStdString();
}
else
{
//Get Reference for default data storage.
ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
dataStorage->Add(node);
// Initialize the RenderWindow
- mitk::TimeSlicedGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
+ mitk::TimeGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
}
}
else
{
MITK_INFO << "There are no files for the current series";
}
}
void DicomEventHandler::OnSignalRemoveSeriesFromStorage(const ctkEvent& ctkEvent)
{
}
void DicomEventHandler::SubscribeSlots()
{
ctkServiceReference ref = mitk::PluginActivator::getContext()->getServiceReference<ctkEventAdmin>();
if (ref)
{
ctkEventAdmin* eventAdmin = mitk::PluginActivator::getContext()->getService<ctkEventAdmin>(ref);
ctkDictionary properties;
properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/ADD";
eventAdmin->subscribeSlot(this, SLOT(OnSignalAddSeriesToDataManager(ctkEvent)), properties);
properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/DELETED";
eventAdmin->subscribeSlot(this, SLOT(OnSignalRemoveSeriesFromStorage(ctkEvent)), properties);
}
}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
index 0a42c8e3e5..b90f35a7b0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp
@@ -1,1810 +1,1810 @@
/*===================================================================
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.
===================================================================*/
//=========FOR TESTING==========
//random generation, number of points equal requested points
// Blueberry application and interaction service
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkFiberBundleDeveloperView.h"
#include <QmitkStdMultiWidget.h>
// Qt
#include <QTimer>
// MITK
#include <mitkPlanarCircle.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkGlobalInteraction.h>
-//===needed when timeSlicedGeometry is null to invoke rendering mechansims ====
+//===needed when timeGeometry is null to invoke rendering mechansims ====
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// VTK
#include <vtkPointSource.h> //for randomized FiberStructure
#include <vtkPolyLine.h> //for fiberStructure
#include <vtkCellArray.h> //for fiberStructure
#include <vtkMatrix4x4.h> //for geometry
//ITK
#include <itkTimeProbe.h>
//==============================================
//======== W O R K E R S ____ S T A R T ========
//==============================================
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --generate FiberIDs--*/
QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberIDWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
m_itemPackage.st_FBX->GenerateFiberIds();
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* -- extract fibers by given PlanarFigure --*/
QmitkFiberExtractorWorker::QmitkFiberExtractorWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberExtractorWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerExtractFibers->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
std::vector<long> fibIds = m_itemPackage.st_FBX->ExtractFiberIdSubset(m_itemPackage.st_PlanarFigure);
//generate new fiberbundle by fiber iDs
vtkSmartPointer<vtkPolyData> newFBPolyData = m_itemPackage.st_FBX->GeneratePolyDataByIds(fibIds);
// call function to convert fiberstructure into fiberbundleX and pass it to datastorage
(m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(newFBPolyData);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerExtractFibers->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --set FA values to fiberbundle--*/
QmitkFiberColoringWorker::QmitkFiberColoringWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage)
, m_hostingThread(hostingThread)
{
}
void QmitkFiberColoringWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe*/
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerColorCoding->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
if(m_itemPackage.st_Controls->radioButton_ColorOrient->isChecked()) {
m_itemPackage.st_FBX->DoColorCodingOrientationBased();
} else if(m_itemPackage.st_Controls->radioButton_ColorFA->isChecked()) {
m_itemPackage.st_FBX->DoColorCodingFaBased();
} else if(m_itemPackage.st_Controls->radioButton_OpacityFA->isChecked()) {
// m_itemPackage.st_FBX->SetColorCoding("");
m_itemPackage.st_PassedDataNode->SetOpacity(0.999);
m_itemPackage.st_FBX->DoUseFaFiberOpacity();
} else if(m_itemPackage.st_Controls->radioButton_ColorCustom->isChecked()){
m_itemPackage.st_FBX->SetColorCoding(mitk::FiberBundleX::COLORCODING_CUSTOM);
}
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerColorCoding->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
QmitkFiberFeederFAWorker::QmitkFiberFeederFAWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberFeederFAWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS
* accurate time measurement using ITK timeProbe */
itk::TimeProbe clock;
clock.Start();
//set GUI representation of timer to 0, is essential for correct timer incrementation
m_itemPackage.st_Controls->infoTimerSetFA->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing
mitk::Image::Pointer FAImg = dynamic_cast<mitk::Image*>(m_itemPackage.st_PassedDataNode->GetData());
if(FAImg.IsNotNull())
m_itemPackage.st_FBX->SetFAMap(FAImg);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
clock.Stop();
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerSetFA->setText( QString::number(clock.GetTotal()) );
disconnect(m_itemPackage.st_FancyGUITimer1);
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --generate random fibers--*/
QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage)
: m_itemPackage(itemPackage),
m_hostingThread(hostingThread)
{
}
void QmitkFiberGenerateRandomWorker::run()
{
if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked())
m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING);
/* MEASUREMENTS AND FANCY GUI EFFECTS */
//MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0));
m_itemPackage.st_FancyGUITimer1->start();
//do processing, generateRandomFibers
int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value();
int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value();
int numOfPoints = numOfFibers * distrRadius;
std::vector< std::vector<int> > fiberStorage;
for (int i=0; i<numOfFibers; ++i) {
std::vector<int> a;
fiberStorage.push_back( a );
}
/* Generate Point Cloud */
vtkSmartPointer<vtkPointSource> randomPoints = vtkSmartPointer<vtkPointSource>::New();
randomPoints->SetCenter(0.0, 0.0, 0.0);
randomPoints->SetNumberOfPoints(numOfPoints);
randomPoints->SetRadius(distrRadius);
randomPoints->Update();
vtkPoints* pnts = randomPoints->GetOutput()->GetPoints();
/* ASSIGN EACH POINT TO A RANDOM FIBER */
srand((unsigned)time(0)); // init randomizer
for (int i=0; i<pnts->GetNumberOfPoints(); ++i) {
//generate random number between 0 and numOfFibers-1
int random_integer;
random_integer = (rand()%numOfFibers);
//add current point to random fiber
fiberStorage.at(random_integer).push_back(i);
// MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer;
}
// initialize accurate time measurement
itk::TimeProbe clock;
clock.Start();
/* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */
vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New(); // Host vtkPolyLines
linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID]
for (long i=0; i<fiberStorage.size(); ++i)
{
std::vector<int> singleFiber = fiberStorage.at(i);
vtkSmartPointer<vtkPolyLine> fiber = vtkSmartPointer<vtkPolyLine>::New();
fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size());
for (long si=0; si<singleFiber.size(); ++si)
{ //hopefully long to double works fine in VTK ;-)
fiber->GetPointIds()->SetId( si, singleFiber.at(si) );
}
linesCell->InsertNextCell(fiber);
}
/* checkpoint for cellarray allocation */
if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12
{
MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance.";
}
/* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */
vtkSmartPointer<vtkPolyData> PDRandom = vtkSmartPointer<vtkPolyData>::New(); //could also be a standard pointer instead of smartpointer cuz ther is no need to delete because data is managed in datastorage.
PDRandom->SetPoints(pnts);
PDRandom->SetLines(linesCell);
// accurate timer measurement stop
clock.Stop();
//MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl;
// call function to convert fiberstructure into fiberbundleX and pass it to datastorage
(m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom);
/* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */
m_itemPackage.st_FancyGUITimer1->stop();
m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) );
delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore
m_hostingThread->quit();
}
/*===================================================================================
* THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD
* --update GUI elements of thread monitor--
* implementation not thread safe, not needed so far because
* there exists only 1 thread for fiberprocessing
* for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */
QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage )
: m_itemPackage(itemPackage)
, m_hostingThread(hostingThread)
, m_pixelstepper(10) //for next rendering call, move object 10px
, m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff
{
//set timers
m_thtimer_initMonitor = new QTimer;
m_thtimer_initMonitor->setInterval(10);
m_thtimer_initMonitorSetFinalPosition = new QTimer;
m_thtimer_initMonitorSetFinalPosition->setInterval(10);
m_thtimer_initMonitorSetMasks = new QTimer;
m_thtimer_initMonitorSetFinalPosition->setInterval(10);
m_thtimer_threadStarted = new QTimer;
m_thtimer_threadStarted->setInterval(50);
m_thtimer_threadFinished = new QTimer;
m_thtimer_threadFinished->setInterval(50);
m_thtimer_threadTerminated = new QTimer;
m_thtimer_threadTerminated->setInterval(50);
connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) );
connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) );
connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) );
connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) );
connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) );
connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) );
//first, the current text shall turn transparent
m_decreaseOpacity_threadStarted = true;
m_decreaseOpacity_threadFinished = true;
m_decreaseOpacity_threadTerminated = true;
}
void QmitkFiberThreadMonitorWorker::run()
{
}
void QmitkFiberThreadMonitorWorker::initializeMonitor()
{
//fancy configuration of animation start
mitk::Point2D pntOpen;
pntOpen[0] = 118;
pntOpen[1] = 10;
mitk::Point2D headPos;
headPos[0] = 19;
headPos[1] = 10;
mitk::Point2D statusPos;
statusPos[0] = 105;
statusPos[1] = 23;
mitk::Point2D startedPos;
startedPos[0] = 68;
startedPos[1] = 10;
mitk::Point2D finishedPos;
finishedPos[0] = 143;
finishedPos[1] = 10;
mitk::Point2D terminatedPos;
terminatedPos[0] = 240;
terminatedPos[1] = 10;
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos);
m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos);
m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos);
m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos);
m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos);
m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos);
m_thtimer_initMonitor->start();
}
void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status)
{
m_itemPackage.st_FBX_Monitor->setStatus(status);
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
/* Methods to set status of running threads
* Following three methods are usually called
- before a thread starts and
- a thread is finished or terminated */
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted()
{
if(!m_thtimer_threadStarted->isActive()) {
m_thtimer_threadStarted->start();
} else {
//fast change without fancy stuff, needed to keep threaddebugger info up to date
int counter = m_itemPackage.st_FBX_Monitor->getStarted();
m_itemPackage.st_FBX_Monitor->setStarted(++counter);
}
}
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished()
{
if(!m_thtimer_threadFinished->isActive()) {
m_thtimer_threadFinished->start();
} else {
//fast change without fancy stuff
int counter = m_itemPackage.st_FBX_Monitor->getFinished();
m_itemPackage.st_FBX_Monitor->setFinished(++counter);
}
}
void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated()
{
if(!m_thtimer_threadTerminated->isActive()) {
m_thtimer_threadTerminated->start();
} else {
//fast change without fancy stuff
int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
}
}
/* Helper methods for fancy fading efx for thread monitor */
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted()
{
if (m_decreaseOpacity_threadStarted) {
int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity );
if (startedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getStarted();
m_itemPackage.st_FBX_Monitor->setStarted(++counter);
m_decreaseOpacity_threadStarted = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity();
m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity );
if (startedOpacity >= 10) {
m_thtimer_threadStarted->stop();
m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished()
{
if (m_decreaseOpacity_threadFinished) {
int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity );
if (finishedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getFinished();
m_itemPackage.st_FBX_Monitor->setFinished(++counter);
m_decreaseOpacity_threadFinished = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity();
m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity );
if (finishedOpacity >= 10) {
m_thtimer_threadFinished->stop();
m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated()
{
if (m_decreaseOpacity_threadTerminated) {
int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity );
if (terminatedOpacity == 0) {
int counter = m_itemPackage.st_FBX_Monitor->getTerminated();
m_itemPackage.st_FBX_Monitor->setTerminated(++counter);
m_decreaseOpacity_threadTerminated = false;
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
} else {
int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity();
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity );
if (terminatedOpacity >= 10) {
m_thtimer_threadTerminated->stop();
m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization()
{
mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member
mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member
pntClose[0] += m_pixelstepper;
pntOpen[0] -= m_pixelstepper;
//MITK_INFO << pntClose[0] << " " << pntOpen[0];
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1;
if (opacity > 10)
opacity = 10;
m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity);
if (pntClose[0] >= m_steppingDistance)
{
if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 )
{
m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10);
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
m_thtimer_initMonitor->stop();
//position them to obt y=25
m_thtimer_initMonitorSetFinalPosition->start();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos()
{
//get y pos of
mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition();
mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition();
mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition();
pntClose[1] += 5;
pntOpen[1] += 5;
pntHead[1] += 5;
m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose);
m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen);
m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead);
if (pntClose[1] >= 35) { //35 = y position
m_thtimer_initMonitorSetFinalPosition->stop();
//now init mask of labels
m_thtimer_initMonitorSetMasks->start();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask()
{
//increase opacity
int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity();
opacity++;
m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity);
m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity);
if (opacity >=10) {
m_thtimer_initMonitorSetMasks->stop();
}
m_itemPackage.st_ThreadMonitorDataNode->Modified();
m_itemPackage.st_MultiWidget->RequestUpdate();
}
//==============================================
//======== W O R K E R S ________ E N D ========
//==============================================
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
// HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
//========#########################===============###########################=====================#########################
const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper";
const std::string id_DataManager = "org.mitk.views.datamanager";
using namespace berry;
QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_FiberIDGenerator( NULL)
, m_GeneratorFibersRandom( NULL )
, m_FiberFeederFASlave( NULL )
, m_FiberColoringSlave(NULL)
, m_FiberExtractor(NULL)
, m_fiberMonitorIsOn( false )
, m_CircleCounter( 0 )
, m_suppressSignal(false)
{
m_hostThread = new QThread;
m_threadInProgress = false;
}
// Destructor
QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView()
{
//m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary
delete m_hostThread;
}
void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done in QtDesigner, etc.
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls;
m_Controls->setupUi( parent );
/*=========INITIALIZE BUTTON CONFIGURATION ================*/
m_Controls->radioButton_directionX->setEnabled(false);
m_Controls->radioButton_directionY->setEnabled(false);
m_Controls->radioButton_directionZ->setEnabled(false);
m_Controls->buttonGenerateFiberIds->setEnabled(false);
m_Controls->buttonGenerateFibers->setEnabled(true);
m_Controls->buttonColorFibers->setEnabled(false);
m_Controls->ddAvailableColorcodings->setEnabled(false);
m_Controls->buttonExtractFibers->setEnabled(false);
m_Controls->button_FAMap->setEnabled(true);
m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented
m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented
m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented
m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented
connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) );
connect( m_Controls->buttonGenerateFiberIds, SIGNAL(clicked()), this, SLOT(DoGenerateFiberIDs()) );
connect( m_Controls->button_FAMapExecute, SIGNAL(clicked()), this, SLOT(DoSetFAValues()) );
connect( m_Controls->button_FAMap, SIGNAL(clicked()), this, SLOT(DoSetFAMap()) );
connect( m_Controls->buttonExtractFibers, SIGNAL(clicked()), this, SLOT(DoExtractFibers()) );
connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) );
connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) );
connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( ActionDrawEllipseTriggered() ) );
connect( m_Controls->buttonColorFibers, SIGNAL(clicked()), this, SLOT(DoColorFibers()) );
// connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
connect( m_Controls->ddAvailableColorcodings, SIGNAL(currentIndexChanged(int)), this, SLOT(SetCurrentColorCoding(int) ));
connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) );
}
// Checkpoint for fiber ORIENTATION
if ( m_DirectionRadios.empty() )
{
m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom);
m_DirectionRadios.insert(1, m_Controls->radioButton_directionX);
m_DirectionRadios.insert(2, m_Controls->radioButton_directionY);
m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ);
}
// set GUI elements of FiberGenerator to according configuration
DoUpdateGenerateFibersWidget();
}
/* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED
* RADIO BUTTONS
*/
void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget()
{
//get selected radioButton
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// disable radiobuttons
if (m_Controls->boxFiberMinLength->isEnabled())
m_Controls->boxFiberMinLength->setEnabled(false);
if (m_Controls->labelFiberMinLength->isEnabled())
m_Controls->labelFiberMinLength->setEnabled(false);
if (m_Controls->boxFiberMaxLength->isEnabled())
m_Controls->boxFiberMaxLength->setEnabled(false);
if (m_Controls->labelFiberMaxLength->isEnabled())
m_Controls->labelFiberMaxLength->setEnabled(false);
//enable radiobuttons
if (!m_Controls->labelFibersTotal->isEnabled())
m_Controls->labelFibersTotal->setEnabled(true);
if (!m_Controls->boxFiberNumbers->isEnabled())
m_Controls->boxFiberNumbers->setEnabled(true);
if (!m_Controls->labelDistrRadius->isEnabled())
m_Controls->labelDistrRadius->setEnabled(true);
if (!m_Controls->boxDistributionRadius->isEnabled())
m_Controls->boxDistributionRadius->setEnabled(true);
} else {
// disable radiobuttons
if (m_Controls->labelDistrRadius->isEnabled())
m_Controls->labelDistrRadius->setEnabled(false);
if (m_Controls->boxDistributionRadius->isEnabled())
m_Controls->boxDistributionRadius->setEnabled(false);
//enable radiobuttons
if (!m_Controls->labelFibersTotal->isEnabled())
m_Controls->labelFibersTotal->setEnabled(true);
if (!m_Controls->boxFiberNumbers->isEnabled())
m_Controls->boxFiberNumbers->setEnabled(true);
if (!m_Controls->boxFiberMinLength->isEnabled())
m_Controls->boxFiberMinLength->setEnabled(true);
if (!m_Controls->labelFiberMinLength->isEnabled())
m_Controls->labelFiberMinLength->setEnabled(true);
if (!m_Controls->boxFiberMaxLength->isEnabled())
m_Controls->boxFiberMaxLength->setEnabled(true);
if (!m_Controls->labelFiberMaxLength->isEnabled())
m_Controls->labelFiberMaxLength->setEnabled(true);
}
}
void QmitkFiberBundleDeveloperView::DoGenerateFibers()
{
// GET SELECTED FIBER DIRECTION
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
// vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// build polydata with random lines and fibers
// output =
GenerateVtkFibersRandom();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) {
// build polydata with XDirection fibers
//output = GenerateVtkFibersDirectionX();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) {
// build polydata with YDirection fibers
// output = GenerateVtkFibersDirectionY();
} else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) {
// build polydata with ZDirection fibers
// output = GenerateVtkFibersDirectionZ();
}
}
void QmitkFiberBundleDeveloperView::DoExtractFibers()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateExtractFibersTimer()) );
struct Package4WorkingThread ItemPackageForExtractor;
ItemPackageForExtractor.st_FBX = m_FiberBundleX;
ItemPackageForExtractor.st_Controls = m_Controls;
ItemPackageForExtractor.st_FancyGUITimer1 = localTimer;
ItemPackageForExtractor.st_host = this; //needed to access method "PutFibersToDataStorage()"
ItemPackageForExtractor.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
ItemPackageForExtractor.st_PlanarFigure = m_PlanarFigure;
//set element for thread monitoring
if (m_fiberMonitorIsOn)
ItemPackageForExtractor.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberExtractor = new QmitkFiberExtractorWorker(m_hostThread, ItemPackageForExtractor);
m_FiberExtractor->moveToThread(m_hostThread);
//connections
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberExtraction() ));
connect(m_hostThread, SIGNAL(started()), m_FiberExtractor, SLOT( run() ));
connect(m_hostThread, SIGNAL(finished()), this, SLOT( AfterThread_FiberExtraction() ));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT( AfterThread_FiberExtraction() ));
m_hostThread->start(QThread::HighestPriority) ;
}
void QmitkFiberBundleDeveloperView::UpdateExtractFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric! shall be done in beforeThreadstarted()
QString crntValue = m_Controls->infoTimerExtractFibers->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerExtractFibers->setText(QString::number(++tmpVal));
m_Controls->infoTimerExtractFibers->update();
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberExtraction()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
//m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberExtraction()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
// disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
// m_FiberExtractor->disconnect();
delete m_FiberExtractor;
m_FiberBundleNode->Modified();
m_MultiWidget->RequestUpdate();
}
void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkSmartPointer<vtkPolyData> threadOutput)
{
MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints();
//qthread mutex lock
mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(threadOutput);
mitk::DataNode::Pointer FBNode;
FBNode = mitk::DataNode::New();
FBNode->SetName("FiberBundleX");
FBNode->SetData(FB);
FBNode->SetVisibility(true);
FBNode->SetOpacity(1.0);
GetDataStorage()->Add(FBNode);
FBNode->Modified();
const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
if (tsgeo == NULL) {
/* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
} else {
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
//qthread mutex unlock
}
void QmitkFiberBundleDeveloperView::PutFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
std::vector<mitk::DataNode*> selectedNodes = GetDataManagerSelection();
for(unsigned int i = 0; i < selectedNodes.size(); i++)
{
selectedNodes[i]->SetSelected(false);
}
newNode->SetSelected(true);
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,0.0,0.0));
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true));
newNode->AddProperty( "selected", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(false) );
newNode->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
newNode->AddProperty( "planarfigure.line.width", mitk::FloatProperty::New(3.0) );
newNode->AddProperty( "planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.helperline.width", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(0.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
newNode->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(2.0));
newNode->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(2.0) );
newNode->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
newNode->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(2.0));
// figure drawn on the topmost layer / image
this->GetDataStorage()->Add(newNode);
}
/*
* Generate polydata of random fibers
*/
void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) );
struct Package4WorkingThread ItemPackageForRandomGenerator;
ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX;
ItemPackageForRandomGenerator.st_Controls = m_Controls;
ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer;
ItemPackageForRandomGenerator.st_host = this; //needed to access method "PutFibersToDataStorage()"
ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; //actual functor calling method putFibersToDataStorage
//set element for thread monitoring
if (m_fiberMonitorIsOn)
ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator);
m_GeneratorFibersRandom->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) );
connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) );
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) );
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::UpdateColorFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerColorCoding->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerColorCoding->setText(QString::number(++tmpVal));
m_Controls->infoTimerColorCoding->update();
}
void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal));
m_Controls->infoTimerGenerateFiberBundle->update();
}
void QmitkFiberBundleDeveloperView::UpdateSetFAValuesTimer()
{
// Make sure that thread has set according info-label to number! here we do not check if value is numeric!
QString crntValue = m_Controls->infoTimerSetFA->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerSetFA->setText(QString::number(++tmpVal));
m_Controls->infoTimerSetFA->update();
}
void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
//m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
// disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
delete m_GeneratorFibersRandom;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX()
{
int numOfFibers = m_Controls->boxFiberNumbers->value();
vtkSmartPointer<vtkCellArray> linesCell = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
//insert Origin point, this point has index 0 in point array
double originX = 0.0;
double originY = 0.0;
double originZ = 0.0;
//after each iteration the origin of the new fiber increases
//here you set which direction is affected.
double increaseX = 0.0;
double increaseY = 1.0;
double increaseZ = 0.0;
//walk along X axis
//length of fibers increases in each iteration
for (int i=0; i<numOfFibers; ++i) {
vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
newFiber->GetPointIds()->SetNumberOfIds(i+2);
//create starting point and add it to pointset
points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ);
//add starting point to fiber
newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1);
//insert remaining points for fiber
for (int pj=0; pj<=i ; ++pj)
{ //generate next point on X axis
points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ );
newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1);
}
linesCell->InsertNextCell(newFiber);
}
vtkSmartPointer<vtkPolyData> PDX = vtkSmartPointer<vtkPolyData>::New();
PDX->SetPoints(points);
PDX->SetLines(linesCell);
return PDX;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY()
{
vtkSmartPointer<vtkPolyData> PDY = vtkSmartPointer<vtkPolyData>::New();
//todo
return PDY;
}
vtkSmartPointer<vtkPolyData> QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ()
{
vtkSmartPointer<vtkPolyData> PDZ = vtkSmartPointer<vtkPolyData>::New();
//todo
return PDZ;
}
void QmitkFiberBundleDeveloperView::DoSetFAValues()
{
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateSetFAValuesTimer() ) );
// pack items which are needed by thread processing
struct Package4WorkingThread ItemPackageToSetFAMap;
ItemPackageToSetFAMap.st_FBX = m_FiberBundleX;
ItemPackageToSetFAMap.st_FancyGUITimer1 = localTimer;
ItemPackageToSetFAMap.st_PassedDataNode = m_FANode;
ItemPackageToSetFAMap.st_Controls = m_Controls;
if (m_fiberMonitorIsOn)
ItemPackageToSetFAMap.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberFeederFASlave = new QmitkFiberFeederFAWorker(m_hostThread, ItemPackageToSetFAMap);
m_FiberFeederFASlave->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberSetFA()) );
connect(m_hostThread, SIGNAL(started()), m_FiberFeederFASlave, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberSetFA()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberSetFA()));
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::DoSetFAMap()
{
std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
if (nodes.empty())
{
m_Controls->lineEdit_FAMap->setText("N/A");
return;
}
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
mitk::DataNode::Pointer node = *it;
if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
{
// this node is what we want
m_FANode = node;
m_Controls->lineEdit_FAMap->setText(node->GetName().c_str());
return;
}
}
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberSetFA()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberSetFA()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
//update renderer
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
//update QComboBox(dropDown menu) in view of available ColorCodings
this->DoGatherColorCodings();
delete m_FiberFeederFASlave;
}
void QmitkFiberBundleDeveloperView::DoColorFibers()
{
//
MITK_INFO << "call fibercoloring in fiberBundleX";
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT( UpdateColorFibersTimer() ) );
// pack items which are needed by thread processing
struct Package4WorkingThread ItemPackageForFiberColoring;
ItemPackageForFiberColoring.st_FBX = m_FiberBundleX;
ItemPackageForFiberColoring.st_PassedDataNode = m_FiberBundleNode;
ItemPackageForFiberColoring.st_FancyGUITimer1 = localTimer;
ItemPackageForFiberColoring.st_Controls = m_Controls; //needed to catch up some selections and set options in GUI
if (m_fiberMonitorIsOn)
ItemPackageForFiberColoring.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
m_FiberColoringSlave = new QmitkFiberColoringWorker(m_hostThread, ItemPackageForFiberColoring);
m_FiberColoringSlave->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_FiberColorCoding()) );
connect(m_hostThread, SIGNAL(started()), m_FiberColoringSlave, SLOT(run()) );
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_FiberColorCoding()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_FiberColorCoding()));
m_hostThread->start(QThread::LowestPriority);
}
void QmitkFiberBundleDeveloperView::BeforeThread_FiberColorCoding()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
}
}
void QmitkFiberBundleDeveloperView::AfterThread_FiberColorCoding()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
//update renderer
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
//update QComboBox(dropDown menu) in view of available ColorCodings
this->DoGatherColorCodings();
delete m_FiberColoringSlave;
}
void QmitkFiberBundleDeveloperView::DoGatherColorCodings()
{
QStringList fbxColorCodings = m_FiberBundleX->GetAvailableColorCodings();
//update dropDown Menu
//remove all items from menu
m_suppressSignal = true;
int ddItems = m_Controls->ddAvailableColorcodings->count();
for(int i=ddItems-1; i>=0; i--)
{ //note, after each item remove, index in QComboBox is updated. sending signal: index changed
m_Controls->ddAvailableColorcodings->removeItem(i);
}
//fill new data into menu
m_Controls->ddAvailableColorcodings->addItems(fbxColorCodings);
m_Controls->ddAvailableColorcodings->addItem(m_FiberBundleX->COLORCODING_CUSTOM);
//highlight current colorcoding
QString cc = m_FiberBundleX->GetCurrentColorCoding();
MITK_INFO << cc.toStdString().c_str() << " is at idx: " << m_Controls->ddAvailableColorcodings->findText(cc);
m_Controls->ddAvailableColorcodings->setCurrentIndex( m_Controls->ddAvailableColorcodings->findText(cc) );
m_Controls->ddAvailableColorcodings->update();
m_suppressSignal = false;
}
void QmitkFiberBundleDeveloperView::SetCurrentColorCoding(int idx)
{
if(!m_suppressSignal){
QString selectedColorCoding = m_Controls->ddAvailableColorcodings->itemText(idx);
m_FiberBundleX->SetColorCoding(selectedColorCoding.toStdString().c_str() ); //QString to char
// update rendering
m_FiberBundleNode->Modified();
m_MultiWidget->ForceImmediateUpdate();
}
}
/* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK ===
* WITHOUT, the rendering mechanism will ignore objects without valid Geometry
* for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */
mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK()
{
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// generate origin
mitk::Point3D origin;
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
geometry->SetOrigin(origin);
// generate spacing
float spacing[3] = {1,1,1};
geometry->SetSpacing(spacing);
// generate identity transform-matrix
vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();
geometry->SetIndexToWorldTransformByVtkMatrix(m);
// generate boundingbox
// for an usable bounding-box use gui parameters to estimate the boundingbox
float bounds[] = {500, 500, 500, -500, -500, -500};
// GET SELECTED FIBER DIRECTION
QString fibDirection; //stores the object_name of selected radiobutton
QVector<QRadioButton*>::const_iterator i;
for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i)
{
QRadioButton* rdbtn = *i;
if (rdbtn->isChecked())
fibDirection = rdbtn->objectName();
}
if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) {
// use information about distribution parameter to calculate bounding box
int distrRadius = m_Controls->boxDistributionRadius->value();
bounds[0] = distrRadius;
bounds[1] = distrRadius;
bounds[2] = distrRadius;
bounds[3] = -distrRadius;
bounds[4] = -distrRadius;
bounds[5] = -distrRadius;
} else {
// so far only X,Y,Z directions are available
MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***";
int maxFibLength = m_Controls->boxFiberMaxLength->value();
bounds[0] = maxFibLength;
bounds[1] = maxFibLength;
bounds[2] = maxFibLength;
bounds[3] = -maxFibLength;
bounds[4] = -maxFibLength;
bounds[5] = -maxFibLength;
}
geometry->SetFloatBounds(bounds);
geometry->SetImageGeometry(true); //??
return geometry;
}
void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer()
{
//MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL
QString crntValue = m_Controls->infoTimerGenerateFiberIds->text();
int tmpVal = crntValue.toInt();
m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal));
m_Controls->infoTimerGenerateFiberIds->update();
}
/* Initialie ID dataset in FiberBundleX */
void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs()
{
/* ===== TIMER CONFIGURATIONS for visual effect ======
* start and stop is called in Thread */
QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough
localTimer->setInterval( 10 );
connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) );
// pack items which are needed by thread processing
struct Package4WorkingThread FiberIdPackage;
FiberIdPackage.st_FBX = m_FiberBundleX;
FiberIdPackage.st_FancyGUITimer1 = localTimer;
FiberIdPackage.st_Controls = m_Controls;
//set element for thread monitoring
if (m_fiberMonitorIsOn)
FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker;
if (m_threadInProgress)
return; //maybe popup window saying, working thread still in progress...pls wait
// THREAD CONFIGURATION
m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage);
m_FiberIDGenerator->moveToThread(m_hostThread);
connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) );
connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run()));
connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate()));
connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate()));
m_hostThread->start(QThread::LowestPriority);
// m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal()));
}
void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate()
{
m_threadInProgress = true;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingStarted();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED);
}
}
void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate()
{
m_threadInProgress = false;
if (m_fiberMonitorIsOn){
m_fiberThreadMonitorWorker->threadForFiberProcessingFinished();
m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE);
}
disconnect(m_hostThread, 0, 0, 0);
m_hostThread->disconnect();
delete m_FiberIDGenerator;
}
void QmitkFiberBundleDeveloperView::ResetFiberInfoWidget()
{
if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) {
m_Controls->infoAnalyseNumOfFibers->setText("-");
m_Controls->infoAnalyseNumOfPoints->setText("-");
m_Controls->infoAnalyseNumOfFibers->setEnabled(false);
}
}
void QmitkFiberBundleDeveloperView::FeedFiberInfoWidget()
{
if (!m_Controls->infoAnalyseNumOfFibers->isEnabled())
m_Controls->infoAnalyseNumOfFibers->setEnabled(true);
QString numOfFibers;
numOfFibers.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfLines() );
QString numOfPoints;
numOfPoints.setNum( m_FiberBundleX->GetFiberPolyData()->GetNumberOfPoints() );
m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers );
m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints );
}
void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx)
{
// show/reset items of selected toolbox page FiberInfo
if (m_Controls->page_FiberInfo->isVisible())
{
if (m_FiberBundleX != NULL) {
FeedFiberInfoWidget();
} else {
//if infolables are disabled: return
//else set info back to - and set label and info to disabled
ResetFiberInfoWidget();
}
}
// show/reset items of selected toolbox page FiberProcessing
if (m_Controls->page_FiberProcessing->isVisible())
{
if (m_FiberBundleX.IsNotNull() && m_PlanarFigure.IsNotNull() )
{
//show fiber extraction button
m_Controls->buttonExtractFibers->setEnabled(true);
} else {
m_Controls->buttonExtractFibers->setEnabled(false);
}
if (m_FiberBundleX.IsNotNull())
{
//show button colorCoding
m_Controls->buttonColorFibers->setEnabled(true);
m_Controls->ddAvailableColorcodings->setEnabled(true);
m_Controls->buttonGenerateFiberIds->setEnabled(true);
// m_Controls->buttonSMFibers->setEnabled(true);
// m_Controls->buttonVtkDecimatePro->setEnabled(true);
// m_Controls->buttonVtkSmoothPD->setEnabled(true);
// m_Controls->buttonGenerateTubes->setEnabled(true);
} else {
m_Controls->buttonColorFibers->setEnabled(false);
m_Controls->ddAvailableColorcodings->setEnabled(false);
m_Controls->buttonGenerateFiberIds->setEnabled(false);
m_Controls->buttonSMFibers->setEnabled(false);
m_Controls->buttonVtkDecimatePro->setEnabled(false);
m_Controls->buttonVtkSmoothPD->setEnabled(false);
m_Controls->buttonGenerateTubes->setEnabled(true);
}
}
}
void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator()
{
// ==== FIBER PROCESSING ELEMENTS and ALL ELEMENTS WHICH NEED A FBX DATANODE======
// m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); moved to selectionChangedToolBox
SelectionChangedToolBox(-1); //set gui elements with respect to active tab, widget, etc. -1 has no effect
}
void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus)
{
//check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor
//if not then put node to datastorage
//if checkStatus is 1 then start qtimer using fading in starting text in datanode
//if checkStatus is 0 then fade out dataNode using qtimer
if (checkStatus)
{
m_fiberMonitorIsOn = true;
// Generate Node hosting thread information
mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New();
FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK());
m_MonitorNode = mitk::DataNode::New();
m_MonitorNode->SetName("FBX_threadMonitor");
m_MonitorNode->SetData(FBXThreadMonitor);
m_MonitorNode->SetVisibility(true);
m_MonitorNode->SetOpacity(1.0);
GetDataStorage()->Add(m_MonitorNode);
//following code is needed for rendering text in mitk! without geometry nothing is rendered
const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry();
if (tsgeo == NULL) {
/* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
} else {
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
//__GEOMETRY FOR THREADMONITOR GENERATED
/* ====== initialize thread for managing fiberThread information ========= */
m_monitorThread = new QThread;
// the package needs datastorage, MonitorDatanode, standardmultiwidget,
struct Package4WorkingThread ItemPackageForThreadMonitor;
ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage();
ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode;
ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget;
ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor;
m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor);
m_fiberThreadMonitorWorker->moveToThread(m_monitorThread);
connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) );
m_monitorThread->start(QThread::LowestPriority);
m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-)
} else {
m_fiberMonitorIsOn = false;
m_monitorThread->quit();
//think about outsourcing following lines to quit / terminate slot of thread
GetDataStorage()->Remove(m_MonitorNode);
GetDataStorage()->Modified();
m_MultiWidget->RequestUpdate(); //necessary??
}
}
void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
/* OnSelectionChanged is registered to SelectionService, therefore no need to
implement SelectionService Listener explicitly */
void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
{
if (nodes.empty())
return;
/* ==== reset everyhing related to FiberBundleX ======
* - variable m_FiberBundleX
* - visualization of analysed fiberbundle
*/
m_FiberBundleNode = NULL;
m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations
m_PlanarFigure = NULL;
ResetFiberInfoWidget();
//timer reset only when no thread is in progress
if (!m_threadInProgress) {
m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to -
m_Controls->infoTimerGenerateFiberBundle->setText( "-" );
m_Controls->infoTimerColorCoding->setText( "-" );
}
//====================================================
for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
mitk::DataNode::Pointer node = *it;
/* CHECKPOINT: FIBERBUNDLE*/
if( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
{
m_FiberBundleNode = node;
m_FiberBundleX = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
if (m_FiberBundleX.IsNull()){
MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n";
m_FiberBundleNode = NULL;
}
// ==== FIBERBUNDLE_INFO ELEMENTS ====
if ( m_Controls->page_FiberInfo->isVisible() )
FeedFiberInfoWidget();
// enable FiberBundleX related Gui Elements, such as buttons etc.
this->FBXDependendGUIElementsConfigurator();
this->DoGatherColorCodings();
}
/* CHECKPOINT: PLANARFIGURE */
else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarFigure*>(node->GetData()) )
{
m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
MITK_INFO << "PF selected";
if (m_PlanarFigure.IsNull())
MITK_INFO << "========ATTENTION=========\n unable to load selected Planarfigure to FiberBundleDeveloper-plugin \n";
}
}
//update gui elements depending on given nodes
FBXDependendGUIElementsConfigurator(); //every gui element which needs a FBX for processing is disabled
}
void QmitkFiberBundleDeveloperView::ActionDrawEllipseTriggered()
{
// bool checked = m_Controls->m_CircleButton->isChecked();
mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
this->PutFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
MITK_INFO << "PlanarCircle created ...";
mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDefaultDataStorage()->GetAll();
mitk::DataNode* node = 0;
mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
mitk::PlanarFigure* figureP = 0;
for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
; it++)
{
node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
figureP = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if(figureP)
{
figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", node);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
}
}
}
void QmitkFiberBundleDeveloperView::Activated()
{
MITK_INFO << "FB DevelopersV ACTIVATED()";
}
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
index 2ebc92ca6a..f0b21f3a28 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkDTIAtlasAppIntroPart.cpp
@@ -1,293 +1,293 @@
/*===================================================================
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 "QmitkDTIAtlasAppIntroPart.h"
#include "mitkNodePredicateDataType.h"
#include <berryIWorkbenchWindow.h>
#include <berryIWorkbench.h>
#include <berryIWorkbenchPage.h>
#include <berryIPerspectiveRegistry.h>
#include <berryWorkbenchPreferenceConstants.h>
#include <berryIPreferences.h>
#include <berryIEditorReference.h>
#include <mitkLogMacros.h>
#include <QLabel>
#include <QMessageBox>
#include <QtCore/qconfig.h>
#ifdef QT_WEBKIT
#include <QWebView>
#include <QWebPage>
#endif
#include <QString>
#include <QStringList>
#include <QRegExp>
#include <QChar>
#include <QByteArray>
#include <QDesktopServices>
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "QmitkDTIAtlasAppApplicationPlugin.h"
#include "mitkDataStorageEditorInput.h"
#include "mitkBaseDataIOFactory.h"
#include "mitkSceneIO.h"
#include "mitkProgressBar.h"
#include "mitkDataNodeFactory.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateProperty.h"
QmitkDTIAtlasAppIntroPart::QmitkDTIAtlasAppIntroPart()
: m_Controls(NULL)
{
berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
workbenchPrefs->Flush();
}
QmitkDTIAtlasAppIntroPart::~QmitkDTIAtlasAppIntroPart()
{
// if the workbench is not closing (that means, welcome screen was closed explicitly), set "Show_intro" false
if (!this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
{
berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, false);
workbenchPrefs->Flush();
}
else
{
berry::IPreferences::Pointer workbenchPrefs = QmitkDTIAtlasAppApplicationPlugin::GetDefault()->GetPreferencesService()->GetSystemPreferences();
workbenchPrefs->PutBool(berry::WorkbenchPreferenceConstants::SHOW_INTRO, true);
workbenchPrefs->Flush();
}
// if workbench is not closing (Just welcome screen closing), open last used perspective
if (this->GetIntroSite()->GetPage()->GetPerspective()->GetId()
== "org.mitk.dtiatlasapp.perspectives.welcome" && !this->GetIntroSite()->GetPage()->GetWorkbenchWindow()->GetWorkbench()->IsClosing())
{
berry::IPerspectiveDescriptor::Pointer perspective = this->GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->GetPerspectiveRegistry()->FindPerspectiveWithId("org.mitk.dtiatlasapp.perspectives.dtiatlasapp");
if (perspective)
{
this->GetIntroSite()->GetPage()->SetPerspective(perspective);
}
}
}
void QmitkDTIAtlasAppIntroPart::CreateQtPartControl(QWidget* parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkWelcomeScreenViewControls;
m_Controls->setupUi(parent);
#ifdef QT_WEBKIT
// create a QWebView as well as a QWebPage and QWebFrame within the QWebview
m_view = new QWebView(parent);
m_view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
QUrl urlQtResource(QString("qrc:/org.mitk.gui.qt.welcomescreen/mitkdtiatlasappwelcomeview.html"), QUrl::TolerantMode );
m_view->load( urlQtResource );
// adds the webview as a widget
parent->layout()->addWidget(m_view);
this->CreateConnections();
#else
parent->layout()->addWidget(new QLabel("<h1><center>Please install Qt with the WebKit option to see cool pictures!</center></h1>"));
#endif
}
}
#ifdef QT_WEBKIT
void QmitkDTIAtlasAppIntroPart::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_view->page()), SIGNAL(linkClicked(const QUrl& )), this, SLOT(DelegateMeTo(const QUrl& )) );
}
}
void QmitkDTIAtlasAppIntroPart::DelegateMeTo(const QUrl& showMeNext)
{
QString scheme = showMeNext.scheme();
QByteArray urlHostname = showMeNext.encodedHost();
QByteArray urlPath = showMeNext.encodedPath();
QByteArray dataset = showMeNext.encodedQueryItemValue("dataset");
QByteArray clear = showMeNext.encodedQueryItemValue("clear");
if (scheme.isEmpty()) MITK_INFO << " empty scheme of the to be delegated link" ;
// if the scheme is set to mitk, it is to be tested which action should be applied
if (scheme.contains(QString("mitk")) )
{
if(urlPath.isEmpty() ) MITK_INFO << " mitk path is empty " ;
// searching for the perspective keyword within the host name
if(urlHostname.contains(QByteArray("perspectives")) )
{
// the simplified method removes every whitespace
// ( whitespace means any character for which the standard C++ isspace() method returns true)
urlPath = urlPath.simplified();
QString tmpPerspectiveId(urlPath.data());
tmpPerspectiveId.replace(QString("/"), QString("") );
std::string perspectiveId = tmpPerspectiveId.toStdString();
// is working fine as long as the perspective id is valid, if not the application crashes
GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
mitk::DataStorageEditorInput::Pointer editorInput;
editorInput = new mitk::DataStorageEditorInput();
berry::IEditorPart::Pointer editor = GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
QmitkStdMultiWidgetEditor::Pointer multiWidgetEditor;
mitk::DataStorage::Pointer dataStorage;
if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNull())
{
editorInput = new mitk::DataStorageEditorInput();
dataStorage = editorInput->GetDataStorageReference()->GetDataStorage();
}
else
{
multiWidgetEditor = editor.Cast<QmitkStdMultiWidgetEditor>();
multiWidgetEditor->GetStdMultiWidget()->RequestUpdate();
dataStorage = multiWidgetEditor->GetEditorInput().Cast<mitk::DataStorageEditorInput>()->GetDataStorageReference()->GetDataStorage();
}
bool dsmodified = false;
QString *fileName = new QString(dataset.data());
if ( fileName->right(5) == ".mitk" )
{
mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
bool clearDataStorageFirst(false);
QString *sClear = new QString(clear.data());
if ( sClear->right(4) == "true" )
{
clearDataStorageFirst = true;
}
mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
dataStorage = sceneIO->LoadScene( fileName->toLocal8Bit().constData(), dataStorage, clearDataStorageFirst );
dsmodified = true;
mitk::ProgressBar::GetInstance()->Progress(2);
}
else
{
mitk::DataNodeFactory::Pointer nodeReader = mitk::DataNodeFactory::New();
try
{
nodeReader->SetFileName(fileName->toLocal8Bit().data());
nodeReader->Update();
for ( unsigned int i = 0 ; i < nodeReader->GetNumberOfOutputs( ); ++i )
{
mitk::DataNode::Pointer node;
node = nodeReader->GetOutput(i);
if ( node->GetData() != NULL )
{
dataStorage->Add(node);
dsmodified = true;
}
}
}
catch(...)
{
MITK_INFO << "Could not open file!";
}
}
if(dataStorage.IsNotNull() && dsmodified)
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = dataStorage->GetSubset(pred);
if(rs->Size() > 0)
{
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
+ mitk::TimeGeometry::Pointer bounds = dataStorage->ComputeBoundingGeometry3D(rs);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
}
}
// searching for the load
if(urlHostname.contains(QByteArray("perspectives")) )
{
// the simplified method removes every whitespace
// ( whitespace means any character for which the standard C++ isspace() method returns true)
urlPath = urlPath.simplified();
QString tmpPerspectiveId(urlPath.data());
tmpPerspectiveId.replace(QString("/"), QString("") );
std::string perspectiveId = tmpPerspectiveId.toStdString();
// is working fine as long as the perspective id is valid, if not the application crashes
GetIntroSite()->GetWorkbenchWindow()->GetWorkbench()->ShowPerspective(perspectiveId, GetIntroSite()->GetWorkbenchWindow() );
mitk::DataStorageEditorInput::Pointer editorInput;
editorInput = new mitk::DataStorageEditorInput();
GetIntroSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID);
}
else
{
MITK_INFO << "Unkown mitk action keyword (see documentation for mitk links)" ;
}
}
// if the scheme is set to http, by default no action is performed, if an external webpage needs to be
// shown it should be implemented below
else if (scheme.contains(QString("http")) )
{
QDesktopServices::openUrl(showMeNext);
// m_view->load( ) ;
}
else if(scheme.contains("qrc"))
{
m_view->load(showMeNext);
}
}
#endif
void QmitkDTIAtlasAppIntroPart::StandbyStateChanged(bool standby)
{
}
void QmitkDTIAtlasAppIntroPart::SetFocus()
{
}
diff --git a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
index 01252b65e9..421a7eb3c1 100644
--- a/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
+++ b/Plugins/org.mitk.gui.qt.dtiatlasapp/src/internal/QmitkNavigationButtonsView.cpp
@@ -1,945 +1,945 @@
/*===================================================================
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 "QmitkNavigationButtonsView.h"
#include "mitkNodePredicateDataType.h"
#include "mitkDataNodeObject.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkResliceMethodProperty.h"
#include "mitkRenderingManager.h"
#include "mitkDiffusionImage.h"
#include "mitkPlanarFigure.h"
#include "mitkFiberBundle.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFiberBundleInteractor.h"
#include "mitkPlanarFigureInteractor.h"
#include "mitkGlobalInteraction.h"
#include "mitkGeometry2D.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "berryISelectionService.h"
#include "berryConstants.h"
#include "berryPlatformUI.h"
#include "itkRGBAPixel.h"
#include "itkTractsToProbabilityImageFilter.h"
#include "qwidgetaction.h"
#include "qcolordialog.h"
const std::string QmitkNavigationButtonsView::VIEW_ID = "org.mitk.views.NavigationButtonsview";
using namespace berry;
QmitkNavigationButtonsView::QmitkNavigationButtonsView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
{
}
QmitkNavigationButtonsView::QmitkNavigationButtonsView(const QmitkNavigationButtonsView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkNavigationButtonsView::~QmitkNavigationButtonsView()
{
this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
}
void QmitkNavigationButtonsView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationButtonsViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkNavigationButtonsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkNavigationButtonsView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkNavigationButtonsView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
}
}
void QmitkNavigationButtonsView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkNavigationButtonsView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
int QmitkNavigationButtonsView::GetSizeFlags(bool width)
{
if(!width)
{
return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
}
else
{
return 0;
}
}
int QmitkNavigationButtonsView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
{
if(width==false)
{
return m_FoundSingleOdfImage ? 120 : 80;
}
else
{
return preferredResult;
}
}
mitk::DataStorage::SetOfObjects::Pointer
QmitkNavigationButtonsView::ActiveSet(std::string classname)
{
if (m_CurrentSelection)
{
mitk::DataStorage::SetOfObjects::Pointer set =
mitk::DataStorage::SetOfObjects::New();
int at = 0;
for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
i != m_CurrentSelection->End();
++i)
{
if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
{
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
{
set->InsertElement(at++, node);
}
}
}
return set;
}
return 0;
}
void QmitkNavigationButtonsView::SetBoolProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, bool value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetBoolProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetIntProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, int value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetFloatProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, float value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetFloatProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetLevelWindowProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::LevelWindow value)
{
if(set.IsNotNull())
{
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), prop);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::SetEnumProp(
mitk::DataStorage::SetOfObjects::Pointer set,
std::string name, mitk::EnumerationProperty::Pointer value)
{
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetProperty(name.c_str(), value);
++itemiter;
}
}
}
void QmitkNavigationButtonsView::DisplayIndexChanged(int dispIndex)
{
QString label = "Channel %1";
label = label.arg(dispIndex);
m_Controls->label_channel->setText(label);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
if(set.IsNotNull())
{
mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
while ( itemiter != itemiterend )
{
(*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
++itemiter;
}
//m_MultiWidget->RequestUpdate();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkNavigationButtonsView::Reinit()
{
if (m_CurrentSelection)
{
mitk::DataNodeObject::Pointer nodeObj =
m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
mitk::DataNode::Pointer node = nodeObj->GetDataNode();
mitk::BaseData::Pointer basedata = node->GetData();
if (basedata.IsNotNull())
{
mitk::RenderingManager::GetInstance()->InitializeViews(
- basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
+ basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void QmitkNavigationButtonsView::TextIntON()
{
if(m_TexIsOn)
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
}
else
{
m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("DiffusionImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("TensorImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("QBallImage");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
set = ActiveSet("Image");
SetBoolProp(set,"texture interpolation", !m_TexIsOn);
m_TexIsOn = !m_TexIsOn;
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::VisibleOdfsON_S()
{
if(m_GlyIsOn_S)
{
m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyOFF_S);
}
else
{
m_Controls->m_VisibleOdfsON_S->setIcon(*m_IconGlyON_S);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_S", !m_GlyIsOn_S);
m_GlyIsOn_S = !m_GlyIsOn_S;
VisibleOdfsON(0);
}
void QmitkNavigationButtonsView::VisibleOdfsON_T()
{
if(m_GlyIsOn_T)
{
m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyOFF_T);
}
else
{
m_Controls->m_VisibleOdfsON_T->setIcon(*m_IconGlyON_T);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_T", !m_GlyIsOn_T);
m_GlyIsOn_T = !m_GlyIsOn_T;
VisibleOdfsON(1);
}
void QmitkNavigationButtonsView::VisibleOdfsON_C()
{
if(m_GlyIsOn_C)
{
m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyOFF_C);
}
else
{
m_Controls->m_VisibleOdfsON_C->setIcon(*m_IconGlyON_C);
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
set = ActiveSet("TensorImage");
SetBoolProp(set,"VisibleOdfs_C", !m_GlyIsOn_C);
m_GlyIsOn_C = !m_GlyIsOn_C;
VisibleOdfsON(2);
}
void QmitkNavigationButtonsView::VisibleOdfsON(int view)
{
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ShowMaxNumberChanged()
{
int maxNr = m_Controls->m_ShowMaxNumber->value();
if ( maxNr < 1 )
{
m_Controls->m_ShowMaxNumber->setValue( 1 );
maxNr = 1;
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
set = ActiveSet("TensorImage");
SetIntProp(set,"ShowMaxNumber", maxNr);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::NormalizationDropdownChanged(int normDropdown)
{
typedef mitk::OdfNormalizationMethodProperty PropType;
PropType::Pointer normMeth = PropType::New();
switch(normDropdown)
{
case 0:
normMeth->SetNormalizationToMinMax();
break;
case 1:
normMeth->SetNormalizationToMax();
break;
case 2:
normMeth->SetNormalizationToNone();
break;
case 3:
normMeth->SetNormalizationToGlobalMax();
break;
default:
normMeth->SetNormalizationToMinMax();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"Normalization", normMeth.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ScalingFactorChanged(double scalingFactor)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"Scaling", scalingFactor);
set = ActiveSet("TensorImage");
SetFloatProp(set,"Scaling", scalingFactor);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::AdditionalScaling(int additionalScaling)
{
typedef mitk::OdfScaleByProperty PropType;
PropType::Pointer scaleBy = PropType::New();
switch(additionalScaling)
{
case 0:
scaleBy->SetScaleByNothing();
break;
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);
break;
#endif
default:
scaleBy->SetScaleByNothing();
}
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
set = ActiveSet("TensorImage");
SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::IndexParam1Changed(double param1)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam1", param1);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam1", param1);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::IndexParam2Changed(double param2)
{
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetFloatProp(set,"IndexParam2", param2);
set = ActiveSet("TensorImage");
SetFloatProp(set,"IndexParam2", param2);
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::OpacityChanged(double l, double u)
{
mitk::LevelWindow olw;
olw.SetRangeMinMax(l*255, u*255);
mitk::DataStorage::SetOfObjects::Pointer set =
ActiveSet("QBallImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("TensorImage");
SetLevelWindowProp(set,"opaclevelwindow", olw);
set = ActiveSet("Image");
SetLevelWindowProp(set,"opaclevelwindow", olw);
m_Controls->m_OpacityMinFaLabel->setText(QString::number(l,'f',2) + " : " + QString::number(u,'f',2));
if(m_MultiWidget)
m_MultiWidget->RequestUpdate();
}
void QmitkNavigationButtonsView::ScalingCheckbox()
{
m_Controls->m_ScalingFrame->setVisible(
m_Controls->m_ScalingCheckbox->isChecked());
}
void QmitkNavigationButtonsView::BundleRepresentationWire()
{
if(m_SelectedNode)
{
int width = m_Controls->m_LineWidth->value();
m_SelectedNode->SetProperty("LineWidth",mitk::IntProperty::New(width));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(15));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(18));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(1));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(2));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(4));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::BundleRepresentationTube()
{
if(m_SelectedNode)
{
float radius = m_Controls->m_TubeRadius->value() / 100.0;
m_SelectedNode->SetProperty("TubeRadius",mitk::FloatProperty::New(radius));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(17));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(13));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(16));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::BundleRepresentationColor()
{
if(m_SelectedNode)
{
QColor color = QColorDialog::getColor();
m_Controls->m_Color->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_Color->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty("color",mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(14));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(3));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
m_SelectedNode->SetProperty("ColorCoding",mitk::IntProperty::New(0));
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
}
void QmitkNavigationButtonsView::PlanarFigureFocus()
{
if(m_SelectedNode)
{
mitk::PlanarFigure* _PlanarFigure = 0;
_PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
if (_PlanarFigure)
{
QmitkRenderWindow* selectedRenderWindow = 0;
bool PlanarFigureInitializedWindow = false;
QmitkRenderWindow* RenderWindow1 =
this->GetActiveStdMultiWidget()->GetRenderWindow1();
if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
{
selectedRenderWindow = RenderWindow1;
}
QmitkRenderWindow* RenderWindow2 =
this->GetActiveStdMultiWidget()->GetRenderWindow2();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow2->GetRenderer()))
{
selectedRenderWindow = RenderWindow2;
}
QmitkRenderWindow* RenderWindow3 =
this->GetActiveStdMultiWidget()->GetRenderWindow3();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow3->GetRenderer()))
{
selectedRenderWindow = RenderWindow3;
}
QmitkRenderWindow* RenderWindow4 =
this->GetActiveStdMultiWidget()->GetRenderWindow4();
if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
"PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
RenderWindow4->GetRenderer()))
{
selectedRenderWindow = RenderWindow4;
}
const mitk::PlaneGeometry
* _PlaneGeometry =
dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry1 =
RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane1 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry2 =
RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane2 =
dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
mitk::Geometry2D::ConstPointer worldGeometry3 =
RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
mitk::PlaneGeometry::ConstPointer _Plane3 =
dynamic_cast<const mitk::PlaneGeometry*>( 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 = RenderWindow1;
}
else
{
if(ang2 < ang3)
{
selectedRenderWindow = RenderWindow2;
}
else
{
selectedRenderWindow = RenderWindow3;
}
}
// make node visible
if (selectedRenderWindow)
{
mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
centerP, _PlaneGeometry->GetNormal());
selectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
centerP);
}
}
// set interactor for new node (if not already set)
mitk::PlanarFigureInteractor::Pointer figureInteractor
= dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetInteractor());
if(figureInteractor.IsNull())
figureInteractor = mitk::PlanarFigureInteractor::New("PlanarFigureInteractor", m_SelectedNode);
mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
}
}
void QmitkNavigationButtonsView::SetInteractor()
{
typedef std::vector<mitk::DataNode*> 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<mitk::DataNode*>(*it);
bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
if(bundle)
{
bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(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 QmitkNavigationButtonsView::PFWidth(int w)
{
double width = w/10.0;
m_SelectedNode->SetProperty("planarfigure.line.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.outline.width", mitk::FloatProperty::New(width) );
m_SelectedNode->SetProperty("planarfigure.helperline.width", mitk::FloatProperty::New(width) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
QString label = "Width %1";
label = label.arg(width);
m_Controls->label_pfwidth->setText(label);
}
void QmitkNavigationButtonsView::PFColor()
{
QColor color = QColorDialog::getColor();
m_Controls->m_PFColor->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
m_SelectedNode->SetProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
m_SelectedNode->SetProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0) );
// m_SelectedNode->SetProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
// m_SelectedNode->SetProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0) );
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkNavigationButtonsView::PFColor3D()
{
QColor color = QColorDialog::getColor();
m_Controls->m_PFColor3D->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color.red()));
styleSheet.append(",");
styleSheet.append(QString::number(color.green()));
styleSheet.append(",");
styleSheet.append(QString::number(color.blue()));
styleSheet.append(")");
m_Controls->m_PFColor3D->setStyleSheet(styleSheet);
m_SelectedNode->SetProperty( "color", mitk::ColorProperty::New(color.red()/255.0, color.green()/255.0, color.blue()/255.0));
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkNavigationButtonsView::Heatmap()
{
if(m_SelectedNode)
{
mitk::FiberBundle* bundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
if(!bundle)
return;
///////////////////////////////
// Generate unsigned char Image
typedef unsigned char OutPixType2;
// run generator
typedef itk::Image< float, 3 > WMPImageType;
typedef itk::TractsToProbabilityImageFilter<WMPImageType,
OutPixType2> ImageGeneratorType2;
ImageGeneratorType2::Pointer generator = ImageGeneratorType2::New();
//generator->SetInput(NULL);
generator->SetFiberBundle(bundle);
generator->SetInvertImage(false);
generator->SetUpsamplingFactor(2);
generator->SetBinaryEnvelope(false);
generator->Update();
// get result
typedef itk::Image<OutPixType2,3> OutType2;
OutType2::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img2 = mitk::Image::New();
img2->InitializeByItk(outImg.GetPointer());
img2->SetVolume(outImg->GetBufferPointer());
// to datastorage
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img2);
QString name(m_SelectedNode->GetName().c_str());
name += "_heatmap";
node->SetName(name.toStdString());
node->SetVisibility(true);
GetDataStorage()->Add(node);
}
}
void QmitkNavigationButtonsView::LineWidthChanged(int w)
{
m_SelectedNode->SetIntProperty("LineWidth", w);
QString label = "Width %1";
label = label.arg(w);
m_Controls->label_linewidth->setText(label);
}
void QmitkNavigationButtonsView::TubeRadiusChanged(int r)
{
m_SelectedNode->SetFloatProperty("TubeRadius", (float) r / 100.0);
QString label = "Radius %1";
label = label.arg(r / 100.0);
m_Controls->label_tuberadius->setText(label);
}
void QmitkNavigationButtonsView::Welcome()
{
berry::PlatformUI::GetWorkbench()->GetIntroManager()->ShowIntro(
GetSite()->GetWorkbenchWindow(), false);
}
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
index d819524251..88f58189cb 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/simpleexample/QmitkSimpleExampleView.cpp
@@ -1,305 +1,305 @@
/*===================================================================
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 "QmitkSimpleExampleView.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include <QMessageBox>
#include <mitkMovieGenerator.h>
#include "mitkNodePredicateProperty.h"
#include "mitkNodePredicateNot.h"
#include "mitkProperties.h"
#include <QmitkStepperAdapter.h>
#include <QFileDialog>
#include <QFileInfo>
#include <QDir>
#include <vtkRenderWindow.h>
#include "vtkImageWriter.h"
#include "vtkPNGWriter.h"
#include "vtkJPEGWriter.h"
#include "vtkRenderLargeImage.h"
const std::string QmitkSimpleExampleView::VIEW_ID = "org.mitk.views.simpleexample";
QmitkSimpleExampleView::QmitkSimpleExampleView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL),
m_NavigatorsInitialized(false)
{
}
QmitkSimpleExampleView::QmitkSimpleExampleView(const QmitkSimpleExampleView& other)
{
Q_UNUSED(other)
throw std::runtime_error("Copy constructor not implemented");
}
QmitkSimpleExampleView::~QmitkSimpleExampleView()
{
}
void QmitkSimpleExampleView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkSimpleExampleViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkSimpleExampleView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
new QmitkStepperAdapter(m_Controls->sliceNavigatorAxial, m_MultiWidget->mitkWidget1->GetSliceNavigationController()->GetSlice(), "sliceNavigatorAxialFromSimpleExample");
new QmitkStepperAdapter(m_Controls->sliceNavigatorSagittal, m_MultiWidget->mitkWidget2->GetSliceNavigationController()->GetSlice(), "sliceNavigatorSagittalFromSimpleExample");
new QmitkStepperAdapter(m_Controls->sliceNavigatorFrontal, m_MultiWidget->mitkWidget3->GetSliceNavigationController()->GetSlice(), "sliceNavigatorFrontalFromSimpleExample");
new QmitkStepperAdapter(m_Controls->sliceNavigatorTime, m_MultiWidget->GetTimeNavigationController()->GetTime(), "sliceNavigatorTimeFromSimpleExample");
new QmitkStepperAdapter(m_Controls->movieNavigatorTime, m_MultiWidget->GetTimeNavigationController()->GetTime(), "movieNavigatorTimeFromSimpleExample");
}
void QmitkSimpleExampleView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkSimpleExampleView::CreateConnections()
{
if ( m_Controls )
{
connect(m_Controls->stereoSelect, SIGNAL(activated(int)), this, SLOT(stereoSelectionChanged(int)) );
connect(m_Controls->reInitializeNavigatorsButton, SIGNAL(clicked()), this, SLOT(initNavigators()) );
connect(m_Controls->genMovieButton, SIGNAL(clicked()), this, SLOT(generateMovie()) );
connect(m_Controls->m_RenderWindow1Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow1Clicked()) );
connect(m_Controls->m_RenderWindow2Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow2Clicked()) );
connect(m_Controls->m_RenderWindow3Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow3Clicked()) );
connect(m_Controls->m_RenderWindow4Button, SIGNAL(clicked()), this, SLOT(OnRenderWindow4Clicked()) );
connect(m_Controls->m_TakeScreenshotBtn, SIGNAL(clicked()), this, SLOT(OnTakeScreenshot()) );
connect(m_Controls->m_TakeHighResScreenShotBtn, SIGNAL(clicked()), this, SLOT(OnTakeHighResolutionScreenshot()) );
}
}
void QmitkSimpleExampleView::Activated()
{
QmitkFunctionality::Activated();
}
void QmitkSimpleExampleView::Deactivated()
{
QmitkFunctionality::Deactivated();
}
void QmitkSimpleExampleView::initNavigators()
{
/* get all nodes that have not set "includeInBoundingBox" to false */
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
/* calculate bounding geometry of these nodes */
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs);
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs);
/* initialize the views to the bounding geometry */
m_NavigatorsInitialized = mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
//m_NavigatorsInitialized = mitk::RenderingManager::GetInstance()->InitializeViews(GetDefaultDataStorage());
}
void QmitkSimpleExampleView::generateMovie()
{
QmitkRenderWindow* movieRenderWindow = GetMovieRenderWindow();
//mitk::Stepper::Pointer stepper = multiWidget->mitkWidget1->GetSliceNavigationController()->GetSlice();
mitk::Stepper::Pointer stepper = movieRenderWindow->GetSliceNavigationController()->GetSlice();
mitk::MovieGenerator::Pointer movieGenerator = mitk::MovieGenerator::New();
if (movieGenerator.IsNotNull()) {
movieGenerator->SetStepper( stepper );
movieGenerator->SetRenderer( mitk::BaseRenderer::GetInstance(movieRenderWindow->GetRenderWindow()) );
QString movieFileName = QFileDialog::getSaveFileName(0, "Choose a file name", QString(), "Movie (*.avi)");
if (!movieFileName.isEmpty()) {
movieGenerator->SetFileName( movieFileName.toStdString().c_str() );
movieGenerator->WriteMovie();
}
}
}
void QmitkSimpleExampleView::stereoSelectionChanged( int id )
{
/* From vtkRenderWindow.h tells us about stereo rendering:
Set/Get what type of stereo rendering to use. CrystalEyes mode uses frame-sequential capabilities available in OpenGL to drive LCD shutter glasses and stereo projectors. RedBlue mode is a simple type of stereo for use with red-blue glasses. Anaglyph mode is a superset of RedBlue mode, but the color output channels can be configured using the AnaglyphColorMask and the color of the original image can be (somewhat maintained using AnaglyphColorSaturation; the default colors for Anaglyph mode is red-cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. StereoLeft and StereoRight modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.
*/
vtkRenderWindow * vtkrenderwindow = m_MultiWidget->mitkWidget4->GetRenderWindow();
// note: foreground vtkRenderers (at least the department logo renderer) produce errors in stereoscopic visualization.
// Therefore, we disable the logo visualization during stereo rendering.
switch(id)
{
case 0:
vtkrenderwindow->StereoRenderOff();
break;
case 1:
vtkrenderwindow->SetStereoTypeToRedBlue();
vtkrenderwindow->StereoRenderOn();
m_MultiWidget->DisableDepartmentLogo();
break;
case 2:
vtkrenderwindow->SetStereoTypeToDresden();
vtkrenderwindow->StereoRenderOn();
m_MultiWidget->DisableDepartmentLogo();
break;
}
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget4->GetRenderWindow())->SetMapperID(2);
m_MultiWidget->RequestUpdate();
}
QmitkRenderWindow* QmitkSimpleExampleView::GetMovieRenderWindow()
{
//check which RenderWindow should be used to generate the movie, e.g. which button is toggled
if(m_Controls->m_RenderWindow1Button->isChecked())
{
return m_MultiWidget->mitkWidget1;
}
else if(m_Controls->m_RenderWindow2Button->isChecked())
{
return m_MultiWidget->mitkWidget2;
}
else if(m_Controls->m_RenderWindow3Button->isChecked())
{
return m_MultiWidget->mitkWidget3;
}
else if(m_Controls->m_RenderWindow4Button->isChecked())
{
return m_MultiWidget->mitkWidget4;
}
else //as default take widget1
{
return m_MultiWidget->mitkWidget1;
}
}
void QmitkSimpleExampleView::OnRenderWindow1Clicked()
{
m_Controls->m_RenderWindow2Button->setChecked(false);
m_Controls->m_RenderWindow3Button->setChecked(false);
m_Controls->m_RenderWindow4Button->setChecked(false);
}
void QmitkSimpleExampleView::OnRenderWindow2Clicked()
{
m_Controls->m_RenderWindow1Button->setChecked(false);
m_Controls->m_RenderWindow3Button->setChecked(false);
m_Controls->m_RenderWindow4Button->setChecked(false);
}
void QmitkSimpleExampleView::OnRenderWindow3Clicked()
{
m_Controls->m_RenderWindow2Button->setChecked(false);
m_Controls->m_RenderWindow1Button->setChecked(false);
m_Controls->m_RenderWindow4Button->setChecked(false);
}
void QmitkSimpleExampleView::OnRenderWindow4Clicked()
{
m_Controls->m_RenderWindow2Button->setChecked(false);
m_Controls->m_RenderWindow3Button->setChecked(false);
m_Controls->m_RenderWindow1Button->setChecked(false);
}
void QmitkSimpleExampleView::OnTakeHighResolutionScreenshot()
{
QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
// only works correctly for 3D RenderWindow
vtkRenderer* renderer = m_MultiWidget->mitkWidget4->GetRenderer()->GetVtkRenderer();
if (renderer == NULL)
return;
this->TakeScreenshot(renderer, 4, fileName);
}
void QmitkSimpleExampleView::OnTakeScreenshot()
{
QString fileName = QFileDialog::getSaveFileName(NULL, "Save screenshot to...", QDir::currentPath(), "JPEG file (*.jpg);;PNG file (*.png)");
QmitkRenderWindow* renWin = this->GetMovieRenderWindow();
if (renWin == NULL)
return;
vtkRenderer* renderer = renWin->GetRenderer()->GetVtkRenderer();
if (renderer == NULL)
return;
this->TakeScreenshot(renderer, 1, fileName);
}
void QmitkSimpleExampleView::TakeScreenshot(vtkRenderer* renderer, unsigned int magnificationFactor, QString fileName)
{
if ((renderer == NULL) ||(magnificationFactor < 1) || fileName.isEmpty())
return;
bool doubleBuffering( renderer->GetRenderWindow()->GetDoubleBuffer() );
renderer->GetRenderWindow()->DoubleBufferOff();
vtkImageWriter* fileWriter;
QFileInfo fi(fileName);
QString suffix = fi.suffix();
if (suffix.compare("png", Qt::CaseInsensitive) == 0)
{
fileWriter = vtkPNGWriter::New();
}
else // default is jpeg
{
vtkJPEGWriter* w = vtkJPEGWriter::New();
w->SetQuality(100);
w->ProgressiveOff();
fileWriter = w;
}
vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
magnifier->SetInput(renderer);
magnifier->SetMagnification(magnificationFactor);
//magnifier->Update();
fileWriter->SetInput(magnifier->GetOutput());
fileWriter->SetFileName(fileName.toLatin1());
// vtkRenderLargeImage has problems with different layers, therefore we have to
// temporarily deactivate all other layers.
// we set the background to white, because it is nicer than black...
double oldBackground[3];
renderer->GetBackground(oldBackground);
double white[] = {1.0, 1.0, 1.0};
renderer->SetBackground(white);
m_MultiWidget->DisableColoredRectangles();
m_MultiWidget->DisableDepartmentLogo();
m_MultiWidget->DisableGradientBackground();
fileWriter->Write();
fileWriter->Delete();
m_MultiWidget->EnableColoredRectangles();
m_MultiWidget->EnableDepartmentLogo();
m_MultiWidget->EnableGradientBackground();
renderer->SetBackground(oldBackground);
renderer->GetRenderWindow()->SetDoubleBuffer(doubleBuffering);
}
diff --git a/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp b/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
index 58ceaaa61f..9b92b43e5f 100644
--- a/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
+++ b/Plugins/org.mitk.gui.qt.examples/src/internal/viewinitialization/QmitkViewInitializationView.cpp
@@ -1,193 +1,193 @@
/*===================================================================
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 "QmitkViewInitializationView.h"
#include "mitkNodePredicateDataType.h"
#include "QmitkDataStorageComboBox.h"
#include "QmitkStdMultiWidget.h"
#include "mitkFocusManager.h"
#include "mitkGlobalInteraction.h"
#include "itkCommand.h"
#include <QMessageBox>
const std::string QmitkViewInitializationView::VIEW_ID = "org.mitk.views.viewinitialization";
QmitkViewInitializationView::QmitkViewInitializationView()
: QmitkFunctionality(),
m_Controls(NULL),
m_MultiWidget(NULL)
{
m_CommandTag = 0;
}
QmitkViewInitializationView::~QmitkViewInitializationView()
{
}
void QmitkViewInitializationView::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkViewInitializationViewControls;
m_Controls->setupUi(parent);
this->CreateConnections();
}
}
void QmitkViewInitializationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkViewInitializationView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkViewInitializationView::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->pbApply), SIGNAL(clicked()),(QObject*) this, SLOT(OnApply()) );
connect( (QObject*)(m_Controls->pbReset), SIGNAL(clicked()),(QObject*) this, SLOT(OnResetAll()) );
}
}
void QmitkViewInitializationView::Activated()
{
//init render window selector (List Widget)
this->InitRenderWindowSelector();
QmitkFunctionality::Activated();
}
void QmitkViewInitializationView::Deactivated()
{
mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
fm->RemoveObserver(m_CommandTag);
QmitkFunctionality::Deactivated();
}
void QmitkViewInitializationView::OnApply()
{
mitk::SliceNavigationController::ViewDirection viewDirection( mitk::SliceNavigationController::Axial );
if( m_Controls->rbAxial->isChecked() )
viewDirection = mitk::SliceNavigationController::Axial;
else if( m_Controls->rbFrontal->isChecked())
viewDirection = mitk::SliceNavigationController::Frontal;
else if( m_Controls->rbSagittal->isChecked() )
viewDirection = mitk::SliceNavigationController::Sagittal;
vtkRenderWindow* renderwindow = this->GetSelectedRenderWindow();
if(renderwindow != NULL)
{
mitk::BaseRenderer::GetInstance(renderwindow)->GetSliceNavigationController()->Update(viewDirection,
m_Controls->cbTop->isChecked(),
m_Controls->cbFrontSide->isChecked(),
m_Controls->cbRotated->isChecked()
);
mitk::BaseRenderer::GetInstance(renderwindow)->GetDisplayGeometry()->Fit();
}
}
void QmitkViewInitializationView::OnResetAll()
{
/* calculate bounding geometry of these nodes */
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDefaultDataStorage()->ComputeBoundingGeometry3D();
+ mitk::TimeGeometry::Pointer bounds = this->GetDefaultDataStorage()->ComputeBoundingGeometry3D();
/* initialize the views to the bounding geometry */
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
vtkRenderWindow* QmitkViewInitializationView::GetSelectedRenderWindow()
{
int selectedItem = m_Controls->m_lbRenderWindows->currentRow();
int itemNumber = 0;
mitk::BaseRenderer::BaseRendererMapType::iterator mapit;
for(mapit = mitk::BaseRenderer::baseRendererMap.begin();
mapit != mitk::BaseRenderer::baseRendererMap.end();
mapit++, itemNumber++)
{
if(itemNumber==selectedItem)
break;
}
if(itemNumber==selectedItem)
{
return (*mapit).first;
}
return NULL;
}
void QmitkViewInitializationView::InitRenderWindowSelector()
{
itk::SimpleMemberCommand<QmitkViewInitializationView>::Pointer updateRendererListCommand =
itk::SimpleMemberCommand<QmitkViewInitializationView>::New();
updateRendererListCommand->SetCallbackFunction( this, &QmitkViewInitializationView::UpdateRendererList );
mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
m_CommandTag = fm->AddObserver(mitk::FocusEvent(), updateRendererListCommand);
this->UpdateRendererList();
}
void QmitkViewInitializationView::UpdateRendererList()
{
vtkRenderWindow* focusedRenderWindow = NULL;
mitk::FocusManager* fm = mitk::GlobalInteraction::GetInstance()->GetFocusManager();
mitk::BaseRenderer::ConstPointer br = fm->GetFocused();
if (br.IsNotNull())
{
focusedRenderWindow = br->GetRenderWindow();
}
int selectedItem = -1;
int itemNumber = 0;
m_Controls->m_lbRenderWindows->clear();
for(mitk::BaseRenderer::BaseRendererMapType::iterator mapit = mitk::BaseRenderer::baseRendererMap.begin();
mapit != mitk::BaseRenderer::baseRendererMap.end(); mapit++, itemNumber++)
{
if( (*mapit).second->GetName())
{
m_Controls->m_lbRenderWindows->addItem(QString((*mapit).second->GetName()));
if(focusedRenderWindow==(*mapit).first)
selectedItem = itemNumber;
}
}
if (selectedItem>=0)
{
m_Controls->m_lbRenderWindows->setCurrentRow(selectedItem);
}
else
{
m_Controls->m_lbRenderWindows->clearSelection();
}
}
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
index 045e1e6027..9b3ef30af7 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView.cpp
@@ -1,1042 +1,1042 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkIGTTrackingLabView.h"
#include "QmitkStdMultiWidget.h"
#include <QmitkNDIConfigurationWidget.h>
#include <QmitkFiducialRegistrationWidget.h>
#include <QmitkUpdateTimerWidget.h>
#include <QmitkToolSelectionWidget.h>
#include <QmitkToolTrackingStatusWidget.h>
#include <mitkCone.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <vtkConeSource.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkAppendPolyData.h>
// Qt
#include <QMessageBox>
#include <QIcon>
const std::string QmitkIGTTrackingLabView::VIEW_ID = "org.mitk.views.igttrackinglab";
QmitkIGTTrackingLabView::QmitkIGTTrackingLabView()
: QmitkFunctionality()
,m_Source(NULL)
,m_FiducialRegistrationFilter(NULL)
,m_PermanentRegistrationFilter(NULL)
,m_Visualizer(NULL)
,m_VirtualView(NULL)
,m_PSRecordingPointSet(NULL)
,m_RegistrationTrackingFiducialsName("Tracking Fiducials")
,m_RegistrationImageFiducialsName("Image Fiducials")
,m_PointSetRecordingDataNodeName("Recorded Points")
,m_PointSetRecording(false)
,m_ImageFiducialsDataNode(NULL)
,m_TrackerFiducialsDataNode(NULL)
,m_PermanentRegistrationSourcePoints(NULL)
{
//[-1;0;0] for WOLF_6D bronchoscope
m_DirectionOfProjectionVector[0]=0;
m_DirectionOfProjectionVector[1]=0;
m_DirectionOfProjectionVector[2]=-1;}
QmitkIGTTrackingLabView::~QmitkIGTTrackingLabView()
{
}
void QmitkIGTTrackingLabView::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
m_ToolBox = new QToolBox(parent);
m_Controls.m_VBoxLayout->addWidget(m_ToolBox);
this->CreateBundleWidgets( parent );
this->CreateConnections();
}
void QmitkIGTTrackingLabView::CreateBundleWidgets( QWidget* parent )
{
// configuration widget
m_NDIConfigWidget = new QmitkNDIConfigurationWidget(parent);
m_NDIConfigWidget->SetToolTypes(QStringList () << "Instrument" << "Fiducial" << "Skinmarker" << "Unknown" );
m_ToolBox->addItem(m_NDIConfigWidget, "Configuration");
// registration widget
m_RegistrationWidget = new QmitkFiducialRegistrationWidget(parent);
m_RegistrationWidget->HideStaticRegistrationRadioButton(true);
m_RegistrationWidget->HideContinousRegistrationRadioButton(true);
m_RegistrationWidget->HideUseICPRegistrationCheckbox(true);
m_ToolBox->addItem(m_RegistrationWidget, "Initial Registration");
// permanent registration widget
m_PermanentRegistrationToolSelectionWidget = new QmitkToolSelectionWidget(parent);
m_PermanentRegistrationToolSelectionWidget->SetCheckboxtText("Use this tool for permanent registration");
m_ToolBox->addItem(m_PermanentRegistrationToolSelectionWidget, "Permanent Registration");
// pointset recording
m_ToolBox->addItem(this->CreatePointSetRecordingWidget(parent), "PointSet Recording");
// virtual view
m_VirtualViewToolSelectionWidget = new QmitkToolSelectionWidget(parent);
m_VirtualViewToolSelectionWidget->SetCheckboxtText("Enable Virtual Camera");
m_ToolBox->addItem(m_VirtualViewToolSelectionWidget, "Virtual Camera");
// tracking status
m_ToolStatusWidget = new QmitkToolTrackingStatusWidget( parent );
m_Controls.m_VBoxLayout->addWidget(m_ToolStatusWidget);
// update timer
m_RenderingTimerWidget = new QmitkUpdateTimerWidget( parent );
m_RenderingTimerWidget->SetPurposeLabelText(QString("Navigation"));
m_RenderingTimerWidget->SetTimerInterval( 50 ); // set rendering timer at 20Hz (updating every 50msec)
m_Controls.m_VBoxLayout->addWidget(m_RenderingTimerWidget);
}
void QmitkIGTTrackingLabView::CreateConnections()
{
connect( m_ToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnToolBoxCurrentChanged(int)) );
//connect( m_NDIConfigWidget, SIGNAL(Connected()), m_RenderingTimerWidget, SLOT(EnableWidget()) );
connect( m_NDIConfigWidget, SIGNAL(Disconnected()), this, SLOT(OnTrackerDisconnected()) );
connect( m_NDIConfigWidget, SIGNAL(Connected()), this, SLOT(OnSetupNavigation()) );
connect( m_NDIConfigWidget, SIGNAL(SignalToolNameChanged(int, QString)), this, SLOT(OnChangeToolName(int, QString)) );
connect( m_NDIConfigWidget, SIGNAL(SignalLoadTool(int, mitk::DataNode::Pointer)), this, SLOT(OnToolLoaded(int, mitk::DataNode::Pointer)) );
connect( m_NDIConfigWidget, SIGNAL(ToolsAdded(QStringList)), this, SLOT(OnToolsAdded(QStringList)) );
connect( m_NDIConfigWidget, SIGNAL(RepresentationChanged( int ,mitk::Surface::Pointer )), this, SLOT(ChangeToolRepresentation( int, mitk::Surface::Pointer )));
connect( m_RegistrationWidget, SIGNAL(AddedTrackingFiducial()), this, SLOT(OnAddRegistrationTrackingFiducial()) );
connect( m_RegistrationWidget, SIGNAL(PerformFiducialRegistration()), this, SLOT(OnRegisterFiducials()) );
connect( m_RenderingTimerWidget, SIGNAL(Started()), this, SLOT(OnStartNavigation()) );
connect( m_RenderingTimerWidget, SIGNAL(Stopped()), this, SLOT(OnStopNavigation()) );
connect( m_VirtualViewToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnVirtualCamera(int, bool)));
connect( m_PermanentRegistrationToolSelectionWidget, SIGNAL(SignalUseTool(int, bool)), this, SLOT(OnPermanentRegistration(int, bool)) );
}
void QmitkIGTTrackingLabView::OnAddRegistrationTrackingFiducial()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage(); // check if DataStorage available
if(ds == NULL)
throw std::invalid_argument("DataStorage is not available");
if (m_FiducialRegistrationFilter.IsNull())
{
std::string message( "IGT Pipeline is not ready. Please 'Start Navigation' before adding points");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
if (m_FiducialRegistrationFilter->GetNumberOfOutputs() < 1 || m_FiducialRegistrationFilter->GetNumberOfInputs() < 1)
{
std::string message("There are no tracking instruments! Please add an instrument first!");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
if (m_FiducialRegistrationFilter->GetInput()->IsDataValid() == false)
{
std::string message("instrument can currently not be tracked. Please make sure that the instrument is visible to the tracker");
QMessageBox::warning(NULL, "Adding Fiducials not possible", message.c_str());
return;
}
mitk::NavigationData::Pointer nd = m_Source->GetOutput(0);
if( nd.IsNull() || !nd->IsDataValid())
QMessageBox::warning( 0, "Invalid tracking data", "Navigation data is not available or invalid!", QMessageBox::Ok );
// in case the tracker fiducials datanode has been renamed or removed
//if(trackerFiducialsPS.IsNull())
//{
// mitk::DataNode::Pointer trackerFiducialsDN = mitk::DataNode::New();
// trackerFiducialsDN->SetName(m_RegistrationTrackingFiducialsName);
// trackerFiducialsPS = mitk::PointSet::New();
// trackerFiducialsDN->SetData(trackerFiducialsPS);
// m_RegistrationWidget->SetTrackerFiducialsNode(trackerFiducialsDN);
//}
if(m_TrackerFiducialsDataNode.IsNotNull() && m_TrackerFiducialsDataNode->GetData() != NULL)
{
mitk::PointSet::Pointer ps = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
ps->InsertPoint(ps->GetSize(), nd->GetPosition());
}
else
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker Fiducials. Adding fiducial not possible!");
}
void QmitkIGTTrackingLabView::OnSetupNavigation()
{
if(m_Source.IsNotNull())
if(m_Source->IsTracking())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access DataStorage. Navigation not possible");
return;
}
// Building up the filter pipeline
try
{
this->SetupIGTPipeline();
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline: %1").arg(e.what()));
this->DestroyIGTPipeline(); // destroy the pipeline if building is incomplete
return;
}
catch(...)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Error while building the IGT-Pipeline"));
this->DestroyIGTPipeline();
return;
}
}
void QmitkIGTTrackingLabView::SetupIGTPipeline()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage(); // check if DataStorage is available
if(ds == NULL)
throw std::invalid_argument("DataStorage is not available");
mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker(); // get current tracker from configuration widget
if(tracker.IsNull()) // check if tracker is valid
throw std::invalid_argument("tracking device is NULL!");
m_Source = mitk::TrackingDeviceSource::New(); // create new source for the IGT-Pipeline
m_Source->SetTrackingDevice(tracker); // set the found tracker from the configuration widget to the source
this->InitializeFilters(); // initialize all needed filters
if(m_NDIConfigWidget->GetTracker()->GetType() == mitk::NDIAurora)
{
for (unsigned int i=0; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_FiducialRegistrationFilter->SetInput(i, m_Source->GetOutput(i)); // set input for registration filter
m_Visualizer->SetInput(i, m_FiducialRegistrationFilter->GetOutput(i)); // set input for visualization filter
}
for(unsigned int i= 0; i < m_Visualizer->GetNumberOfOutputs(); ++i)
{
const char* toolName = tracker->GetTool(i)->GetToolName();
mitk::DataNode::Pointer representation = this->CreateInstrumentVisualization(this->GetDefaultDataStorage(), toolName);
m_PSRecToolSelectionComboBox->addItem(QString(toolName));
m_PermanentRegistrationToolSelectionWidget->AddToolName(QString(toolName));
m_VirtualViewToolSelectionWidget->AddToolName(QString(toolName));
m_Visualizer->SetRepresentationObject(i, representation->GetData());
}
if(m_Source->GetTrackingDevice()->GetToolCount() > 0)
m_RenderingTimerWidget->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
this->GlobalReinit();
}
// this->CreateInstrumentVisualization(ds, tracker);//create for each single connected ND a corresponding 3D representation
}
void QmitkIGTTrackingLabView::InitializeFilters()
{
//1. Fiducial Registration Filters
m_FiducialRegistrationFilter = mitk::NavigationDataLandmarkTransformFilter::New(); // filter used for initial fiducial registration
//2. Visualization Filter
m_Visualizer = mitk::NavigationDataObjectVisualizationFilter::New(); // filter to display NavigationData
m_PermanentRegistrationFilter = mitk::NavigationDataLandmarkTransformFilter::New();
//3. Virtual Camera
m_VirtualView = mitk::CameraVisualization::New(); // filter to update the vtk camera according to the reference navigation data
m_VirtualView->SetRenderer(mitk::BaseRenderer::GetInstance(this->GetActiveStdMultiWidget()->mitkWidget4->GetRenderWindow()));
mitk::Vector3D viewUpInToolCoordinatesVector;
viewUpInToolCoordinatesVector[0]=1;
viewUpInToolCoordinatesVector[1]=0;
viewUpInToolCoordinatesVector[2]=0;
m_VirtualView->SetDirectionOfProjectionInToolCoordinates(m_DirectionOfProjectionVector);
m_VirtualView->SetFocalLength(5000.0);
m_VirtualView->SetViewUpInToolCoordinates(viewUpInToolCoordinatesVector);
}
void QmitkIGTTrackingLabView::OnRegisterFiducials( )
{
/* filter pipeline can only be build, if source and visualization filters exist */
if (m_Source.IsNull() || m_Visualizer.IsNull() || m_FiducialRegistrationFilter.IsNull())
{
QMessageBox::warning(NULL, "Registration not possible", "Navigation pipeline is not ready. Please (re)start the navigation");
return;
}
if (m_Source->IsTracking() == false)
{
QMessageBox::warning(NULL, "Registration not possible", "Registration only possible if navigation is running");
return;
}
/* retrieve fiducials from data storage */
mitk::DataStorage* ds = this->GetDefaultDataStorage();
mitk::PointSet::Pointer imageFiducials = dynamic_cast<mitk::PointSet*>(m_ImageFiducialsDataNode->GetData());
mitk::PointSet::Pointer trackerFiducials = dynamic_cast<mitk::PointSet*>(m_TrackerFiducialsDataNode->GetData());
//mitk::PointSet::Pointer imageFiducials = ds->GetNamedObject<mitk::PointSet>(m_RegistrationImageFiducialsName.c_str());
//mitk::PointSet::Pointer trackerFiducials = ds->GetNamedObject<mitk::PointSet>(m_RegistrationTrackingFiducialsName.c_str());
if (imageFiducials.IsNull() || trackerFiducials.IsNull())
{
QMessageBox::warning(NULL, "Registration not possible", "Fiducial data objects not found. \n"
"Please set 3 or more fiducials in the image and with the tracking system.\n\n"
"Registration is not possible");
return;
}
unsigned int minFiducialCount = 3; // \Todo: move to view option
if ((imageFiducials->GetSize() < minFiducialCount) || (trackerFiducials->GetSize() < minFiducialCount) || (imageFiducials->GetSize() != trackerFiducials->GetSize()))
{
QMessageBox::warning(NULL, "Registration not possible", QString("Not enough fiducial pairs found. At least %1 fiducial must "
"exist for the image and the tracking system respectively.\n"
"Currently, %2 fiducials exist for the image, %3 fiducials exist for the tracking system").arg(minFiducialCount).arg(imageFiducials->GetSize()).arg(trackerFiducials->GetSize()));
return;
}
/* now we have two PointSets with enough points to perform a landmark based transform */
if ( m_RegistrationWidget->UseICPIsChecked() )
m_FiducialRegistrationFilter->UseICPInitializationOn();
else
m_FiducialRegistrationFilter->UseICPInitializationOff();
m_FiducialRegistrationFilter->SetSourceLandmarks(trackerFiducials);
m_FiducialRegistrationFilter->SetTargetLandmarks(imageFiducials);
if (m_FiducialRegistrationFilter.IsNotNull() && m_FiducialRegistrationFilter->IsInitialized()) // update registration quality display
{
QString registrationQuality = QString("%0: FRE is %1mm (Std.Dev. %2), \n"
"RMS error is %3mm,\n"
"Minimum registration error (best fitting landmark) is %4mm,\n"
"Maximum registration error (worst fitting landmark) is %5mm.")
.arg("Fiducial Registration")
.arg(m_FiducialRegistrationFilter->GetFRE(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetFREStdDev(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetRMSError(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetMinError(), 3, 'f', 3)
.arg(m_FiducialRegistrationFilter->GetMaxError(), 3, 'f', 3);
m_RegistrationWidget->SetQualityDisplayText(registrationQuality);
}
//trackerFiducials->Clear();
//this->GlobalReinit();
}
void QmitkIGTTrackingLabView::OnTrackerDisconnected()
{
m_RenderingTimerWidget->DisableWidget();
this->DestroyInstrumentVisualization(this->GetDefaultDataStorage(), m_NDIConfigWidget->GetTracker());
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateInstrumentVisualization(mitk::DataStorage* ds, const char* toolName)
{
//const char* toolName = tracker->GetTool(i)->GetToolName();
mitk::DataNode::Pointer toolRepresentationNode;
toolRepresentationNode = ds->GetNamedNode(toolName); // check if node with same name already exists
if(toolRepresentationNode.IsNotNull())
ds->Remove(toolRepresentationNode); // remove old node with same name
toolRepresentationNode = this->CreateConeRepresentation( toolName );
// m_Visualizer->SetRepresentationObject(i, toolRepresentationNode->GetData());
ds->Add(toolRepresentationNode); // adds node to data storage
return toolRepresentationNode;
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateConeRepresentation( const char* label )
{
//new data
mitk::Cone::Pointer activeToolData = mitk::Cone::New();
vtkConeSource* vtkData = vtkConeSource::New();
vtkData->SetRadius(7.5);
vtkData->SetHeight(15.0);
vtkData->SetDirection(m_DirectionOfProjectionVector[0],m_DirectionOfProjectionVector[1],m_DirectionOfProjectionVector[2]);
vtkData->SetCenter(0.0, 0.0, 7.5);
vtkData->SetResolution(20);
vtkData->CappingOn();
vtkData->Update();
activeToolData->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
//new node
mitk::DataNode::Pointer coneNode = mitk::DataNode::New();
coneNode->SetData(activeToolData);
coneNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New( label ));
coneNode->GetPropertyList()->SetProperty("layer", mitk::IntProperty::New(0));
coneNode->GetPropertyList()->SetProperty("visible", mitk::BoolProperty::New(true));
coneNode->SetColor(1.0,0.0,0.0);
coneNode->SetOpacity(0.85);
coneNode->Modified();
return coneNode;
}
void QmitkIGTTrackingLabView::DestroyIGTPipeline()
{
if(m_Source.IsNotNull())
{
m_Source->StopTracking();
m_Source->Disconnect();
m_Source = NULL;
}
m_FiducialRegistrationFilter = NULL;
m_PermanentRegistrationFilter = NULL;
m_Visualizer = NULL;
m_VirtualView = NULL;
}
void QmitkIGTTrackingLabView::OnChangeToolName(int index, QString name)
{
if(m_Source.IsNull())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL,"DataStorage Access Error", "Could not access DataStorage. Tool Name can not be changed!");
return;
}
mitk::NavigationData::Pointer tempND = m_Source->GetOutput(index);
if(tempND.IsNull())
return;
const char* oldName = tempND->GetName();
mitk::DataNode::Pointer tempNode = ds->GetNamedNode(oldName);
if(tempNode.IsNotNull())
{
tempNode->SetName(name.toStdString().c_str());
tempND->SetName(name.toStdString().c_str());
}
else
QMessageBox::warning(NULL, "Rename Tool Error", "Couldn't find the corresponding tool for changing it's name!");
}
void QmitkIGTTrackingLabView::OnToolLoaded(int index, mitk::DataNode::Pointer toolNode)
{
if(m_Source.IsNull() || m_Visualizer.IsNull())
return;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL,"DataStorage Access Error", "Could not access DataStorage. Loaded tool representation can not be shown!");
return;
}
mitk::NavigationData::Pointer tempND = m_Source->GetOutput(index);
if(tempND.IsNull())
return;
// try to find DataNode for tool in DataStorage
const char* toolName = tempND->GetName();
mitk::DataNode::Pointer tempNode = ds->GetNamedNode(toolName);
if(tempNode.IsNull())
{
tempNode = mitk::DataNode::New(); // create new node, if none was found
ds->Add(tempNode);
}
tempNode->SetData(toolNode->GetData());
tempNode->SetName(toolNode->GetName());
m_PSRecToolSelectionComboBox->setItemText(index,toolNode->GetName().c_str());
m_VirtualViewToolSelectionWidget->ChangeToolName(index, QString(toolNode->GetName().c_str()));
m_PermanentRegistrationToolSelectionWidget->ChangeToolName(index, QString(toolNode->GetName().c_str()));
m_Visualizer->SetRepresentationObject(index, tempNode->GetData());
m_Visualizer->Update();
tempNode->Modified();
this->GlobalReinit();
}
void QmitkIGTTrackingLabView::OnStartNavigation()
{
if(m_Source.IsNull())
{
QMessageBox::warning(NULL, "IGTTrackingLab: Error", "can not access tracking source. Navigation not possible");
return;
}
if(!m_Source->IsTracking())
{
m_Source->StartTracking();
try
{
m_RenderingTimerWidget->GetTimerInterval();
this->StartContinuousUpdate(); // start tracker with set interval
for(unsigned int i = 0; i < m_Source->GetNumberOfOutputs(); i++) // add navigation data to bundle widgets
{
m_ToolStatusWidget->AddNavigationData(dynamic_cast<mitk::NavigationData*>(m_Source->GetOutputs().at(i).GetPointer()));
}
m_ToolStatusWidget->ShowStatusLabels(); // show status for every tool if ND is valid or not
//m_IGTPlayerWidget->setEnabled(true);
}
catch(...)
{
//m_IGTPlayerWidget->setDisabled(true);
this->StopContinuousUpdate();
this->DestroyIGTPipeline();
return;
}
m_NDIConfigWidget->EnableAddToolsButton(false);
}
}
void QmitkIGTTrackingLabView::StopContinuousUpdate()
{
if (this->m_RenderingTimerWidget->GetUpdateTimer() != NULL)
{
m_RenderingTimerWidget->StopTimer();
disconnect( (QTimer*) m_RenderingTimerWidget->GetUpdateTimer(), SIGNAL(timeout()), this, SLOT(RenderScene()) ); // disconnect timer from RenderScene() method
}
if(m_PointSetRecordPushButton)
m_PointSetRecordPushButton->setDisabled(true);
}
void QmitkIGTTrackingLabView::RenderScene( )
{
try
{
if (m_Visualizer.IsNull() || this->GetActiveStdMultiWidget() == NULL)
return;
try
{
if(m_Source.IsNotNull() && m_Source->IsTracking())
m_ToolStatusWidget->Refresh();
if(m_VirtualViewToolSelectionWidget->IsSelectedToolActivated())
{
m_VirtualView->Update();
mitk::Point3D p = m_Visualizer->GetOutput(m_VirtualViewToolSelectionWidget->GetCurrentSelectedIndex())->GetPosition();
this->GetActiveStdMultiWidget()->MoveCrossToPosition(p);
}
if(m_PermanentRegistrationToolSelectionWidget->IsSelectedToolActivated() && m_PermanentRegistrationToolSelectionWidget->GetCurrentSelectedIndex() >= 0 )
{
mitk::NavigationData::Pointer permRegTool = m_Source->GetOutput((unsigned int) m_PermanentRegistrationToolSelectionWidget->GetCurrentSelectedIndex());
m_PermanentRegistrationFilter->SetSourceLandmarks(this->GetVirtualPointSetFromPosition(permRegTool));
}
if(m_PointSetRecording && m_PSRecordingPointSet.IsNotNull())
{
int size = m_PSRecordingPointSet->GetSize();
mitk::NavigationData::Pointer nd= m_Visualizer->GetOutput(m_PSRecToolSelectionComboBox->currentIndex());
if(size > 0)
{
mitk::Point3D p = m_PSRecordingPointSet->GetPoint(size-1);
if(p.EuclideanDistanceTo(nd->GetPosition()) > (double) m_PSRecordingSpinBox->value())
m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
}
else
m_PSRecordingPointSet->InsertPoint(size, nd->GetPosition());
}
}
catch(std::exception& e)
{
MITK_WARN << "Exception during QmitkIGTTrackingLab::RenderScene():" << e.what() << "\n";
}
//if(m_VirtualViewCheckBox->isChecked())
// mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
////update all Widgets
//else
m_Visualizer->Update();
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
}
catch (std::exception& e)
{
MITK_WARN << "RenderAll exception: " << e.what() << "\n";
}
catch (...)
{
MITK_WARN << "RenderAll unknown exception\n";
}
}
void QmitkIGTTrackingLabView::StartContinuousUpdate( )
{
if (m_Source.IsNull() || m_Visualizer.IsNull() )
throw std::invalid_argument("Pipeline is not set up correctly");
if (m_RenderingTimerWidget->GetUpdateTimer() == NULL)
return;
else
{
connect( (QTimer*) m_RenderingTimerWidget->GetUpdateTimer(), SIGNAL(timeout()), this, SLOT(RenderScene()) ); // connect update timer to RenderScene() method
}
if(m_PointSetRecordPushButton)
m_PointSetRecordPushButton->setEnabled(true);
}
void QmitkIGTTrackingLabView::OnStopNavigation()
{
if(m_Source.IsNull())
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "can not access tracking source. Navigation not possible");
return;
}
if(m_Source->IsTracking())
{
m_Source->StopTracking();
this->StopContinuousUpdate();
m_ToolStatusWidget->RemoveStatusLabels();
m_NDIConfigWidget->EnableAddToolsButton(true);
}
}
void QmitkIGTTrackingLabView::OnToolsAdded(QStringList toolsList)
{
if(m_Source.IsNull() || m_FiducialRegistrationFilter.IsNull() || m_Visualizer.IsNull())
return;
m_Source->UpdateOutputInformation();
unsigned int nrOfOldOutputs = m_Visualizer->GetNumberOfOutputs();
for(unsigned int i = nrOfOldOutputs; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_FiducialRegistrationFilter->SetInput(i, m_Source->GetOutput(i));
m_Visualizer->SetInput(i, m_FiducialRegistrationFilter->GetOutput(i));
}
for(unsigned int j = nrOfOldOutputs; j < m_Visualizer->GetNumberOfOutputs(); ++j)
{
mitk::DataNode::Pointer representation = this->CreateInstrumentVisualization(this->GetDefaultDataStorage(), m_Source->GetTrackingDevice()->GetTool(j)->GetToolName());
m_PSRecToolSelectionComboBox->addItem(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_PermanentRegistrationToolSelectionWidget->AddToolName(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_VirtualViewToolSelectionWidget->AddToolName(QString(m_Source->GetTrackingDevice()->GetTool(j)->GetToolName()));
m_Visualizer->SetRepresentationObject(j, representation->GetData());
}
if(m_Source->GetTrackingDevice()->GetToolCount() > 0)
m_RenderingTimerWidget->setEnabled(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
this->GlobalReinit();
//mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_ALL);
}
void QmitkIGTTrackingLabView::InitializeRegistration()
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if( ds == NULL )
return;
m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget()); // passing multiwidget to pointsetwidget
if(m_ImageFiducialsDataNode.IsNull())
{
m_ImageFiducialsDataNode = mitk::DataNode::New();
mitk::PointSet::Pointer ifPS = mitk::PointSet::New();
m_ImageFiducialsDataNode->SetData(ifPS);
mitk::Color color;
color.Set(1.0f, 0.0f, 0.0f);
m_ImageFiducialsDataNode->SetName(m_RegistrationImageFiducialsName);
m_ImageFiducialsDataNode->SetColor(color);
m_ImageFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
ds->Add(m_ImageFiducialsDataNode);
}
m_RegistrationWidget->SetMultiWidget(this->GetActiveStdMultiWidget());
m_RegistrationWidget->SetImageFiducialsNode(m_ImageFiducialsDataNode);
if(m_TrackerFiducialsDataNode.IsNull())
{
m_TrackerFiducialsDataNode = mitk::DataNode::New();
mitk::PointSet::Pointer tfPS = mitk::PointSet::New();
m_TrackerFiducialsDataNode->SetData(tfPS);
mitk::Color color;
color.Set(0.0f, 1.0f, 0.0f);
m_TrackerFiducialsDataNode->SetName(m_RegistrationTrackingFiducialsName);
m_TrackerFiducialsDataNode->SetColor(color);
m_TrackerFiducialsDataNode->SetBoolProperty( "updateDataOnRender", false );
ds->Add(m_TrackerFiducialsDataNode);
}
m_RegistrationWidget->SetTrackerFiducialsNode(m_TrackerFiducialsDataNode);
}
void QmitkIGTTrackingLabView::OnToolBoxCurrentChanged(const int index)
{
switch (index)
{
case RegistrationWidget:
this->InitializeRegistration();
break;
default:
break;
}
}
mitk::DataNode::Pointer QmitkIGTTrackingLabView::CreateRegistrationFiducialsNode( const std::string& label, const mitk::Color& color)
{
mitk::DataNode::Pointer fiducialsNode = mitk::DataNode::New();
mitk::PointSet::Pointer fiducialsPointSet = mitk::PointSet::New();
fiducialsNode->SetData(fiducialsPointSet);
fiducialsNode->SetName( label );
fiducialsNode->SetColor( color );
fiducialsNode->SetBoolProperty( "updateDataOnRender", false );
return fiducialsNode;
}
void QmitkIGTTrackingLabView::ChangeToolRepresentation( int toolID , mitk::Surface::Pointer surface )
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access DataStorage. Changing tool representation not possible!");
return;
}
mitk::TrackingDevice::Pointer tracker = m_NDIConfigWidget->GetTracker();
if(tracker.IsNull())
{
QMessageBox::warning(NULL, "IGTSurfaceTracker: Error", "Can not access Tracker. Changing tool representation not possible!");
return;
}
try
{
const char* name = tracker->GetTool(toolID)->GetToolName(); // get tool name by id
mitk::DataNode::Pointer toolNode = ds->GetNamedNode(name);
if(toolNode.IsNull())
return;
toolNode->SetData(surface); // change surface representation of node
toolNode->SetColor(0.45,0.70,0.85); //light blue like old 5D sensors
toolNode->Modified();
m_Visualizer->SetRepresentationObject( toolID, toolNode->GetData()); // updating node with changed surface back in visualizer
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
catch(std::exception& e)
{
QMessageBox::warning(NULL, QString("IGTSurfaceTracker: Error"), QString("Can not change tool representation!").arg(e.what()));
return;
}
}
QWidget* QmitkIGTTrackingLabView::CreatePointSetRecordingWidget(QWidget* parent)
{
QWidget* pointSetRecordingWidget = new QWidget(parent);
m_PSRecToolSelectionComboBox = new QComboBox(pointSetRecordingWidget);
m_PSRecordingSpinBox = new QSpinBox(pointSetRecordingWidget);
QLabel* psRecordingEpsilonDistance = new QLabel("mm (point distance)", pointSetRecordingWidget);
// the recording button
m_PointSetRecordPushButton = new QPushButton("Start PointSet Recording", pointSetRecordingWidget);
m_PointSetRecordPushButton->setDisabled(true);
m_PointSetRecordPushButton->setIcon(QIcon(":/QmitkQmitkIGTTrackingLabView/start_rec.png"));
m_PointSetRecordPushButton->setCheckable(true);
connect( m_PointSetRecordPushButton, SIGNAL(toggled(bool)), this, SLOT(OnPointSetRecording(bool)) );
// distances spin
m_PSRecordingSpinBox->setValue(1);
m_PSRecordingSpinBox->setMinimum(1);
m_PSRecordingSpinBox->setMaximum(20);
QLabel* toolSelectLabel = new QLabel("Select tool for recording:", pointSetRecordingWidget);
QGridLayout* layout = new QGridLayout(pointSetRecordingWidget);
int row = 0;
int col = 0;
layout->addWidget(toolSelectLabel,row,col++,1,1,Qt::AlignRight);
layout->addWidget(m_PSRecToolSelectionComboBox,row,col++,1,3,Qt::AlignLeft);
col +=2;
layout->addWidget(m_PSRecordingSpinBox,row,col++,1,1,Qt::AlignRight);
layout->addWidget(psRecordingEpsilonDistance, row, col++,1,1,Qt::AlignLeft);
row++;
col=4;
layout->addWidget(m_PointSetRecordPushButton,row,col++,1,2,Qt::AlignRight);
return pointSetRecordingWidget;
}
void QmitkIGTTrackingLabView::OnPointSetRecording(bool record)
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
if(ds == NULL)
return;
if(record)
{
mitk::DataNode::Pointer psRecND = ds->GetNamedNode(m_PointSetRecordingDataNodeName);
if(m_PSRecordingPointSet.IsNull() || psRecND.IsNull())
{
m_PSRecordingPointSet = NULL;
m_PSRecordingPointSet = mitk::PointSet::New();
mitk::DataNode::Pointer dn = mitk::DataNode::New();
dn->SetName(m_PointSetRecordingDataNodeName);
dn->SetColor(0.,1.,0.);
dn->SetData(m_PSRecordingPointSet);
ds->Add(dn);
}
else
m_PSRecordingPointSet->Clear();
m_PointSetRecording = true;
m_PointSetRecordPushButton->setText("Stop PointSet Recording");
m_PSRecToolSelectionComboBox->setDisabled(true);
}
else
{
m_PointSetRecording = false;
m_PointSetRecordPushButton->setText("Start PointSet Recording");
m_PSRecToolSelectionComboBox->setEnabled(true);
}
}
void QmitkIGTTrackingLabView::DestroyInstrumentVisualization(mitk::DataStorage* ds, mitk::TrackingDevice::Pointer tracker)
{
if(ds == NULL || tracker.IsNull())
return;
for(int i=0; i < tracker->GetToolCount(); ++i)
{
mitk::DataNode::Pointer dn = ds->GetNamedNode(tracker->GetTool(i)->GetToolName());
if(dn.IsNotNull())
ds->Remove(dn);
}
}
void QmitkIGTTrackingLabView::GlobalReinit()
{
// request global reiinit
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
//global reinit end
}
void QmitkIGTTrackingLabView::OnVirtualCamera(int toolNr, bool on)
{
if(m_VirtualView.IsNull() || m_FiducialRegistrationFilter.IsNull())
return;
if(on)
{
m_VirtualView->SetInput(m_FiducialRegistrationFilter->GetOutput(toolNr));
this->GetActiveStdMultiWidget()->SetWidgetPlaneModeToRotation(true);
}
else
this->GetActiveStdMultiWidget()->SetWidgetPlaneModeToSlicing(true);
}
void QmitkIGTTrackingLabView::OnPermanentRegistration(int toolID, bool on)
{
if (m_PermanentRegistrationFilter.IsNull() || m_FiducialRegistrationFilter.IsNull())
return;
if(on)
{
if(m_PermanentRegistrationSourcePoints.IsNull())
m_PermanentRegistrationSourcePoints = mitk::PointSet::New();
// interconnectiong permanent registration filter between tracking source and fiducial registration filter
for(unsigned int i=0; i < m_Source->GetNumberOfOutputs(); ++i)
{
m_PermanentRegistrationFilter->SetInput(i,m_Source->GetOutput(i));
m_FiducialRegistrationFilter->SetInput(i,m_PermanentRegistrationFilter->GetOutput(i));
}
mitk::NavigationData::Pointer nd = m_Source->GetOutput((unsigned int) toolID);
m_PermanentRegistrationFilter->SetTargetLandmarks(this->GetVirtualPointSetFromPosition(nd));
}
else
{
for(unsigned int i=0; i < m_FiducialRegistrationFilter->GetNumberOfOutputs(); ++i)
m_FiducialRegistrationFilter->SetInput(i,m_Source->GetOutput());
}
}
mitk::PointSet::Pointer QmitkIGTTrackingLabView::GetVirtualPointSetFromPosition(mitk::NavigationData::Pointer navigationData)
{
typedef itk::QuaternionRigidTransform<double> QuaternionTransformType;
mitk::NavigationData::PositionType pointA;
mitk::NavigationData::PositionType pointB;
mitk::NavigationData::PositionType pointC;
//initializing three points with position(0|0|0)
pointA.Fill(0);
pointB.Fill(0);
pointC.Fill(0);
// changing position off all points in order to make them orthogonal
pointA[0] = 1;
pointB[1] = 1;
pointC[2] = 1;
QuaternionTransformType::Pointer quatTransform = QuaternionTransformType::New();
// orientation of NavigationData from parameter
mitk::NavigationData::OrientationType quatIn = navigationData->GetOrientation();
// set orientation to quaternion transform
vnl_quaternion<double> const vnlQuatIn(quatIn.x(), quatIn.y(), quatIn.z(), quatIn.r());
quatTransform->SetRotation(vnlQuatIn);
// transform each point
pointA = quatTransform->TransformPoint(pointA);
pointB = quatTransform->TransformPoint(pointB);
pointC = quatTransform->TransformPoint(pointC);
// add position data from NavigationData parameter to each point
pointA[0] += navigationData->GetPosition()[0];
pointA[1] += navigationData->GetPosition()[1];
pointA[2] += navigationData->GetPosition()[2];
pointB[0] += navigationData->GetPosition()[0];
pointB[1] += navigationData->GetPosition()[1];
pointB[2] += navigationData->GetPosition()[2];
pointC[0] += navigationData->GetPosition()[0];
pointC[1] += navigationData->GetPosition()[1];
pointC[2] += navigationData->GetPosition()[2];
// insert points in source points pointset for the permanent registration landmark transform
m_PermanentRegistrationSourcePoints->InsertPoint(0,pointA);
m_PermanentRegistrationSourcePoints->InsertPoint(1,pointB);
m_PermanentRegistrationSourcePoints->InsertPoint(2,pointC);
return m_PermanentRegistrationSourcePoints;
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index d5e1df3008..e82ad7abcb 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,676 +1,676 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMITKIGTTrackingToolboxView.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingDeviceSourceConfigurator.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNDITrackingDevice.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
// vtk
#include <vtkSphereSource.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
{
m_TrackingTimer = new QTimer(this);
m_tracking = false;
m_logging = false;
m_loggedFrames = 0;
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi( parent );
//create connections
connect( m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()) );
connect( m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()) );
connect( m_Controls->m_Disconnect, SIGNAL(clicked()), this, SLOT(OnDisconnect()) );
connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
connect( m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect( m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect( m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect( m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect( m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
//initialize widgets
m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetOpacity(0.25);
m_TrackingVolumeNode->SetBoolProperty("Backface Culling",true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
GetDataStorage()->Add(m_TrackingVolumeNode);
//initialize buttons
m_Controls->m_Connect->setEnabled(true);
m_Controls->m_Disconnect->setEnabled(false);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine( m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
m_Controls->m_VolumeSelectionBox->clear();
for(int i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(NULL,tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
m_toolStorage = myDeserializer->Deserialize(filename.toStdString());
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during deserializing. Problems with file,please check the file?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
return;
}
if(m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
m_toolStorage = NULL;
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("Loaded Tools: <none>");
m_Controls->m_toolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = this->m_Controls->m_configurationWidget->GetTrackingDevice();
//Get Tracking Volume Data
mitk::TrackingDeviceData data = mitk::DeviceDataUnspecified;
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ( (! qstr.isNull()) || (! qstr.isEmpty()) ) {
std::string str = qstr.toStdString();
data = mitk::GetDeviceDataByName(str); //Data will be set later, after device generation
}
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(this->m_toolStorage,trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(this->m_ToolVisualizationFilter);
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
MessageBox(myTrackingDeviceSourceFactory->GetErrorMessage());
return;
}
//The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
{
//so delete the old tools in wrong order and add them in the right order
//we cannot simply replace the tool storage because the new storage is
//not correctly initialized with the right data storage
m_toolStorage->DeleteAllTools();
for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_toolStorage->AddTool(toolsInNewOrder->GetTool(i));}
}
//connect to device
try
{
m_TrackingDeviceSource->Connect();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_toolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
}
catch (...) //todo: change to mitk::IGTException
{
MessageBox("Error while starting the tracking device!");
return;
}
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(true);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(false);
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_configurationWidget->ConfigurationFinished();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
if (m_tracking) this->OnStopTracking();
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
//ToolStorages unregisters automatically
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(false);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(true);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_configurationWidget->Reset();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
MessageBox("Error while starting the tracking device!");
return;
}
m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(false);
m_Controls->m_StopTracking->setEnabled(true);
m_Controls->m_Connect->setEnabled(false);
m_tracking = true;
this->GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingTimer->stop();
m_TrackingDeviceSource->StopTracking();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
//enable/disable Buttons
m_Controls->m_Disconnect->setEnabled(true);
m_Controls->m_StartTracking->setEnabled(true);
m_Controls->m_StopTracking->setEnabled(false);
m_Controls->m_Connect->setEnabled(false);
this->GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
// Code to enable/disable device specific buttons
if (Type == mitk::NDIAurora) //Aurora
{
m_Controls->m_AutoDetectTools->setVisible(true);
m_Controls->m_AddSingleTool->setEnabled(false);
}
else //Polaris or Microntracker
{
m_Controls->m_AutoDetectTools->setVisible(false);
m_Controls->m_AddSingleTool->setEnabled(true);
}
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for(int i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = mitk::GetDeviceDataByName(str);
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
GlobalReinit();
}
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
GetDataStorage()->Add(m_TrackingVolumeNode);
}
else
{
GetDataStorage()->Remove(m_TrackingVolumeNode);
GlobalReinit();
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
{
DisableTrackingConfigurationButtons();
mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
currentDevice->OpenConnection();
currentDevice->StartTracking();
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(this->GetDataStorage());
for (int i=0; i<currentDevice->GetToolCount(); i++)
{
//create a navigation tool with sphere as surface
std::stringstream toolname;
toolname << "AutoDetectedTool" << i;
mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
newTool->SetIdentifier(toolname.str());
newTool->SetTrackingDeviceType(mitk::NDIAurora);
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
mitk::Surface::Pointer mySphere = mitk::Surface::New();
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(3.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(mySphere);
newNode->SetName(toolname.str());
newTool->SetDataNode(newNode);
autoDetectedStorage->AddTool(newTool);
}
//save detected tools
m_toolStorage = autoDetectedStorage;
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
currentDevice->StopTracking();
currentDevice->CloseConnection();
EnableTrackingConfigurationButtons();
if (m_toolStorage->GetToolCount()>0)
{
//ask the user if he wants to save the detected tools
QMessageBox msgBox;
switch(m_toolStorage->GetToolCount())
{
case 1:
msgBox.setText("Found one tool!");
break;
default:
msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
}
msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
int ret = msgBox.exec();
if (ret == 16384) //yes
{
//ask the user for a filename
QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"/",tr("*.IGTToolStorage"));
//check for empty filename
if(fileName == "") {return;}
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
//when Serialize method is used exceptions are thrown, need to be adapted
//try-catch block for exception handling in Serializer
try
{
mySerializer->Serialize(fileName.toStdString(),m_toolStorage);
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during serialization. Please check the Zip file.";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());}
return;
}
else if (ret == 65536) //no
{
return;
}
}
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
{
m_ToolVisualizationFilter->Update();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetRecordCounter();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: "+QString::number(m_loggedFrames));
//check if logging stopped automatically
if((m_loggedFrames>1)&&(!m_loggingFilter->GetRecording())){StopLogging();}
}
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QString filename = QFileDialog::getSaveFileName(NULL,tr("Choose Logging File"), "/", "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->SetRecordingMode(mitk::NavigationDataRecorder::NormalFile);
if (m_Controls->m_xmlFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::xml);
else if (m_Controls->m_csvFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::csv);
std::string filename = m_Controls->m_LoggingFileName->text().toStdString().c_str();
// this part has been changed in order to prevent crash of the program
if(!filename.empty())
m_loggingFilter->SetFileName(filename);
else if(filename.empty()){
std::string errormessage = "File name has not been set, please set the file name";
mitkThrowException(mitk::IGTIOException)<<errormessage;
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->SetFileName(filename);
}
if (m_Controls->m_LoggingLimit->isChecked()){m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value());}
//connect filter
for(int i=0; i<m_ToolVisualizationFilter->GetNumberOfOutputs(); i++){m_loggingFilter->AddNavigationData(m_ToolVisualizationFilter->GetOutput(i));}
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//update label
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
m_loggingFilter->StopRecording();
m_logging = false;
EnableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
if (m_toolStorage.IsNotNull()) Identifier += QString::number(m_toolStorage->GetToolCount());
else Identifier += "0";
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(),Identifier.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(),false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull()) m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
QString toolLabel = QString("Loaded Tools: <manually added>");
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_csvFormat->setEnabled(false);
m_Controls->m_xmlFormat->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_csvFormat->setEnabled(true);
m_Controls->m_xmlFormat->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_ShowToolQuaternions->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_ShowToolQuaternions->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(true);
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
index 5f154a8535..4badf81dc5 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkNavigationDataPlayerView.cpp
@@ -1,476 +1,476 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkNavigationDataPlayerView.h"
#include "QmitkStdMultiWidget.h"
//mitk
#include <mitkCone.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// Qt
#include <QMessageBox>
// vtk
#include <vtkConeSource.h>
const std::string QmitkNavigationDataPlayerView::VIEW_ID = "org.mitk.views.navigationdataplayer";
QmitkNavigationDataPlayerView::QmitkNavigationDataPlayerView()
: QmitkFunctionality()
, m_Controls( 0 )
, m_MultiWidget( NULL )
, m_Trajectory( NULL )
, m_TrajectoryIndex( -1 )
, m_ReloadData( true )
, m_ShowTrajectory( false )
, m_SplineMapper( NULL )
, m_PointSetMapper( NULL )
{
m_TrajectoryPointSet = mitk::PointSet::New(); // PointSet for trajectory points
}
QmitkNavigationDataPlayerView::~QmitkNavigationDataPlayerView()
{
delete m_PlayerWidget;
}
void QmitkNavigationDataPlayerView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkNavigationDataPlayerViewControls;
m_Controls->setupUi( parent );
this->CreateBundleWidgets( parent );
this->CreateConnections();
}
}
void QmitkNavigationDataPlayerView::CreateBundleWidgets(QWidget* parent)
{
m_PlayerWidget = new QmitkIGTPlayerWidget( parent ); // this bundle's ND player widget
}
void QmitkNavigationDataPlayerView::CreateConnections()
{
connect( m_PlayerWidget, SIGNAL(SignalPlayingStarted()), this, SLOT(OnCreatePlaybackVisualization()) );
connect( m_PlayerWidget, SIGNAL(SignalPlayerUpdated()), this, SLOT(OnPerformPlaybackVisualization()) );
connect( m_PlayerWidget, SIGNAL(SignalInputFileChanged()), this, SLOT(OnReinit()) );
connect( m_PlayerWidget, SIGNAL(SignalCurrentTrajectoryChanged(int)), this, SLOT (OnShowTrajectory(int)) );
connect( m_PlayerWidget, SIGNAL(SignalPlayingStarted()), this, SLOT(OnPlayingStarted()) );
connect( m_PlayerWidget, SIGNAL(SignalSplineModeToggled(bool)), this, SLOT(OnEnableSplineTrajectoryMapper(bool)) );
}
void QmitkNavigationDataPlayerView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkNavigationDataPlayerView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkNavigationDataPlayerView::OnPlayingStarted()
{
m_TrajectoryPointSet->Clear(); // clear trajectory data before every replay
}
void QmitkNavigationDataPlayerView::OnCreatePlaybackVisualization()
{
if(m_ReloadData) // only if input file changed
{
m_Visualizer = mitk::NavigationDataObjectVisualizationFilter::New();
mitk::DataStorage* ds = this->GetDefaultDataStorage();
unsigned int nrTools = m_PlayerWidget->GetNumberOfTools(); // obtain number of tools from replay file
QStringList toolNames;
toolNames << "No trajectory selected ..."; // info statement at beginning of trajectories list
for(int i=0; i<nrTools; ++i)
{
std::stringstream ss;
QString nodeName = QString("Replay Tool %1").arg(i).toLatin1();
toolNames << nodeName;
mitk::Color color = this->GetColorCircleColor(i); // color for replay object
mitk::DataNode::Pointer playbackRepresentation = this->CreateRepresentationObject( nodeName.toStdString(), color ); // create replay DataNode object
m_Visualizer->SetRepresentationObject(i, playbackRepresentation->GetData()); // add replay object to visualizer
// add new representation object to DataStorage
this->AddRepresentationObject(this->GetDefaultDataStorage(), playbackRepresentation);
}
this->m_PlayerWidget->SetTrajectoryNames(toolNames); // set names in player widget trajectory selection combobox
m_ReloadData = false;
/// request global reiinit
mitk::NodePredicateNot::Pointer pred
= mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox"
, mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
/// global reinit end
}
}
mitk::DataNode::Pointer QmitkNavigationDataPlayerView::CreateTrajectory( mitk::PointSet::Pointer points, const std::string& name, const mitk::Color color )
{
mitk::DataNode::Pointer result = mitk::DataNode::New();
// instantiate return DataNode
result->SetData(points);
result->SetName(name);
result->SetColor(color);
mitk::PointSetVtkMapper3D::Pointer mapper;
// create mapper for trajectory visualization
if(m_PlayerWidget->IsTrajectoryInSplineMode())
mapper = this->GetTrajectoryMapper(Splines);
else
mapper = this->GetTrajectoryMapper(Points);
result->SetMapper(mitk::BaseRenderer::Standard3D, mapper);
// trajectory properties
result->SetProperty("contourcolor", mitk::ColorProperty::New(color));
result->SetBoolProperty("show contour", true);
result->SetBoolProperty("updateDataOnRender", false);
return result;
}
mitk::DataNode::Pointer QmitkNavigationDataPlayerView::CreateRepresentationObject(const std::string& name, const mitk::Color color)
{
mitk::DataNode::Pointer representationNode = mitk::DataNode::New();
// creating cone DataNode for tool visualization
mitk::Cone::Pointer cone = mitk::Cone::New();
vtkConeSource* vtkData = vtkConeSource::New();
vtkData->SetRadius(7.5);
vtkData->SetHeight(15.0);
vtkData->SetDirection(0.0, 0.0, 1.0);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->SetResolution(20);
vtkData->CappingOn();
vtkData->Update();
cone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
representationNode->SetData(cone);
representationNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New( name.c_str() ));
representationNode->GetPropertyList()->SetProperty("layer", mitk::IntProperty::New(0));
representationNode->GetPropertyList()->SetProperty("visible", mitk::BoolProperty::New(true));
representationNode->SetColor(color);
representationNode->SetOpacity(1.0);
representationNode->Modified();
return representationNode;
}
void QmitkNavigationDataPlayerView::OnPerformPlaybackVisualization()
{
if(m_PlayerWidget == NULL || m_Visualizer.IsNull())
return;
static int update = 0;
static int counter = -1;
for(unsigned int i = 0 ; i < m_PlayerWidget->GetNavigationDatas().size(); ++i)
{
m_Visualizer->SetInput(i, m_PlayerWidget->GetNavigationDatas().at(i)); // pass updated tool NDs to visualizer
// show trajectory for selected tool with user given resolution
if(m_ShowTrajectory && (i == m_TrajectoryIndex) && (update++ % m_PlayerWidget->GetResolution() == 0) )
{
mitk::PointSet::PointType currentPoint = m_PlayerWidget->GetNavigationDataPoint(i); // current ND point for tool trajectory
// if realtime mode is selected, trajectory points that are equal in position to their antecessor
// will not be inserted in the trajectory pointset to avoid "vtk can't create normals" warning
if(m_PlayerWidget->GetCurrentPlaybackMode() == QmitkIGTPlayerWidget::RealTimeMode)
{
mitk::PointSet::PointType lastPoint;
if(counter == -1)
{
lastPoint[0] = -1;
lastPoint[1] = -1;
lastPoint[2] = -1;
}
else
lastPoint = m_TrajectoryPointSet->GetPoint(counter); // antecessor point is last point from PointSet
mitk::PointSet::PointType currentPoint = m_PlayerWidget->GetNavigationDataPoint(i);
// check for position differences between last and current point
bool diff0 = lastPoint[0] != currentPoint[0];
bool diff1 = lastPoint[1] != currentPoint[1];
bool diff2 = lastPoint[2] != currentPoint[2];
if(diff0 || diff1 || diff2)
m_TrajectoryPointSet->InsertPoint(++counter, currentPoint); // insert only if there are differences
}
else
{
m_TrajectoryPointSet->InsertPoint(++counter, currentPoint); // insert point in trajectory PointSet
}
}
}
this->RenderScene();
}
void QmitkNavigationDataPlayerView::RenderScene()
{
try
{
if (m_Visualizer.IsNull() || this->GetActiveStdMultiWidget() == NULL)
return;
try
{
m_Visualizer->Update();
}
catch(std::exception& e)
{
std::cout << "Exception during QmitkNavigationDataPlayerView::RenderScene():" << e.what() << "\n";
}
//update all Widgets
// mitk::RenderingManager::GetInstance()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
// update only Widget4
mitk::BaseRenderer::GetInstance(m_MultiWidget->mitkWidget4->GetRenderWindow())->RequestUpdate(); // update 3D render window
}
catch (std::exception& e)
{
std::cout << "RenderAll exception: " << e.what() << "\n";
}
catch (...)
{
std::cout << "RenderAll unknown exception\n";
}
}
void QmitkNavigationDataPlayerView::OnReinit()
{
std::vector<mitk::DataNode::Pointer>::iterator it;
mitk::DataStorage* ds = this->GetDefaultDataStorage();
// clear tool representation objects from DataStorage
for ( it = m_RepresentationObjects.begin() ; it != m_RepresentationObjects.end(); it++ )
{
//ds->Remove(*it);
mitk::DataNode::Pointer dn = ds->GetNamedNode((*it)->GetName());
if(dn.IsNotNull())
ds->Remove(dn);
}
m_RepresentationObjects.clear(); // clear tool representation objects vector
if(m_Trajectory.IsNotNull())
this->GetDefaultDataStorage()->Remove(m_Trajectory); // remove trajectory DataNode from DataStorage
m_TrajectoryPointSet->Clear(); // clear trajectory PointSet
this->m_PlayerWidget->ClearTrajectorySelectCombobox(); // clear trajectory selection combobox in player widget
m_ReloadData = true; // set flag to true so representation data will be reload if play is triggered again
}
void QmitkNavigationDataPlayerView::AddTrajectory(mitk::DataStorage* ds, mitk::DataNode::Pointer trajectoryNode)
{
if(ds == NULL)
return;
if(m_Trajectory.IsNotNull())
ds->Remove(m_Trajectory); // remove trajectory from DataStorage if already exists
// add trajectory to DataStorage
if(ds != NULL && trajectoryNode.IsNotNull())
{
m_Trajectory = trajectoryNode;
ds->Add(m_Trajectory);
}
}
void QmitkNavigationDataPlayerView::AddRepresentationObject(mitk::DataStorage* ds, mitk::DataNode::Pointer reprObject)
{
m_RepresentationObjects.push_back(reprObject);
ds->Add(reprObject);
}
void QmitkNavigationDataPlayerView::RemoveRepresentationObject(mitk::DataStorage* ds, mitk::DataNode::Pointer reprObject)
{
std::vector<mitk::DataNode::Pointer>::iterator it;
for ( it = m_RepresentationObjects.begin() ; it != m_RepresentationObjects.end(); it++ )
{
if(*it == reprObject)
{
m_RepresentationObjects.erase(it);
ds->Remove(reprObject);
}
}
}
void QmitkNavigationDataPlayerView::OnShowTrajectory(int index)
{
mitk::DataStorage* ds = this->GetDefaultDataStorage();
// no trajectory selected
if(index == 0)
{
m_ShowTrajectory = false;
m_TrajectoryIndex = -1;
if(m_Trajectory.IsNotNull())
ds->Remove(m_Trajectory);
}
else
{
m_ShowTrajectory = true;
// index-1 because combobox is filled with infovalue at index = 0
mitk::DataNode::Pointer replayObject = m_RepresentationObjects.at(index-1);
std::string prefix("Trajectory of ");
std::string name = replayObject->GetName();
mitk::Color color = this->GetColorCircleColor(index-1);
if(m_TrajectoryPointSet.IsNotNull())
m_TrajectoryPointSet->Clear();
m_TrajectoryIndex = index-1;
mitk::DataNode::Pointer trajectory = this->CreateTrajectory( m_TrajectoryPointSet, prefix.append(name), color );
this->AddTrajectory(this->GetDefaultDataStorage(), trajectory);
}
}
void QmitkNavigationDataPlayerView::OnEnableSplineTrajectoryMapper(bool enable)
{
if(m_Trajectory.IsNull())
return;
// if enabled set spline mapper
if(enable)
m_Trajectory->SetMapper(mitk::BaseRenderer::Standard3D, this->GetTrajectoryMapper(Splines));
// if disabled set pointset mapper
else
m_Trajectory->SetMapper(mitk::BaseRenderer::Standard3D, this->GetTrajectoryMapper(Points));
mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // request update after mapper change
}
mitk::Color QmitkNavigationDataPlayerView::GetColorCircleColor(int index)
{
mitk::Color result;
mitk::ColorSequenceCycleH colorCycle;
for(int i=0; i <= index; ++i)
{
result = colorCycle.GetNextColor();
}
return result;
}
mitk::PointSetVtkMapper3D::Pointer QmitkNavigationDataPlayerView::GetTrajectoryMapper(TrajectoryStyle style)
{
if(style == Points)
{
if(m_PointSetMapper.IsNull())
m_PointSetMapper = mitk::PointSetVtkMapper3D::New();
return m_PointSetMapper;
}
else if(style == Splines)
{
if(m_SplineMapper.IsNull())
m_SplineMapper = mitk::SplineVtkMapper3D::New();
return m_SplineMapper.GetPointer();
}
else
return NULL;
}
diff --git a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
index 83c1d09fae..cc421beaed 100644
--- a/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
+++ b/Plugins/org.mitk.gui.qt.imagecropper/src/internal/QmitkImageCropper.cpp
@@ -1,454 +1,454 @@
/*===================================================================
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 <iostream>
#include "QmitkImageCropper.h"
#include <QAction>
#include <QInputDialog>
#include <QMessageBox>
#include <QCheckBox>
#include <QSpinBox>
#include <QSlider>
#include <vtkRenderWindow.h>
#include <mitkEllipsoid.h>
#include <mitkCylinder.h>
#include <mitkCone.h>
#include <mitkRenderingManager.h>
#include <mitkProperties.h>
#include <mitkGlobalInteraction.h>
#include "mitkUndoController.h"
#include "mitkBoundingObjectCutter.h"
#include "mitkImageAccessByItk.h"
#include "mitkITKImageImport.h"
#include "mitkIDataStorageService.h"
#include "mitkNodePredicateDataType.h"
#include <itkCommand.h>
//to be moved to mitkInteractionConst.h by StateMachineEditor
const mitk::OperationType QmitkImageCropper::OP_EXCHANGE = 717;
// constructors for operation classes
QmitkImageCropper::opExchangeNodes::opExchangeNodes( mitk::OperationType type, mitk::DataNode* node, mitk::BaseData* oldData, mitk::BaseData* newData )
:mitk::Operation(type),m_Node(node),m_OldData(oldData),m_NewData(newData), m_NodeDeletedObserverTag(0), m_OldDataDeletedObserverTag(0),
m_NewDataDeletedObserverTag(0)
{
// listen to the node the image is hold
itk::MemberCommand<opExchangeNodes>::Pointer nodeDeletedCommand = itk::MemberCommand<opExchangeNodes>::New();
nodeDeletedCommand->SetCallbackFunction(this, &opExchangeNodes::NodeDeleted);
m_NodeDeletedObserverTag = m_Node->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
m_OldDataDeletedObserverTag = m_OldData->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
m_NewDataDeletedObserverTag = m_NewData->AddObserver(itk::DeleteEvent(), nodeDeletedCommand);
}
// destructor for operation class
QmitkImageCropper::opExchangeNodes::~opExchangeNodes()
{
if (m_Node != NULL)
{
m_Node->RemoveObserver(m_NodeDeletedObserverTag);
m_Node=NULL;
}
if (m_OldData.IsNotNull())
{
m_OldData->RemoveObserver(m_OldDataDeletedObserverTag);
m_OldData=NULL;
}
if (m_NewData.IsNotNull())
{
m_NewData->RemoveObserver(m_NewDataDeletedObserverTag);
m_NewData=NULL;
}
}
void QmitkImageCropper::opExchangeNodes::NodeDeleted(const itk::Object * /*caller*/, const itk::EventObject &/*event*/)
{
m_Node = NULL;
m_OldData = NULL;
m_NewData = NULL;
}
QmitkImageCropper::QmitkImageCropper(QObject *parent)
: m_Controls(NULL), m_ParentWidget(0)
{
m_Interface = new mitk::ImageCropperEventInterface;
m_Interface->SetImageCropper( this );
}
QmitkImageCropper::~QmitkImageCropper()
{
//delete smart pointer objects
m_CroppingObjectNode = NULL;
m_CroppingObject = NULL;
m_Interface->Delete();
}
void QmitkImageCropper::CreateQtPartControl(QWidget* parent)
{
if (!m_Controls)
{
m_ParentWidget = parent;
// build ui elements
m_Controls = new Ui::QmitkImageCropperControls;
m_Controls->setupUi(parent);
// setup ui elements
m_Controls->groupInfo->hide();
m_Controls->m_SurroundingSlider->hide();
m_Controls->m_SurroundingSpin->hide();
m_Controls->m_BoxButton->setEnabled(true);
m_Controls->warningLabel->setVisible(false);
// create ui element connections
this->CreateConnections();
}
}
void QmitkImageCropper::CreateConnections()
{
if ( m_Controls )
{
connect( m_Controls->m_CropButton, SIGNAL(clicked()), this, SLOT(CropImage())); // click on the crop button
connect( m_Controls->m_BoxButton, SIGNAL(clicked()), this, SLOT(CreateNewBoundingObject()) );
connect( m_Controls->m_EnableSurroundingCheckBox, SIGNAL(toggled(bool)), this, SLOT(SurroundingCheck(bool)) );
connect( m_Controls->chkInformation, SIGNAL(toggled(bool)), this, SLOT(ChkInformationToggled(bool)) );
}
}
void QmitkImageCropper::Activated()
{
QmitkFunctionality::Activated(); // just call the inherited function
}
void QmitkImageCropper::Deactivated()
{
RemoveBoundingObjectFromNode();
QmitkFunctionality::Deactivated(); // just call the inherited function
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
/*! When called with an opExchangeNodes, it changes the content of a node from one data set to another
*/
void QmitkImageCropper::ExecuteOperation (mitk::Operation *operation)
{
if (!operation) return;
switch (operation->GetOperationType())
{
case OP_EXCHANGE:
{
//RemoveBoundingObjectFromNode();
opExchangeNodes* op = static_cast<opExchangeNodes*>(operation);
op->GetNode()->SetData(op->GetNewData());
mitk::RenderingManager::GetInstance()->InitializeViews();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
break;
}
default:;
}
}
void QmitkImageCropper::CreateNewBoundingObject()
{
// attach the cuboid to the image and update the views
if (this->IsVisible())
{
if (m_ImageNode.IsNotNull())
{
m_ImageToCrop = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
if(m_ImageToCrop.IsNotNull())
{
if (this->GetDefaultDataStorage()->GetNamedDerivedNode("CroppingObject", m_ImageNode))
{
//Remove m_Cropping
this->RemoveBoundingObjectFromNode();
}
bool fitCroppingObject = false;
if(m_CroppingObject.IsNull())
{
CreateBoundingObject();
fitCroppingObject = true;
}
if (m_CroppingObject.IsNull())
return;
AddBoundingObjectToNode( m_ImageNode, fitCroppingObject );
m_ImageNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->InitializeViews();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_BoxButton->setText("Reset bounding box!");
m_Controls->m_CropButton->setEnabled(true);
}
}
else
QMessageBox::information(NULL, "Image cropping functionality", "Load an image first!");
}
}
void QmitkImageCropper::SurroundingCheck(bool value)
{
if(value)
{
if(m_ImageNode.IsNotNull())
{
mitk::DataNode *imageNode = m_ImageNode.GetPointer();
if (imageNode)
{
mitk::BaseData* data = imageNode->GetData();
if (data)
{
// test if this data item is an image or not (could also be a surface or something totally different)
mitk::Image* image = dynamic_cast<mitk::Image*>( data );
if (image)
{
float min = 10000.0;
float max = -10000.0;
min = image->GetScalarValueMin();
max = image->GetScalarValueMax();
m_Controls->m_SurroundingSlider->setRange((int)min,(int)max);
m_Controls->m_SurroundingSpin->setRange((int)min,(int)max);
}
}
}
m_Controls->m_SurroundingSlider->show();
m_Controls->m_SurroundingSpin->show();
}
else
m_Controls->m_EnableSurroundingCheckBox->setChecked(false);
}
else
{
m_Controls->m_SurroundingSlider->hide();
m_Controls->m_SurroundingSpin->hide();
}
}
void QmitkImageCropper::CropImage()
{
// test, if image is selected
if (m_ImageToCrop.IsNull()) return;
// test, if bounding box is visible
if (m_CroppingObjectNode.IsNull())
{
QMessageBox::information(NULL, "Image cropping functionality", "Generate a new bounding object first!");
return;
}
// image and bounding object ok
mitk::BoundingObjectCutter::Pointer cutter = mitk::BoundingObjectCutter::New();
cutter->SetBoundingObject( m_CroppingObject );
cutter->SetInput( m_ImageToCrop );
cutter->AutoOutsideValueOff();
if (m_Controls->m_EnableSurroundingCheckBox->isChecked())
{
cutter->SetOutsideValue(m_Controls->m_SurroundingSpin->value());
}
// do the actual cutting
try
{
cutter->Update();
//cutter->UpdateLargestPossibleRegion();
}
catch(itk::ExceptionObject&)
{
QMessageBox::warning ( NULL,
tr("Cropping not possible"),
tr("Sorry, the bounding box has to be completely inside the image.\n\n"
"The possibility to drag it larger than the image is a bug and has to be fixed."),
QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton );
return;
}
// cutting successful
mitk::Image::Pointer resultImage = cutter->GetOutput();
resultImage->DisconnectPipeline();
RemoveBoundingObjectFromNode();
{
opExchangeNodes* doOp = new opExchangeNodes(OP_EXCHANGE, m_ImageNode.GetPointer(),
m_ImageNode->GetData(),
resultImage);
opExchangeNodes* undoOp = new opExchangeNodes(OP_EXCHANGE, m_ImageNode.GetPointer(),
resultImage,
m_ImageNode->GetData());
// TODO: MITK doesn't recognize that a new event happens in the next line,
// because nothing happens in the render window.
// As a result the undo action will happen together with the last action
// recognized by MITK.
mitk::OperationEvent* operationEvent = new mitk::OperationEvent( m_Interface, doOp, undoOp, "Crop image");
mitk::UndoController::GetCurrentUndoModel()->SetOperationEvent( operationEvent ); // tell the undo controller about the action
ExecuteOperation(doOp); // execute action
}
m_Controls->m_BoxButton->setEnabled(true);
m_Controls->m_CropButton->setEnabled(false);
}
void QmitkImageCropper::CreateBoundingObject()
{
QStringList items;
items << tr("Cuboid") << tr("Ellipsoid") << tr("Cylinder") << tr("Cone");
bool ok;
QString item = QInputDialog::getItem(m_Parent, tr("Select Bounding Object"), tr("Type of Bounding Object:"), items, 0, false, &ok);
if (!ok)
return;
if (item == "Ellipsoid")
m_CroppingObject = mitk::Ellipsoid::New();
else if(item == "Cylinder")
m_CroppingObject = mitk::Cylinder::New();
else if (item == "Cone")
m_CroppingObject = mitk::Cone::New();
else if (item == "Cuboid")
m_CroppingObject = mitk::Cuboid::New();
else
return;
m_CroppingObjectNode = mitk::DataNode::New();
m_CroppingObjectNode->SetData( m_CroppingObject );
m_CroppingObjectNode->SetProperty( "name", mitk::StringProperty::New( "CroppingObject" ) );
m_CroppingObjectNode->SetProperty( "color", mitk::ColorProperty::New(1.0, 1.0, 0.0) );
m_CroppingObjectNode->SetProperty( "opacity", mitk::FloatProperty::New(0.4) );
m_CroppingObjectNode->SetProperty( "layer", mitk::IntProperty::New(99) ); // arbitrary, copied from segmentation functionality
m_CroppingObjectNode->SetProperty( "helper object", mitk::BoolProperty::New(true) );
m_AffineInteractor = mitk::AffineInteractor::New("AffineInteractions ctrl-drag", m_CroppingObjectNode);
}
void QmitkImageCropper::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
{
this->RemoveBoundingObjectFromNode();
if (nodes.size() != 1 || dynamic_cast<mitk::Image*>(nodes[0]->GetData()) == 0)
{
m_ParentWidget->setEnabled(false);
m_Controls->warningLabel->setVisible(false);
return;
}
m_ImageNode = nodes[0];
m_ParentWidget->setEnabled(true);
// do not accept datanodes with dimension of less than three
mitk::Image* m_ImageToCrop = dynamic_cast<mitk::Image*>(nodes[0]->GetData());
if (m_ImageToCrop == NULL)
{
return;
}
unsigned int dim = m_ImageToCrop->GetDimension();
if (dim < 3)
{
m_Controls->warningLabel->setVisible(true);
m_ParentWidget->setEnabled(false);
}
else
{
m_Controls->warningLabel->setVisible(false);
}
}
void QmitkImageCropper::AddBoundingObjectToNode(mitk::DataNode* node, bool fit)
{
m_ImageToCrop = dynamic_cast<mitk::Image*>(node->GetData());
unsigned int dim = m_ImageToCrop->GetDimension();
if (dim < 3)
{
MITK_WARN << "Image Cropper does not support 1D/2D Objects. Aborting operation";
return;
}
if(!this->GetDefaultDataStorage()->Exists(m_CroppingObjectNode))
{
this->GetDefaultDataStorage()->Add(m_CroppingObjectNode, node);
if (fit)
{
- m_CroppingObject->FitGeometry(m_ImageToCrop->GetTimeSlicedGeometry());
+ m_CroppingObject->FitGeometry(m_ImageToCrop->GetGeometry());
}
mitk::GlobalInteraction::GetInstance()->AddInteractor( m_AffineInteractor );
}
m_CroppingObjectNode->SetVisibility(true);
}
void QmitkImageCropper::RemoveBoundingObjectFromNode()
{
if (m_CroppingObjectNode.IsNotNull())
{
if(this->GetDefaultDataStorage()->Exists(m_CroppingObjectNode))
{
this->GetDefaultDataStorage()->Remove(m_CroppingObjectNode);
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_AffineInteractor);
m_CroppingObject = NULL;
}
m_Controls->m_BoxButton->setText("New bounding box!");
}
}
void QmitkImageCropper::ChkInformationToggled( bool on )
{
if (on)
m_Controls->groupInfo->show();
else
m_Controls->groupInfo->hide();
}
void QmitkImageCropper::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkImageCropper::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkImageCropper::NodeRemoved(const mitk::DataNode *node)
{
std::string name = node->GetName();
if (strcmp(name.c_str(), "CroppingObject")==0)
{
m_Controls->m_CropButton->setEnabled(false);
m_Controls->m_BoxButton->setEnabled(true);
}
}
diff --git a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
index d54415ee0d..d12258f793 100644
--- a/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
+++ b/Plugins/org.mitk.gui.qt.simulation/src/internal/QmitkSimulationView.cpp
@@ -1,263 +1,263 @@
/*===================================================================
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 "QmitkSimulationPreferencePage.h"
#include "QmitkSimulationView.h"
#include <mitkIRenderingManager.h>
#include <mitkNodePredicateDataType.h>
#include <mitkSimulation.h>
#include <mitkSimulationModel.h>
#include <sofa/helper/system/PluginManager.h>
#include <sofa/simulation/common/UpdateContextVisitor.h>
static void InitializeViews(mitk::IRenderWindowPart* renderWindowPart, mitk::Geometry3D* geometry)
{
if (renderWindowPart == NULL || geometry == NULL)
return;
mitk::IRenderingManager* renderingManager = renderWindowPart->GetRenderingManager();
if (renderingManager != NULL)
renderingManager->InitializeViews(geometry, mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
QmitkSimulationView::QmitkSimulationView()
: m_SelectionWasRemovedFromDataStorage(false),
m_Timer(this)
{
this->GetDataStorage()->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
connect(&m_Timer, SIGNAL(timeout()), this, SLOT(OnTimerTimeout()));
initSOFAPlugins();
}
QmitkSimulationView::~QmitkSimulationView()
{
this->GetDataStorage()->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkSimulationView, const mitk::DataNode*>(this, &QmitkSimulationView::OnNodeRemovedFromDataStorage));
}
void QmitkSimulationView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Controls.simulationComboBox->SetDataStorage(this->GetDataStorage());
m_Controls.simulationComboBox->SetPredicate(mitk::NodePredicateDataType::New("Simulation"));
m_Controls.stepsRecordedLabel->hide();
connect(m_Controls.animateButton, SIGNAL(toggled(bool)), this, SLOT(OnAnimateButtonToggled(bool)));
connect(m_Controls.recordButton, SIGNAL(toggled(bool)), this, SLOT(OnRecordButtonToggled(bool)));
connect(m_Controls.resetButton, SIGNAL(clicked()), this, SLOT(OnResetButtonClicked()));
connect(m_Controls.stepButton, SIGNAL(clicked()), this, SLOT(OnStepButtonClicked()));
connect(m_Controls.simulationComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSimulationComboBoxSelectionChanged(const mitk::DataNode*)));
connect(m_Controls.dtSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnDTSpinBoxValueChanged(double)));
connect(m_Controls.snapshotButton, SIGNAL(clicked()), this, SLOT(OnSnapshotButtonClicked()));
if (m_Controls.simulationComboBox->GetSelectedNode().IsNotNull())
this->OnSimulationComboBoxSelectionChanged(m_Controls.simulationComboBox->GetSelectedNode());
}
void QmitkSimulationView::OnAnimateButtonToggled(bool toggled)
{
if (this->SetSelectionAsCurrentSimulation())
{
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
rootNode->getContext()->setAnimate(toggled);
if (toggled)
{
m_Controls.stepButton->setEnabled(false);
m_Timer.start(0);
}
}
if (!toggled)
{
m_Timer.stop();
m_Controls.stepButton->setEnabled(true);
}
}
void QmitkSimulationView::OnDTSpinBoxValueChanged(double value)
{
if (!this->SetSelectionAsCurrentSimulation())
return;
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
rootNode->setDt(value == 0.0
? simulation->GetDefaultDT()
: value);
}
void QmitkSimulationView::OnNodeRemovedFromDataStorage(const mitk::DataNode* node)
{
if (m_Selection.IsNotNull() && m_Selection.GetPointer() == node)
m_SelectionWasRemovedFromDataStorage = true;
}
void QmitkSimulationView::OnRecordButtonToggled(bool toggled)
{
if (!toggled)
{
if (m_Record.IsNotNull())
{
mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
dataNode->SetData(m_Record);
dataNode->SetName(m_Record->GetTimeSteps() == 1 ? "Snapshot" : "Record");
this->GetDataStorage()->Add(dataNode, m_Selection);
- InitializeViews(this->GetRenderWindowPart(), m_Record->GetTimeSlicedGeometry());
+ InitializeViews(this->GetRenderWindowPart(), m_Record->GetTimeGeometry());
m_Record = NULL;
}
m_Controls.stepsRecordedLabel->hide();
m_Controls.stepsRecordedLabel->setText("0 steps recorded");
}
else if (toggled)
{
m_Controls.stepsRecordedLabel->show();
}
}
void QmitkSimulationView::OnResetButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
if (m_Controls.recordButton->isChecked())
m_Controls.recordButton->setChecked(false);
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
m_Controls.dtSpinBox->setValue(0.0);
sofaSimulation->reset(rootNode.get());
rootNode->setTime(0.0);
rootNode->execute<sofa::simulation::UpdateContextVisitor>(sofa::core::ExecParams::defaultInstance());
simulation->GetDrawTool()->Reset();
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
}
void QmitkSimulationView::OnSimulationComboBoxSelectionChanged(const mitk::DataNode* node)
{
if (m_Controls.animateButton->isChecked())
m_Controls.animateButton->setChecked(false);
if (m_SelectionWasRemovedFromDataStorage)
{
m_SelectionWasRemovedFromDataStorage = false;
m_Selection = NULL;
}
if (m_Controls.recordButton->isChecked())
m_Controls.recordButton->setChecked(false);
if (node != NULL)
{
m_Selection = m_Controls.simulationComboBox->GetSelectedNode();
m_Controls.sceneGroupBox->setEnabled(true);
m_Controls.snapshotButton->setEnabled(true);
static_cast<mitk::Simulation*>(node->GetData())->SetAsActiveSimulation();
}
else
{
m_Selection = NULL;
m_Controls.sceneGroupBox->setEnabled(false);
m_Controls.snapshotButton->setEnabled(false);
mitk::Simulation::SetActiveSimulation(NULL);
}
}
void QmitkSimulationView::OnSnapshotButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Selection->GetData());
mitk::Surface::Pointer snapshot = simulation->TakeSnapshot();
if (snapshot.IsNull())
return;
mitk::DataNode::Pointer snapshotDataNode = mitk::DataNode::New();
snapshotDataNode->SetData(snapshot);
snapshotDataNode->SetName("Snapshot");
this->GetDataStorage()->Add(snapshotDataNode, m_Selection);
}
void QmitkSimulationView::OnStepButtonClicked()
{
if (!this->SetSelectionAsCurrentSimulation())
return;
mitk::Simulation::Pointer simulation = dynamic_cast<mitk::Simulation*>(m_Controls.simulationComboBox->GetSelectedNode()->GetData());
sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
simulation->GetDrawTool()->Reset();
sofaSimulation->animate(rootNode.get(), rootNode->getDt());
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
if (m_Controls.recordButton->isChecked())
{
if (m_Record.IsNull())
m_Record = mitk::Surface::New();
simulation->AppendSnapshot(m_Record);
unsigned int numSteps = m_Record->GetTimeSteps();
QString plural = numSteps != 1 ? "s" : "";
m_Controls.stepsRecordedLabel->setText(QString("%1 step%2 recorded").arg(numSteps).arg(plural));
}
}
void QmitkSimulationView::SetFocus()
{
m_Controls.animateButton->setFocus();
}
bool QmitkSimulationView::SetSelectionAsCurrentSimulation() const
{
if (m_Selection.IsNotNull())
{
static_cast<mitk::Simulation*>(m_Selection->GetData())->SetAsActiveSimulation();
return true;
}
return false;
}
void QmitkSimulationView::OnTimerTimeout()
{
this->OnStepButtonClicked();
}
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 3fde750bdb..01bfede395 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,618 +1,618 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <mitkIRenderingManager.h>
#include <mitkIRenderWindowPart.h>
#include <mitkILinkedRenderWindowPart.h>
// Qmitk
#include "QmitkToFUtilView.h"
#include <QmitkStdMultiWidget.h>
#include <QmitkTextOverlay.h>
// Qt
#include <QMessageBox>
#include <QString>
//QT headers
#include <qmessagebox.h>
#include <qfiledialog.h>
#include <qcombobox.h>
// MITK
#include <mitkBaseRenderer.h>
#include <mitkGlobalInteraction.h>
#include <mitkLookupTableProperty.h>
#include <mitkToFDistanceImageToPointSetFilter.h>
#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include <mitkToFDeviceFactoryManager.h>
#include <mitkToFCameraDevice.h>
#include <mitkCameraIntrinsicsProperty.h>
//itk headers
#include <itksys/SystemTools.hxx>
// VTK
#include <vtkCamera.h>
// ITK
#include <itkCommand.h>
const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
//Constructor
QmitkToFUtilView::QmitkToFUtilView()
: QmitkAbstractView()
, m_Controls(NULL), m_MultiWidget( NULL )
, m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
, m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
, m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
, m_2DDisplayCount(0)
, m_RealTimeClock(NULL)
, m_StepsForFramerate(100)
, m_2DTimeBefore(0.0)
, m_2DTimeAfter(0.0)
, m_CameraIntrinsics(NULL)
{
this->m_Frametimer = new QTimer(this);
this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
}
//Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
QmitkToFUtilView::~QmitkToFUtilView()
{
OnToFCameraStopped();
OnToFCameraDisconnected();
}
//Createing the PartControl Signal-Slot principal
void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
{
// build up qt view, unless already done
if ( !m_Controls )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkToFUtilViewControls;
m_Controls->setupUi( parent );
//Looking for Input and Defining reaction
connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
connect( (QObject*)(m_Controls->m_SurfaceCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnSurfaceCheckboxChecked(bool)) );
connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
connect( (QObject*)(m_Controls->m_KinectTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnKinectRGBTextureCheckBoxChecked(bool)) );
}
}
//SetFocus-Method -> actually seting Focus to the Recorder
void QmitkToFUtilView::SetFocus()
{
m_Controls->m_ToFRecorderWidget->setFocus();
}
//Activated-Method->Generating RenderWindow
void QmitkToFUtilView::Activated()
{
//get the current RenderWindowPart or open a new one if there is none
if(this->GetRenderWindowPart(OPEN))
{
mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
if(linkedRenderWindowPart == 0)
{
MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
}
else
{
linkedRenderWindowPart->EnableSlicingPlanes(false);
}
GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
this->UseToFVisibilitySettings(true);
if (this->m_ToFCompositeFilter)
{
m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
}
if (this->GetDataStorage())
{
m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
}
if (this->m_ToFImageGrabber.IsNull())
{
m_Controls->m_ToFRecorderWidget->setEnabled(false);
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
m_Controls->tofMeasurementWidget->setEnabled(false);
m_Controls->SurfacePropertiesBox->setEnabled(false);
}
}
}
//ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
{
ResetGUIToDefault();
}
void QmitkToFUtilView::Deactivated()
{
}
void QmitkToFUtilView::Visible()
{
}
//Reset of the ToFUtilView
void QmitkToFUtilView::Hidden()
{
ResetGUIToDefault();
}
void QmitkToFUtilView::OnToFCameraConnected()
{
MITK_DEBUG <<"OnToFCameraConnected";
this->m_2DDisplayCount = 0;
this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
// initialize surface generation
this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
// initialize ToFImageRecorder and ToFRecorderWidget
this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
m_Controls->m_ToFRecorderWidget->setEnabled(true);
m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
// initialize ToFCompositeFilterWidget
this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
if (this->m_ToFCompositeFilter)
{
m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
}
if (this->GetDataStorage())
{
m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
}
// initialize measurement widget
m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
this->m_RealTimeClock = mitk::RealTimeClock::New();
this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
this->RequestRenderWindowUpdate();
}
void QmitkToFUtilView::ResetGUIToDefault()
{
if(this->GetRenderWindowPart())
{
mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
if(linkedRenderWindowPart == 0)
{
MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
}
else
{
linkedRenderWindowPart->EnableSlicingPlanes(true);
}
GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
this->UseToFVisibilitySettings(false);
//global reinit
this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
this->RequestRenderWindowUpdate();
}
}
void QmitkToFUtilView::OnToFCameraDisconnected()
{
m_Controls->m_ToFRecorderWidget->OnStop();
m_Controls->m_ToFRecorderWidget->setEnabled(false);
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
m_Controls->tofMeasurementWidget->setEnabled(false);
m_Controls->SurfacePropertiesBox->setEnabled(false);
//clean up measurement widget
m_Controls->tofMeasurementWidget->CleanUpWidget();
}
void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
{
if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
{
if (m_SelectedCamera.contains("Kinect"))
{
if (m_ToFImageGrabber->GetBoolProperty("RGB"))
{
this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
}
else if (m_ToFImageGrabber->GetBoolProperty("IR"))
{
this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
}
}
this->UseToFVisibilitySettings(true);
}
}
void QmitkToFUtilView::OnToFCameraStarted()
{
if (m_ToFImageGrabber.IsNotNull())
{
// initialize camera intrinsics
if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
{
m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
MITK_INFO << m_CameraIntrinsics->ToString();
}
else
{
m_CameraIntrinsics = NULL;
MITK_ERROR << "No camera intrinsics were found!";
}
// initial update of image grabber
this->m_ToFImageGrabber->Update();
this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
// initial update of composite filter
this->m_ToFCompositeFilter->Update();
this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput(0);
this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
std::string rgbFileName;
m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
if ((m_SelectedCamera.contains("Kinect"))||(rgbFileName!=""))
{
//set the reconstruction mode for kinect
this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
if (rgbFileName!="" || m_ToFImageGrabber->GetBoolProperty("RGB") )
{
this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
}
else if (m_ToFImageGrabber->GetBoolProperty("IR"))
{
this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
}
}
else
{
this->m_RGBImageNode = NULL;
this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
}
this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
this->UseToFVisibilitySettings(true);
m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
// initialize visualization widget
m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
// set distance image to measurement widget
m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
this->m_Frametimer->start(0);
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
m_Controls->tofMeasurementWidget->setEnabled(true);
m_Controls->SurfacePropertiesBox->setEnabled(true);
if (m_Controls->m_TextureCheckBox->isChecked())
{
OnTextureCheckBoxChecked(true);
}
if (m_Controls->m_KinectTextureCheckBox->isChecked())
{
OnKinectRGBTextureCheckBoxChecked(true);
}
}
m_Controls->m_TextureCheckBox->setEnabled(true);
}
void QmitkToFUtilView::OnToFCameraStopped()
{
m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
m_Controls->SurfacePropertiesBox->setEnabled(false);
this->m_Frametimer->stop();
}
void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
{
m_SelectedCamera = selected;
if ((selected.contains("CamBoard"))||(selected.contains("O3D")))
{
MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
this->m_Controls->m_TextureCheckBox->setEnabled(false);
this->m_Controls->m_KinectTextureCheckBox->setEnabled(false);
this->m_Controls->m_SurfaceCheckBox->setChecked(false);
this->m_Controls->m_TextureCheckBox->setChecked(false);
this->m_Controls->m_KinectTextureCheckBox->setChecked(false);
}
else
{
this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
this->m_Controls->m_TextureCheckBox->setEnabled(true);
this->m_Controls->m_KinectTextureCheckBox->setEnabled(true);
}
}
void QmitkToFUtilView::OnSurfaceCheckboxChecked(bool checked)
{
if(checked)
{
//initialize the surface once
MITK_DEBUG << "OnSurfaceCheckboxChecked true";
this->m_SurfaceNode->SetData(this->m_Surface);
this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
//we need to initialize (reinit) the surface, to make it fit into the renderwindow
this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
- this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
+ this->m_Surface->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
//the default camera position is rather unfortunate,
//that's why we set our own position according to the surface center
mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
vtkCamera* camera3d = GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
//1m distance to camera should be a nice default value for most cameras
camera3d->SetPosition(0,0,-1000);
camera3d->SetViewUp(0,-1,0);
camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
camera3d->SetViewAngle(40);
camera3d->SetClippingRange(1, 10000);
}
}
void QmitkToFUtilView::OnUpdateCamera()
{
//##### Code for surface #####
if (m_Controls->m_SurfaceCheckBox->isChecked())
{
// update surface
m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
//if the user wants to see the texture, it has to be updated for every frame
if(m_Controls->m_KinectTextureCheckBox->isChecked() && (m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
{
//remove the vtkScalarsToColors object, if there was one.
this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(NULL);
//set RGB-iamge as texture
this->m_ToFSurfaceVtkMapper3D->SetTexture((this->m_ToFImageGrabber->GetOutput(3)->GetVtkImageData()));
}
else
{
//we have to delete the texture, if there was one.
this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
//get the colortransferfunction from the visualization widget
this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction());
}
//update pipeline
this->m_Surface->Update();
}
//##### End code for surface #####
else
{
// update pipeline
this->m_MitkDistanceImage->Update();
}
this->RequestRenderWindowUpdate();
this->m_2DDisplayCount++;
if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
{
this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter/1000);
this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
}
}
void QmitkToFUtilView::OnTextureCheckBoxChecked(bool checked)
{
if(m_SurfaceNode.IsNotNull())
{
if (checked)
{
this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
}
else
{
this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
}
}
}
void QmitkToFUtilView::OnKinectRGBTextureCheckBoxChecked(bool checked)
{
if((m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
{
if (checked)
{
//define the dimensions of the texture
this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(0));
this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(1));
}
}
}
void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
{
this->OnToFCameraStopped();
if(index == 0)
{
if(this->m_IntensityImageNode.IsNotNull())
this->m_IntensityImageNode->SetVisibility(false);
if(this->m_RGBImageNode.IsNotNull())
this->m_RGBImageNode->SetVisibility(true);
}
else if(index == 1)
{
if(this->m_IntensityImageNode.IsNotNull())
this->m_IntensityImageNode->SetVisibility(true);
if(this->m_RGBImageNode.IsNotNull())
this->m_RGBImageNode->SetVisibility(false);
}
this->RequestRenderWindowUpdate();
this->OnToFCameraStarted();
}
mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
{
mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
if (node.IsNull())
{
node = mitk::DataNode::New();
node->SetData(data);
node->SetName(nodeName);
node->SetBoolProperty("binary",false);
this->GetDataStorage()->Add(node);
}
else
{
node->SetData(data);
}
return node;
}
void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
{
// set node properties
if (m_DistanceImageNode.IsNotNull())
{
this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
this->m_DistanceImageNode->SetBoolProperty("use color",!useToF);
this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
if (m_AmplitudeImageNode.IsNotNull())
{
if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
{
this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
else
{
this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
}
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
this->m_AmplitudeImageNode->SetBoolProperty("use color",!useToF);
this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
if (m_IntensityImageNode.IsNotNull())
{
if (m_SelectedCamera.contains("Kinect"))
{
this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
else
{
this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
this->m_IntensityImageNode->SetBoolProperty("use color",!useToF);
this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
}
}
if ((m_RGBImageNode.IsNotNull()))
{
if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
{
this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
}
else
{
this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
}
}
// initialize images
if (m_MitkDistanceImage.IsNotNull())
{
this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
- this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
+ this->m_MitkDistanceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
}
if(this->m_SurfaceNode.IsNotNull())
{
QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
while (i.hasNext()){
i.next();
this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
}
this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
}
//disable/enable gradient background
this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
}
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index 5a696f73a5..8c400a49bb 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
@@ -1,214 +1,214 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
//Mitk
#include <mitkDataNode.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// Qmitk
#include "UltrasoundSupport.h"
#include <QTimer>
// Qt
#include <QMessageBox>
// Ultrasound
#include "mitkUSDevice.h"
const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
void UltrasoundSupport::SetFocus()
{
m_Controls.m_AddDevice->setFocus();
}
void UltrasoundSupport::CreateQtPartControl( QWidget *parent )
{
m_Timer = new QTimer(this);
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this, SLOT(OnClickedAddNewDevice()) ); // Change Widget Visibilities
connect( m_Controls.m_AddDevice, SIGNAL(clicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice()) ); // Init NewDeviceWidget
connect( m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone()) ); // After NewDeviceWidget finished editing
connect( m_Controls.m_BtnView, SIGNAL(clicked()), this, SLOT(OnClickedViewDevice()) );
connect( m_Timer, SIGNAL(timeout()), this, SLOT(DisplayImage()));
connect( m_Controls.crop_left, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_right, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_top, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
connect( m_Controls.crop_bot, SIGNAL(valueChanged(int)), this, SLOT(OnCropAreaChanged()) );
//connect (m_Controls.m_ActiveVideoDevices, SIGNAL())
// Initializations
m_Controls.m_NewVideoDeviceWidget->setVisible(false);
std::string filter = "(&(" + mitk::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(" + mitk::USDevice::US_PROPKEY_ISACTIVE + "=true))";
m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USDevice::US_PROPKEY_LABEL ,filter);
//UI initializations
m_Controls.crop_left->setEnabled(false);
m_Controls.crop_right->setEnabled(false);
m_Controls.crop_bot->setEnabled(false);
m_Controls.crop_top->setEnabled(false);
m_Node = mitk::DataNode::New();
m_Node->SetName("US Image Stream");
this->GetDataStorage()->Add(m_Node);
}
void UltrasoundSupport::OnClickedAddNewDevice()
{
m_Controls.m_NewVideoDeviceWidget->setVisible(true);
m_Controls.m_DeviceManagerWidget->setVisible(false);
m_Controls.m_AddDevice->setVisible(false);
m_Controls.m_Headline->setText("Add New Device:");
}
void UltrasoundSupport::DisplayImage()
{
m_Device->UpdateOutputData(0);
m_Node->SetData(m_Device->GetOutput());
this->RequestRenderWindowUpdate();
m_FrameCounter ++;
if (m_FrameCounter == 10)
{
int nMilliseconds = m_Clock.restart();
int fps = 10000.0f / (nMilliseconds );
m_Controls.m_FramerateLabel->setText("Current Framerate: "+ QString::number(fps) +" FPS");
m_FrameCounter = 0;
}
}
void UltrasoundSupport::OnCropAreaChanged()
{
if (m_Device->GetDeviceClass()=="org.mitk.modules.us.USVideoDevice")
{
mitk::USVideoDevice::Pointer currentVideoDevice = dynamic_cast<mitk::USVideoDevice*>(m_Device.GetPointer());
mitk::USDevice::USImageCropArea newArea;
newArea.cropLeft = m_Controls.crop_left->value();
newArea.cropTop = m_Controls.crop_top->value();
newArea.cropRight = m_Controls.crop_right->value();
newArea.cropBottom = m_Controls.crop_bot->value();
//check enabled: if not we are in the initializing step and don't need to do anything
//otherwise: update crop area
if (m_Controls.crop_right->isEnabled())
currentVideoDevice->SetCropArea(newArea);
GlobalReinit();
}
else
{
MITK_WARN << "No USVideoDevice: Cannot Crop!";
}
}
void UltrasoundSupport::OnClickedViewDevice()
{
m_FrameCounter = 0;
// We use the activity state of the timer to determine whether we are currently viewing images
if ( ! m_Timer->isActive() ) // Activate Imaging
{
//get device & set data node
m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
if (m_Device.IsNull()){
m_Timer->stop();
return;
}
m_Device->Update();
m_Node->SetData(m_Device->GetOutput());
//start timer
int interval = (1000 / m_Controls.m_FrameRate->value());
m_Timer->setInterval(interval);
m_Timer->start();
//reinit view
GlobalReinit();
//change UI elements
m_Controls.m_BtnView->setText("Stop Viewing");
m_Controls.m_FrameRate->setEnabled(false);
m_Controls.crop_left->setValue(m_Device->GetCropArea().cropLeft);
m_Controls.crop_right->setValue(m_Device->GetCropArea().cropRight);
m_Controls.crop_bot->setValue(m_Device->GetCropArea().cropBottom);
m_Controls.crop_top->setValue(m_Device->GetCropArea().cropTop);
m_Controls.crop_left->setEnabled(true);
m_Controls.crop_right->setEnabled(true);
m_Controls.crop_bot->setEnabled(true);
m_Controls.crop_top->setEnabled(true);
}
else //deactivate imaging
{
//stop timer & release data
m_Timer->stop();
m_Node->ReleaseData();
this->RequestRenderWindowUpdate();
//change UI elements
m_Controls.m_BtnView->setText("Start Viewing");
m_Controls.m_FrameRate->setEnabled(true);
m_Controls.crop_left->setEnabled(false);
m_Controls.crop_right->setEnabled(false);
m_Controls.crop_bot->setEnabled(false);
m_Controls.crop_top->setEnabled(false);
}
}
void UltrasoundSupport::OnNewDeviceWidgetDone()
{
m_Controls.m_NewVideoDeviceWidget->setVisible(false);
m_Controls.m_DeviceManagerWidget->setVisible(true);
m_Controls.m_AddDevice->setVisible(true);
m_Controls.m_Headline->setText("Connected Devices:");
}
void UltrasoundSupport::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
- mitk::TimeSlicedGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
+ mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
UltrasoundSupport::UltrasoundSupport()
{
m_DevicePersistence = mitk::USDevicePersistence::New();
m_DevicePersistence->RestoreLastDevices();
}
UltrasoundSupport::~UltrasoundSupport()
{
m_DevicePersistence->StoreCurrentDevices();
m_Controls.m_DeviceManagerWidget->DisconnectAllDevices();
}
\ No newline at end of file