mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent)
{
DataNode *referenceNode(m_ToolManager->GetReferenceData(0));
if (!referenceNode)
{
return nullptr;
}
Image *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
if (!referenceImage)
{
return nullptr;
}
int displayedComponent = 0;
if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
{
// found the displayed component
return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
}
else
{
return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
}
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent* positionEvent)
{
DataNode* referenceNode( m_ToolManager->GetReferenceData(0) );
if ( !referenceNode ) return NULL;
Image* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
if ( !referenceImage ) return NULL;
return GetAffectedImageSliceAs2DImage( positionEvent, referenceImage );
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent* positionEvent)
{
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
if ( !workingNode ) return NULL;
Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
if ( !workingImage ) return NULL;
return GetAffectedImageSliceAs2DImage( positionEvent, workingImage );
}
mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
{
if (!positionEvent)
{
return nullptr;
}
assert(positionEvent->GetSender()); // sure, right?
unsigned int timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
}
void mitk::SegTool2D::WriteSliceToVolume(mitk::SegTool2D::SliceInformation sliceInfo)
{
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
Image* image = dynamic_cast<Image*>(workingNode->GetData());
/*============= BEGIN undo/redo feature block ========================*/
// Create undo operation by caching the not yet modified slices
mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, image, sliceInfo.timestep);
DiffSliceOperation* undoOperation = new DiffSliceOperation(const_cast<mitk::Image*>(image), originalSlice, dynamic_cast<SlicedGeometry3D*>(originalSlice->GetGeometry()), sliceInfo.timestep, sliceInfo.plane);
/*============= END undo/redo feature block ========================*/
//Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
//Set the slice as 'input'
reslice->SetInputSlice(sliceInfo.slice->GetVtkImageData());
//set overwrite mode to true to write back to the image volume
reslice->SetOverwriteMode(true);
reslice->Modified();
mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
extractor->SetInput( image );
extractor->SetTimeStep( sliceInfo.timestep );
extractor->SetWorldGeometry( sliceInfo.plane );
extractor->SetVtkOutputRequest(false);
extractor->SetResliceTransformByGeometry( image->GetGeometry( sliceInfo.timestep ) );
extractor->Modified();
extractor->Update();
//the image was modified within the pipeline, but not marked so
image->Modified();
image->GetVtkImageData()->Modified();
/*============= BEGIN undo/redo feature block ========================*/
//specify the undo operation with the edited slice
DiffSliceOperation* doOperation = new DiffSliceOperation(image, extractor->GetOutput(),dynamic_cast<SlicedGeometry3D*>(sliceInfo.slice->GetGeometry()), sliceInfo.timestep, sliceInfo.plane);
//create an operation event for the undo stack
OperationEvent* undoStackItem = new OperationEvent( DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation" );
//add it to the undo controller
UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
//clear the pointers as the operation are stored in the undocontroller and also deleted from there
undoOperation = NULL;
doOperation = NULL;
/*============= END undo/redo feature block ========================*/
}
void mitk::FastMarchingTool::ConfirmSegmentation()
{
// combine preview image with current working segmentation
if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
{
//logical or combination of preview and segmentation slice
OutputImageType::Pointer workingImageSliceInITK = OutputImageType::New();
mitk::Image::Pointer workingImageSlice;
mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(this->m_ToolManager->GetWorkingData(0)->GetData());
workingImageSlice = GetAffectedImageSliceAs2DImage(m_WorkingPlane, workingImage, m_CurrentTimeStep);
CastToItkImage( workingImageSlice, workingImageSliceInITK );
typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
orFilter->SetInput(1, workingImageSliceInITK);
orFilter->Update();
mitk::Image::Pointer segmentationResult = mitk::Image::New();
mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
segmentationResult->GetGeometry()->SetOrigin(workingImageSlice->GetGeometry()->GetOrigin());
segmentationResult->GetGeometry()->SetIndexToWorldTransform(workingImageSlice->GetGeometry()->GetIndexToWorldTransform());
//write to segmentation volume and hide preview image
// again, current time step is not considered
this->WriteBackSegmentationResult(m_WorkingPlane, segmentationResult, m_CurrentTimeStep);
this->m_ResultImageNode->SetVisibility(false);
this->ClearSeeds();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_ToolManager->ActivateTool(-1);
}
