/**
3.2 Initialize region growing
3.2.1 Determine memory offset inside the original image
3.2.2 Determine initial region growing parameters from the level window settings of the image
3.2.3 Perform a region growing (which generates a new feedback contour)
*/
bool mitk::RegionGrowingTool::OnMousePressedOutside(Action* itkNotUsed( action ), const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in OnMousePressed
// 3.2 If we have a reference image, then perform an initial region growing, considering the reference image's level window
// if click was outside the image, don't continue
const Geometry3D* sliceGeometry = m_ReferenceSlice->GetGeometry();
Point3D mprojectedPointIn2D;
sliceGeometry->WorldToIndex( positionEvent->GetWorldPosition(), mprojectedPointIn2D );
itk::Index<2> projectedPointIn2D;
projectedPointIn2D[0] = static_cast<int>( mprojectedPointIn2D[0] - 0.5 );
projectedPointIn2D[1] = static_cast<int>( mprojectedPointIn2D[1] - 0.5 );
if ( sliceGeometry->IsIndexInside( mprojectedPointIn2D ) )
{
MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetWorldPosition() << " (index coordinates " << mprojectedPointIn2D << ") IS in reference slice" << std::endl;
// 3.2.1 Remember Y cursor position and initial seed point
//m_ScreenYPositionAtStart = static_cast<int>(positionEvent->GetDisplayPosition()[1]);
m_LastScreenPosition = ApplicationCursor::GetInstance()->GetCursorPosition();
m_ScreenYDifference = 0;
m_SeedPointMemoryOffset = projectedPointIn2D[1] * m_OriginalPicSlice->n[0] + projectedPointIn2D[0];
m_LastWorkingSeed = m_SeedPointMemoryOffset; // remember for skeletonization
if ( m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] ) &&
m_SeedPointMemoryOffset >= 0 )
{
// 3.2.2 Get level window from reference DataNode
// Use some logic to determine initial gray value bounds
LevelWindow lw(0, 500);
m_ToolManager->GetReferenceData(0)->GetLevelWindow(lw); // will fill lw if levelwindow property is present, otherwise won't touch it.
ScalarType currentVisibleWindow = lw.GetWindow();
if (!mitk::Equal(currentVisibleWindow, m_VisibleWindow))
{
m_InitialLowerThreshold = currentVisibleWindow / 20.0;
m_InitialUpperThreshold = currentVisibleWindow / 20.0;
m_LowerThreshold = m_InitialLowerThreshold;
m_UpperThreshold = m_InitialUpperThreshold;
// 3.2.3. Actually perform region growing
mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour();
ipMITKSegmentationFree( result);
// display the contour
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
m_FillFeedbackContour = true;
}
}
return true;
}
return false;
}
/**
If in region growing mode (m_ReferenceSlice != NULL), then
1. Calculate the new thresholds from mouse position (relative to first position)
2. Perform a new region growing and update the feedback contour
*/
bool mitk::RegionGrowingTool::OnMouseMoved( StateMachineAction*, InteractionEvent* interactionEvent )
{
if ( FeedbackContourTool::CanHandleEvent(interactionEvent) > 0.0 )
{
if ( m_ReferenceSlice.IsNotNull() && m_OriginalPicSlice )
{
mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
//const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (positionEvent)
{
ApplicationCursor* cursor = ApplicationCursor::GetInstance();
if (!cursor) return false;
m_ScreenYDifference += cursor->GetCursorPosition()[1] - m_LastScreenPosition[1];
cursor->SetCursorPosition( m_LastScreenPosition );
m_LowerThreshold = std::max<mitk::ScalarType>(0.0, m_InitialLowerThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
m_UpperThreshold = std::max<mitk::ScalarType>(0.0, m_InitialUpperThreshold - m_ScreenYDifference * m_MouseDistanceScaleFactor);
// 2. Perform region growing again and show the result
mitkIpPicDescriptor* result = PerformRegionGrowingAndUpdateContour(positionEvent->GetSender()->GetTimeStep());
ipMITKSegmentationFree( result );
// 3. Update the contour
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
}
}
}
return true;
}
void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, unsigned int timeStep, Image* sliceImage, int paintingPixelValue )
{
// 1. Use ipSegmentation to draw a filled(!) contour into a new 8 bit 2D image, which will later be copied back to the slice.
// We don't work on the "real" working data, because ipSegmentation would restrict us to 8 bit images
// convert the projected contour into a ipSegmentation format
mitkIpInt4_t* picContour = new mitkIpInt4_t[2 * projectedContour->GetNumberOfVertices(timeStep)];
unsigned int index(0);
ContourModel::VertexIterator iter = projectedContour->Begin(timeStep);
ContourModel::VertexIterator end = projectedContour->End(timeStep);
while( iter != end)
{
picContour[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[0] + 1.0 ); // +0.5 wahrscheinlich richtiger
picContour[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[1] + 1.0 );
//MITK_INFO << "mitk 2d [" << (*iter)[0] << ", " << (*iter)[1] << "] pic [" << picContour[ 2*index+0] << ", " << picContour[ 2*index+1] << "]";
iter++;
index++;
}
assert( sliceImage->GetSliceData() );
mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
CastToIpPicDescriptor( sliceImage, originalPicSlice);
mitkIpPicDescriptor* picSlice = ipMITKSegmentationNew( originalPicSlice );
ipMITKSegmentationClear( picSlice );
assert( originalPicSlice && picSlice );
// here comes the actual contour filling algorithm (from ipSegmentation/Graphics Gems)
ipMITKSegmentationCombineRegion ( picSlice, picContour, projectedContour->GetNumberOfVertices(timeStep), NULL, IPSEGMENTATION_OR, 1); // set to 1
delete[] picContour;
// 2. Copy the filled contour to the working data slice
// copy all pixels that are non-zero to the original image (not caring for the actual type of the working image). perhaps make the replace value a parameter ( -> general painting tool ).
// make the pic slice an mitk/itk image (as little ipPic code as possible), call a templated method with accessbyitk, iterate over the original and the modified slice
Image::Pointer ipsegmentationModifiedSlice = Image::New();
ipsegmentationModifiedSlice->Initialize( CastToImageDescriptor( picSlice ) );
ipsegmentationModifiedSlice->SetSlice( picSlice->data );
AccessFixedDimensionByItk_2( sliceImage, ItkCopyFilledContourToSlice, 2, ipsegmentationModifiedSlice, paintingPixelValue );
ipsegmentationModifiedSlice = NULL; // free MITK header information
ipMITKSegmentationFree( picSlice ); // free actual memory
}
/**
Uses ipSegmentation algorithms to do the actual region growing. The result (binary image) is first smoothed by a 5x5 circle mask, then
its contour is extracted and converted to MITK coordinates.
*/
mitkIpPicDescriptor* mitk::RegionGrowingTool::PerformRegionGrowingAndUpdateContour(int timestep)
{
// 1. m_OriginalPicSlice and m_SeedPointMemoryOffset are set to sensitive values, as well as m_LowerThreshold and m_UpperThreshold
assert (m_OriginalPicSlice);
if (m_OriginalPicSlice->n[0] != 256 || m_OriginalPicSlice->n[1] != 256) // ???
assert( (m_SeedPointMemoryOffset < static_cast<int>( m_OriginalPicSlice->n[0] * m_OriginalPicSlice->n[1] )) && (m_SeedPointMemoryOffset >= 0) ); // inside the image
// 2. ipSegmentation is used to perform region growing
float ignored;
int oneContourOffset( 0 );
mitkIpPicDescriptor* regionGrowerResult = ipMITKSegmentationGrowRegion4N( m_OriginalPicSlice,
m_SeedPointMemoryOffset, // seed point
true, // grayvalue interval relative to seed point gray value?
m_LowerThreshold,
m_UpperThreshold,
0, // continue until done (maxIterations == 0)
NULL, // allocate new memory (only this time, on mouse move we'll reuse the old buffer)
oneContourOffset, // a pixel that is near the resulting contour
ignored // ignored by us
);
if (!regionGrowerResult || oneContourOffset == -1)
{
ContourModel::Pointer dummyContour = ContourModel::New();
dummyContour->Initialize();
FeedbackContourTool::SetFeedbackContour( *dummyContour );
if (regionGrowerResult) ipMITKSegmentationFree(regionGrowerResult);
return NULL;
}
// 3. We smooth the result a little to reduce contour complexity
bool smoothResult( true ); // currently fixed, perhaps remove else block
mitkIpPicDescriptor* smoothedRegionGrowerResult;
if (smoothResult)
{
// Smooth the result (otherwise very detailed contour)
smoothedRegionGrowerResult = SmoothIPPicBinaryImage( regionGrowerResult, oneContourOffset );
ipMITKSegmentationFree( regionGrowerResult );
}
else
{
smoothedRegionGrowerResult = regionGrowerResult;
}
// 4. convert the result of region growing into a mitk::Contour
// At this point oneContourOffset could be useless, if smoothing destroyed a thin bridge. In these
// cases, we have two or more unconnected segmentation regions, and we don't know, which one is touched by oneContourOffset.
// In the bad case, the contour is not the one around our seedpoint, so the result looks very strange to the user.
// -> we remove the point where the contour started so far. Then we look from the bottom of the image for the first segmentation pixel
// and start another contour extraction from there. This is done, until the seedpoint is inside the contour
int numberOfContourPoints( 0 );
int newBufferSize( 0 );
float* contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
if (contourPoints)
{
while ( !ipMITKSegmentationIsInsideContour( contourPoints, // contour
numberOfContourPoints, // points in contour
m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0], // test point x
m_SeedPointMemoryOffset / smoothedRegionGrowerResult->n[0] // test point y
) )
{
// we decide that this cannot be part of the segmentation because the seedpoint is not contained in the contour (fill the 4-neighborhood with 0)
ipMITKSegmentationReplaceRegion4N( smoothedRegionGrowerResult, oneContourOffset, 0 );
// move the contour offset to the last row (x position of the seed point)
int rowLength = smoothedRegionGrowerResult->n[0]; // number of pixels in a row
oneContourOffset = m_SeedPointMemoryOffset % smoothedRegionGrowerResult->n[0] // x of seed point
+ rowLength*(smoothedRegionGrowerResult->n[1]-1); // y of last row
while ( oneContourOffset >=0
&& (*(static_cast<ipMITKSegmentationTYPE*>(smoothedRegionGrowerResult->data) + oneContourOffset) == 0) )
{
oneContourOffset -= rowLength; // if pixel at data+oneContourOffset is 0, then move up one row
}
if ( oneContourOffset < 0 )
{
break; // just use the last contour we found
}
free(contourPoints); // release contour memory
contourPoints = ipMITKSegmentationGetContour8N( smoothedRegionGrowerResult, oneContourOffset, numberOfContourPoints, newBufferSize ); // memory allocated with malloc
}
// copy point from float* to mitk::Contour
ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
contourInImageIndexCoordinates->Expand(timestep + 1);
contourInImageIndexCoordinates->SetClosed(true, timestep);
Point3D newPoint;
for (int index = 0; index < numberOfContourPoints; ++index)
{
newPoint[0] = contourPoints[ 2 * index + 0 ] - 0.5;//correction is needed because the output of the algorithm is center based
newPoint[1] = contourPoints[ 2 * index + 1 ] - 0.5;//and we want our contour displayed corner based.
newPoint[2] = 0;
contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
}
free(contourPoints);
ContourModel::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice( m_ReferenceSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for ipSegmentation correctio
FeedbackContourTool::SetFeedbackContour( *contourInWorldCoordinates );
}
// 5. Result HAS TO BE freed by caller, contains the binary region growing result
return smoothedRegionGrowerResult;
}
