void mitk::CreateDistanceImageFromSurfaceFilter::CreateSolutionMatrixAndFunctionValues()
{
unsigned int numberOfInputs = this->GetNumberOfInputs();
if (numberOfInputs == 0)
{
MITK_ERROR << "mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!" << std::endl;
itkExceptionMacro("mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!");
return;
}
//First of all we have to extract the nomals and the surface points.
//Duplicated points can be eliminated
Surface* currentSurface;
vtkSmartPointer<vtkPolyData> polyData;
vtkSmartPointer<vtkDoubleArray> currentCellNormals;
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
double p[3];
PointType currentPoint;
PointType normal;
for (unsigned int i = 0; i < numberOfInputs; i++)
{
currentSurface = const_cast<Surface*>( this->GetInput(i) );
polyData = currentSurface->GetVtkPolyData();
if (polyData->GetNumberOfPolys() == 0)
{
MITK_INFO << "mitk::CreateDistanceImageFromSurfaceFilter: No input-polygons available. Please be sure the input surface consists of polygons!" << std::endl;
}
currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
existingPolys = polyData->GetPolys();
existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( unsigned int j = 0; j < cellSize; j++ )
{
existingPoints->GetPoint(cell[j], p);
currentPoint.copy_in(p);
int count = std::count(m_Centers.begin() ,m_Centers.end(),currentPoint);
if (count == 0)
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
normal.copy_in(currentNormal);
m_Normals.push_back(normal);
m_Centers.push_back(currentPoint);
}
}//end for all points
}//end for all cells
}//end for all outputs
//For we can now calculate the exact size of the centers we initialize the data structures
unsigned int numberOfCenters = m_Centers.size();
m_Centers.reserve(numberOfCenters*3);
m_FunctionValues.set_size(numberOfCenters*3);
m_FunctionValues.fill(0);
//Create inner points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] - normal[0];
currentPoint[1] = currentPoint[1] - normal[1];
currentPoint[2] = currentPoint[2] - normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters+i, -1);
}
//Create outer points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] + normal[0];
currentPoint[1] = currentPoint[1] + normal[1];
currentPoint[2] = currentPoint[2] + normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters*2+i, 1);
}
//Now we have created all centers and all function values. Next step is to create the solution matrix
numberOfCenters = m_Centers.size();
m_SolutionMatrix.set_size(numberOfCenters, numberOfCenters);
m_Weights.set_size(numberOfCenters);
PointType p1;
PointType p2;
double norm;
for (unsigned int i = 0; i < numberOfCenters; i++)
{
for (unsigned int j = 0; j < numberOfCenters; j++)
{
//Calculate the RBF value. Currently using Phi(r) = r with r is the euclidian distance between two points
p1 = m_Centers.at(i);
p2 = m_Centers.at(j);
p1 = p1 - p2;
norm = p1.two_norm();
m_SolutionMatrix(i,j) = norm;
}
}
}
void Geometry2DDataVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
{
SetVtkMapperImmediateModeRendering(m_EdgeMapper);
SetVtkMapperImmediateModeRendering(m_BackgroundMapper);
// Remove all actors from the assembly, and re-initialize it with the
// edge actor
m_ImageAssembly->GetParts()->RemoveAllItems();
if ( !this->IsVisible(renderer) )
{
// visibility has explicitly to be set in the single actors
// due to problems when using cell picking:
// even if the assembly is invisible, the renderer contains
// references to the assemblies parts. During picking the
// visibility of each part is checked, and not only for the
// whole assembly.
m_ImageAssembly->VisibilityOff();
m_EdgeActor->VisibilityOff();
return;
}
// visibility has explicitly to be set in the single actors
// due to problems when using cell picking:
// even if the assembly is invisible, the renderer contains
// references to the assemblies parts. During picking the
// visibility of each part is checked, and not only for the
// whole assembly.
m_ImageAssembly->VisibilityOn();
m_EdgeActor->VisibilityOn();
Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
if (input.IsNotNull() && (input->GetGeometry2D() != NULL))
{
SmartPointerProperty::Pointer surfacecreatorprop;
surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(GetDataNode()->GetProperty("surfacegeometry", renderer));
if ( (surfacecreatorprop.IsNull())
|| (surfacecreatorprop->GetSmartPointer().IsNull())
|| ((m_SurfaceCreator = dynamic_cast<Geometry2DDataToSurfaceFilter*>
(surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull() ) )
{
m_SurfaceCreator->PlaceByGeometryOn();
surfacecreatorprop = SmartPointerProperty::New( m_SurfaceCreator );
GetDataNode()->SetProperty("surfacegeometry", surfacecreatorprop);
}
m_SurfaceCreator->SetInput(input);
int res;
if (GetDataNode()->GetIntProperty("xresolution", res, renderer))
{
m_SurfaceCreator->SetXResolution(res);
}
if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
{
m_SurfaceCreator->SetYResolution(res);
}
double tubeRadius = 1.0; // Radius of tubular edge surrounding plane
// Clip the Geometry2D with the reference geometry bounds (if available)
if ( input->GetGeometry2D()->HasReferenceGeometry() )
{
Geometry3D *referenceGeometry =
input->GetGeometry2D()->GetReferenceGeometry();
BoundingBox::PointType boundingBoxMin, boundingBoxMax;
boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
if ( referenceGeometry->GetImageGeometry() )
{
for ( unsigned int i = 0; i < 3; ++i )
{
boundingBoxMin[i] -= 0.5;
boundingBoxMax[i] -= 0.5;
}
}
m_SurfaceCreatorPointsContainer->CreateElementAt( 0 ) = boundingBoxMin;
m_SurfaceCreatorPointsContainer->CreateElementAt( 1 ) = boundingBoxMax;
m_SurfaceCreatorBoundingBox->ComputeBoundingBox();
m_SurfaceCreator->SetBoundingBox( m_SurfaceCreatorBoundingBox );
tubeRadius = referenceGeometry->GetDiagonalLength() / 450.0;
}
// If no reference geometry is available, clip with the current global
// bounds
else if (m_DataStorage.IsNotNull())
{
m_SurfaceCreator->SetBoundingBox(m_DataStorage->ComputeVisibleBoundingBox(NULL, "includeInBoundingBox"));
tubeRadius = sqrt( m_SurfaceCreator->GetBoundingBox()->GetDiagonalLength2() ) / 450.0;
}
// Calculate the surface of the Geometry2D
m_SurfaceCreator->Update();
Surface *surface = m_SurfaceCreator->GetOutput();
// Check if there's something to display, otherwise return
if ( (surface->GetVtkPolyData() == 0 )
|| (surface->GetVtkPolyData()->GetNumberOfCells() == 0) )
{
m_ImageAssembly->VisibilityOff();
return;
}
// add a graphical representation of the surface normals if requested
DataNode* node = this->GetDataNode();
bool displayNormals = false;
bool colorTwoSides = false;
bool invertNormals = false;
node->GetBoolProperty("draw normals 3D", displayNormals, renderer);
node->GetBoolProperty("color two sides", colorTwoSides, renderer);
node->GetBoolProperty("invert normals", invertNormals, renderer);
//if we want to draw the display normals or render two sides we have to get the colors
if( displayNormals || colorTwoSides )
{
//get colors
float frontColor[3] = { 0.0, 0.0, 1.0 };
node->GetColor( frontColor, renderer, "front color" );
float backColor[3] = { 1.0, 0.0, 0.0 };
node->GetColor( backColor, renderer, "back color" );
if ( displayNormals )
{
m_NormalsTransformer->SetInput( surface->GetVtkPolyData() );
m_NormalsTransformer->SetTransform(node->GetVtkTransform(this->GetTimestep()) );
m_FrontHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
m_FrontHedgeHog->SetVectorModeToUseNormal();
m_FrontHedgeHog->SetScaleFactor( invertNormals ? 1.0 : -1.0 );
m_FrontNormalsActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
m_BackHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
m_BackHedgeHog->SetVectorModeToUseNormal();
m_BackHedgeHog->SetScaleFactor( invertNormals ? -1.0 : 1.0 );
m_BackNormalsActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
//if there is no actor added yet, add one
if ( !m_NormalsActorAdded )
{
m_Prop3DAssembly->AddPart( m_FrontNormalsActor );
m_Prop3DAssembly->AddPart( m_BackNormalsActor );
m_NormalsActorAdded = true;
}
}
//if we don't want to display normals AND there is an actor added remove the actor
else if ( m_NormalsActorAdded )
{
m_Prop3DAssembly->RemovePart( m_FrontNormalsActor );
m_Prop3DAssembly->RemovePart( m_BackNormalsActor );
m_NormalsActorAdded = false;
}
if ( colorTwoSides )
{
if ( !invertNormals )
{
m_BackgroundActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
m_BackgroundActor->GetBackfaceProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
}
else
{
m_BackgroundActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
m_BackgroundActor->GetBackfaceProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
}
}
}
// Add black background for all images (which may be transparent)
m_BackgroundMapper->SetInput( surface->GetVtkPolyData() );
m_ImageAssembly->AddPart( m_BackgroundActor );
LayerSortedActorList layerSortedActors;
// Traverse the data tree to find nodes resliced by ImageMapperGL2D
mitk::NodePredicateOr::Pointer p = mitk::NodePredicateOr::New();
//use a predicate to get all data nodes which are "images" or inherit from mitk::Image
mitk::TNodePredicateDataType< mitk::Image >::Pointer predicateAllImages = mitk::TNodePredicateDataType< mitk::Image >::New();
mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetSubset(predicateAllImages);
//process all found images
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode *node = it->Value();
if (node != NULL)
this->ProcessNode(node, renderer, surface, layerSortedActors);
}
// Add all image actors to the assembly, sorted according to
// layer property
LayerSortedActorList::iterator actorIt;
for ( actorIt = layerSortedActors.begin(); actorIt != layerSortedActors.end(); ++actorIt )
{
m_ImageAssembly->AddPart( actorIt->second );
}
// Configurate the tube-shaped frame: size according to the surface
// bounds, color as specified in the plane's properties
vtkPolyData *surfacePolyData = surface->GetVtkPolyData();
m_Cleaner->SetInput(surfacePolyData);
m_EdgeTransformer->SetTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
// Adjust the radius according to extent
m_EdgeTuber->SetRadius( tubeRadius );
// Get the plane's color and set the tube properties accordingly
ColorProperty::Pointer colorProperty;
colorProperty = dynamic_cast<ColorProperty*>(this->GetDataNode()->GetProperty( "color" ));
if ( colorProperty.IsNotNull() )
{
const Color& color = colorProperty->GetColor();
m_EdgeActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
}
else
{
m_EdgeActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
}
m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
}
VtkRepresentationProperty* representationProperty;
this->GetDataNode()->GetProperty(representationProperty, "material.representation", renderer);
if ( representationProperty != NULL )
m_BackgroundActor->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
}
void mitk::CreateDistanceImageFromSurfaceFilter::PreprocessContourPoints()
{
unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
if (numberOfInputs == 0)
{
MITK_ERROR << "mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!" << std::endl;
itkExceptionMacro("mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!");
return;
}
//First of all we have to extract the nomals and the surface points.
//Duplicated points can be eliminated
Surface* currentSurface;
vtkSmartPointer<vtkPolyData> polyData;
vtkSmartPointer<vtkDoubleArray> currentCellNormals;
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
double p[3];
PointType currentPoint;
PointType normal;
for (unsigned int i = 0; i < numberOfInputs; i++)
{
currentSurface = const_cast<Surface*>( this->GetInput(i) );
polyData = currentSurface->GetVtkPolyData();
if (polyData->GetNumberOfPolys() == 0)
{
MITK_INFO << "mitk::CreateDistanceImageFromSurfaceFilter: No input-polygons available. Please be sure the input surface consists of polygons!" << std::endl;
}
currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
existingPolys = polyData->GetPolys();
existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (nullptr);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( vtkIdType j = 0; j < cellSize; j++ )
{
existingPoints->GetPoint(cell[j], p);
currentPoint.copy_in(p);
int count = std::count(m_Centers.begin() ,m_Centers.end(),currentPoint);
if (count == 0)
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
normal.copy_in(currentNormal);
m_Normals.push_back(normal);
m_Centers.push_back(currentPoint);
}
}//end for all points
}//end for all cells
}//end for all outputs
}
bool AffineInteractor3D
::ExecuteAction( Action *action, StateEvent const *stateEvent )
{
bool ok = false;
// Get data object
BaseData *data = m_DataNode->GetData();
if ( data == NULL )
{
MITK_ERROR << "No data object present!";
return ok;
}
// Get Event and extract renderer
const Event *event = stateEvent->GetEvent();
BaseRenderer *renderer = NULL;
vtkRenderWindow *renderWindow = NULL;
vtkRenderWindowInteractor *renderWindowInteractor = NULL;
vtkRenderer *currentVtkRenderer = NULL;
vtkCamera *camera = NULL;
if ( event != NULL )
{
renderer = event->GetSender();
if ( renderer != NULL )
{
renderWindow = renderer->GetRenderWindow();
if ( renderWindow != NULL )
{
renderWindowInteractor = renderWindow->GetInteractor();
if ( renderWindowInteractor != NULL )
{
currentVtkRenderer = renderWindowInteractor
->GetInteractorStyle()->GetCurrentRenderer();
if ( currentVtkRenderer != NULL )
{
camera = currentVtkRenderer->GetActiveCamera();
}
}
}
}
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe != NULL )
{
m_CurrentPickedPoint = dpe->GetWorldPosition();
m_CurrentPickedDisplayPoint = dpe->GetDisplayPosition();
}
// Get the timestep to also support 3D+t
int timeStep = 0;
ScalarType timeInMS = 0.0;
if ( renderer != NULL )
{
timeStep = renderer->GetTimeStep( data );
timeInMS = renderer->GetTime();
}
// If data is an mitk::Surface, extract it
Surface *surface = dynamic_cast< Surface * >( data );
vtkPolyData *polyData = NULL;
if ( surface != NULL )
{
polyData = surface->GetVtkPolyData( timeStep );
// Extract surface normal from surface (if existent, otherwise use default)
vtkPointData *pointData = polyData->GetPointData();
if ( pointData != NULL )
{
vtkDataArray *normal = polyData->GetPointData()->GetVectors( "planeNormal" );
if ( normal != NULL )
{
m_ObjectNormal[0] = normal->GetComponent( 0, 0 );
m_ObjectNormal[1] = normal->GetComponent( 0, 1 );
m_ObjectNormal[2] = normal->GetComponent( 0, 2 );
}
}
}
// Get geometry object
m_Geometry = data->GetGeometry( timeStep );
// Make sure that the data (if time-resolved) has enough entries;
// if not, create the required extra ones (empty)
data->Expand( timeStep+1 );
switch (action->GetActionId())
{
case AcDONOTHING:
ok = true;
break;
case AcCHECKOBJECT:
{
// Re-enable VTK interactor (may have been disabled previously)
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Enable();
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
// Check if an object is present at the current mouse position
DataNode *pickedNode = dpe->GetPickedObjectNode();
StateEvent *newStateEvent;
if ( pickedNode == m_DataNode )
{
// Yes: object will be selected
newStateEvent = new StateEvent( EIDYES );
}
else
{
// No: back to start state
newStateEvent = new StateEvent( EIDNO );
}
this->HandleEvent( newStateEvent );
ok = true;
break;
}
case AcDESELECTOBJECT:
{
// Color object white
m_DataNode->SetColor( 1.0, 1.0, 1.0 );
RenderingManager::GetInstance()->RequestUpdateAll();
// Colorize surface / wireframe as inactive
this->ColorizeSurface( polyData,
m_CurrentPickedPoint, -1.0 );
ok = true;
break;
}
case AcSELECTPICKEDOBJECT:
{
// Color object red
m_DataNode->SetColor( 1.0, 0.0, 0.0 );
RenderingManager::GetInstance()->RequestUpdateAll();
// Colorize surface / wireframe dependend on distance from picked point
this->ColorizeSurface( polyData,
m_CurrentPickedPoint, 0.0 );
ok = true;
break;
}
case AcINITMOVE:
{
// Disable VTK interactor until MITK interaction has been completed
if ( renderWindowInteractor != NULL )
{
renderWindowInteractor->Disable();
}
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
//DataNode *pickedNode = dpe->GetPickedObjectNode();
m_InitialPickedPoint = m_CurrentPickedPoint;
m_InitialPickedDisplayPoint = m_CurrentPickedDisplayPoint;
if ( currentVtkRenderer != NULL )
{
vtkInteractorObserver::ComputeDisplayToWorld(
currentVtkRenderer,
m_InitialPickedDisplayPoint[0],
m_InitialPickedDisplayPoint[1],
0.0, //m_InitialInteractionPickedPoint[2],
m_InitialPickedPointWorld );
}
// Make deep copy of current Geometry3D of the plane
data->UpdateOutputInformation(); // make sure that the Geometry is up-to-date
m_OriginalGeometry = static_cast< Geometry3D * >(
data->GetGeometry( timeStep )->Clone().GetPointer() );
ok = true;
break;
}
case AcMOVE:
{
// Check if we have a DisplayPositionEvent
const DisplayPositionEvent *dpe =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( dpe == NULL )
{
ok = true;
break;
}
if ( currentVtkRenderer != NULL )
{
vtkInteractorObserver::ComputeDisplayToWorld(
currentVtkRenderer,
m_CurrentPickedDisplayPoint[0],
m_CurrentPickedDisplayPoint[1],
0.0, //m_InitialInteractionPickedPoint[2],
m_CurrentPickedPointWorld );
}
Vector3D interactionMove;
interactionMove[0] = m_CurrentPickedPointWorld[0] - m_InitialPickedPointWorld[0];
interactionMove[1] = m_CurrentPickedPointWorld[1] - m_InitialPickedPointWorld[1];
interactionMove[2] = m_CurrentPickedPointWorld[2] - m_InitialPickedPointWorld[2];
if ( m_InteractionMode == INTERACTION_MODE_TRANSLATION )
{
Point3D origin = m_OriginalGeometry->GetOrigin();
Vector3D transformedObjectNormal;
data->GetGeometry( timeStep )->IndexToWorld(
m_ObjectNormal, transformedObjectNormal );
data->GetGeometry( timeStep )->SetOrigin(
origin + transformedObjectNormal * (interactionMove * transformedObjectNormal) );
}
else if ( m_InteractionMode == INTERACTION_MODE_ROTATION )
{
if ( camera )
{
double vpn[3];
camera->GetViewPlaneNormal( vpn );
Vector3D viewPlaneNormal;
viewPlaneNormal[0] = vpn[0];
viewPlaneNormal[1] = vpn[1];
viewPlaneNormal[2] = vpn[2];
Vector3D rotationAxis =
itk::CrossProduct( viewPlaneNormal, interactionMove );
rotationAxis.Normalize();
int *size = currentVtkRenderer->GetSize();
double l2 =
(m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) *
(m_CurrentPickedDisplayPoint[0] - m_InitialPickedDisplayPoint[0]) +
(m_CurrentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]) *
(m_CurrentPickedDisplayPoint[1] - m_InitialPickedDisplayPoint[1]);
double rotationAngle = 360.0 * sqrt(l2/(size[0]*size[0]+size[1]*size[1]));
// Use center of data bounding box as center of rotation
Point3D rotationCenter = m_OriginalGeometry->GetCenter();;
// Reset current Geometry3D to original state (pre-interaction) and
// apply rotation
RotationOperation op( OpROTATE, rotationCenter, rotationAxis, rotationAngle );
Geometry3D::Pointer newGeometry = static_cast< Geometry3D * >(
m_OriginalGeometry->Clone().GetPointer() );
newGeometry->ExecuteOperation( &op );
data->SetClonedGeometry(newGeometry, timeStep);
}
}
RenderingManager::GetInstance()->RequestUpdateAll();
ok = true;
break;
}
default:
return Superclass::ExecuteAction( action, stateEvent );
}
return ok;
}
void mitk::ComputeContourSetNormalsFilter::GenerateData()
{
unsigned int numberOfInputs = this->GetNumberOfIndexedInputs();
this->CreateOutputsForAllInputs(numberOfInputs);
//Iterating over each input
for(unsigned int i = 0; i < numberOfInputs; i++)
{
//Getting the inputs polydata and polygons
Surface* currentSurface = const_cast<Surface*>( this->GetInput(i) );
vtkPolyData* polyData = currentSurface->GetVtkPolyData();
vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
//The array that contains all the vertex normals of the current polygon
vtkSmartPointer<vtkDoubleArray> normals = vtkSmartPointer<vtkDoubleArray>::New();
normals->SetNumberOfComponents(3);
normals->SetNumberOfTuples(polyData->GetNumberOfPoints());
//If the current contour is an inner contour then the direction is -1
//A contour lies inside another one if the pixel values in the direction of the normal is 1
m_NegativeNormalCounter = 0;
m_PositiveNormalCounter = 0;
//Iterating over each polygon
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
if(cellSize < 3)continue;
//First we calculate the current polygon's normal
double polygonNormal[3] = {0.0};
double p1[3];
double p2[3];
double v1[3];
double v2[3];
existingPoints->GetPoint(cell[0], p1);
unsigned int index = cellSize*0.5;
existingPoints->GetPoint(cell[index], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
for (unsigned int k = 2; k < cellSize; k++)
{
index = cellSize*0.25;
existingPoints->GetPoint(cell[index], p1);
index = cellSize*0.75;
existingPoints->GetPoint(cell[index], p2);
v2[0] = p2[0]-p1[0];
v2[1] = p2[1]-p1[1];
v2[2] = p2[2]-p1[2];
vtkMath::Cross(v1,v2,polygonNormal);
if (vtkMath::Norm(polygonNormal) != 0)
break;
}
vtkMath::Normalize(polygonNormal);
//Now we start computing the normal for each vertex
double vertexNormalTemp[3];
existingPoints->GetPoint(cell[0], p1);
existingPoints->GetPoint(cell[1], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormalTemp);
vtkMath::Normalize(vertexNormalTemp);
double vertexNormal[3];
for (unsigned j = 0; j < cellSize-2; j++)
{
existingPoints->GetPoint(cell[j+1], p1);
existingPoints->GetPoint(cell[j+2], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormal);
vtkMath::Normalize(vertexNormal);
double finalNormal[3];
finalNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
finalNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
finalNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
//Here we determine the direction of the normal
if (j == 0 && m_SegmentationBinaryImage)
{
Point3D worldCoord;
worldCoord[0] = p1[0]+finalNormal[0]*m_MaxSpacing;
worldCoord[1] = p1[1]+finalNormal[1]*m_MaxSpacing;
worldCoord[2] = p1[2]+finalNormal[2]*m_MaxSpacing;
double val = 0.0;
mitk::ImagePixelReadAccessor<unsigned char> readAccess(m_SegmentationBinaryImage);
mitk::Index3D idx;
m_SegmentationBinaryImage->GetGeometry()->WorldToIndex(worldCoord, idx);
val = readAccess.GetPixelByIndexSafe(idx);
if (val == 1.0)
{
++m_PositiveNormalCounter;
}
else
{
++m_NegativeNormalCounter;
}
}
vertexNormalTemp[0] = vertexNormal[0];
vertexNormalTemp[1] = vertexNormal[1];
vertexNormalTemp[2] = vertexNormal[2];
vtkIdType id = cell[j+1];
normals->SetTuple(id,finalNormal);
}
existingPoints->GetPoint(cell[0], p1);
existingPoints->GetPoint(cell[1], p2);
v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
vtkMath::Cross(v1,polygonNormal,vertexNormal);
vtkMath::Normalize(vertexNormal);
vertexNormal[0] = (vertexNormal[0] + vertexNormalTemp[0])*0.5;
vertexNormal[1] = (vertexNormal[1] + vertexNormalTemp[1])*0.5;
vertexNormal[2] = (vertexNormal[2] + vertexNormalTemp[2])*0.5;
vtkIdType id = cell[0];
normals->SetTuple(id,vertexNormal);
id = cell[cellSize-1];
normals->SetTuple(id,vertexNormal);
int normalDirection(-1);
if(m_NegativeNormalCounter < m_PositiveNormalCounter)
{
normalDirection = 1;
}
for(unsigned int n = 0; n < normals->GetNumberOfTuples(); n++)
{
double normal[3];
normals->GetTuple(n,normal);
normal[0] = normalDirection*normal[0];
normal[1] = normalDirection*normal[1];
normal[2] = normalDirection*normal[2];
}
}//end for all cells
Surface::Pointer surface = this->GetOutput(i);
surface->GetVtkPolyData()->GetCellData()->SetNormals(normals);
}//end for all inputs
//Setting progressbar
if (this->m_UseProgressBar)
mitk::ProgressBar::GetInstance()->Progress(this->m_ProgressStepSize);
}
mitk::Surface::Pointer mitk::ComputeContourSetNormalsFilter::GetNormalsAsSurface()
{
//Just for debugging:
vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> newLines = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> newPoints = vtkSmartPointer<vtkPoints>::New();
unsigned int idCounter (0);
//Debug end
for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); i++)
{
Surface* currentSurface = const_cast<Surface*>( this->GetOutput(i) );
vtkPolyData* polyData = currentSurface->GetVtkPolyData();
vtkSmartPointer<vtkDoubleArray> currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
vtkSmartPointer<vtkCellArray> existingPolys = polyData->GetPolys();
vtkSmartPointer<vtkPoints> existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( unsigned int j = 0; j < cellSize; j++ )
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
line->GetPointIds()->SetNumberOfIds(2);
double newPoint[3];
double p0[3];
existingPoints->GetPoint(cell[j], p0);
newPoint[0] = p0[0] + currentNormal[0];
newPoint[1] = p0[1] + currentNormal[1];
newPoint[2] = p0[2] + currentNormal[2];
line->GetPointIds()->SetId(0, idCounter);
newPoints->InsertPoint(idCounter, p0);
idCounter++;
line->GetPointIds()->SetId(1, idCounter);
newPoints->InsertPoint(idCounter, newPoint);
idCounter++;
newLines->InsertNextCell(line);
}//end for all points
}//end for all cells
}//end for all outputs
newPolyData->SetPoints(newPoints);
newPolyData->SetLines(newLines);
newPolyData->BuildCells();
mitk::Surface::Pointer surface = mitk::Surface::New();
surface->SetVtkPolyData(newPolyData);
return surface;
}
void HeightFieldSurfaceClipImageFilter::GenerateData()
{
const Image *inputImage = this->GetInput(0);
const Image *outputImage = this->GetOutput();
m_InputTimeSelector->SetInput(inputImage);
m_OutputTimeSelector->SetInput(outputImage);
Image::RegionType outputRegion = outputImage->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = outputImage->GetTimeGeometry();
const TimeGeometry *inputTimeGeometry = inputImage->GetTimeGeometry();
ScalarType timeInMS;
int timestep = 0;
int tstart = outputRegion.GetIndex(3);
int tmax = tstart + outputRegion.GetSize(3);
for (unsigned int i = 1; i < this->GetNumberOfInputs(); ++i)
{
Surface *inputSurface = const_cast<Surface *>(dynamic_cast<Surface *>(itk::ProcessObject::GetInput(i)));
if (!outputImage->IsInitialized() || inputSurface == nullptr)
return;
MITK_INFO << "Plane: " << i;
MITK_INFO << "Clipping: Start\n";
// const PlaneGeometry *clippingGeometryOfCurrentTimeStep = nullptr;
int t;
for (t = tstart; t < tmax; ++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint(t);
timestep = inputTimeGeometry->TimePointToTimeStep(timeInMS);
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
// Compose IndexToWorld transform of image with WorldToIndexTransform of
// clipping data for conversion from image index space to plane index space
AffineTransform3D::Pointer planeWorldToIndexTransform = AffineTransform3D::New();
inputSurface->GetGeometry(t)->GetIndexToWorldTransform()->GetInverse(planeWorldToIndexTransform);
AffineTransform3D::Pointer imageToPlaneTransform = AffineTransform3D::New();
imageToPlaneTransform->SetIdentity();
imageToPlaneTransform->Compose(inputTimeGeometry->GetGeometryForTimeStep(t)->GetIndexToWorldTransform());
imageToPlaneTransform->Compose(planeWorldToIndexTransform);
MITK_INFO << "Accessing ITK function...\n";
if (i == 1)
{
AccessByItk_3(m_InputTimeSelector->GetOutput(),
_InternalComputeClippedImage,
this,
inputSurface->GetVtkPolyData(t),
imageToPlaneTransform);
}
else
{
mitk::Image::Pointer extensionImage = m_OutputTimeSelector->GetOutput()->Clone();
AccessByItk_3(
extensionImage, _InternalComputeClippedImage, this, inputSurface->GetVtkPolyData(t), imageToPlaneTransform);
}
if (m_ClippingMode == CLIPPING_MODE_MULTIPLANE)
m_MultiPlaneValue = m_MultiPlaneValue * 2;
}
}
m_TimeOfHeaderInitialization.Modified();
}
