自学教程：C++ GetDataNode函数代码示例

void mitk::DoseImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ){  LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);  mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );  mitk::DataNode* datanode = this->GetDataNode();  if ( input == NULL || input->IsInitialized() == false )  {    return;  }  //check if there is a valid worldGeometry  const PlaneGeometry *worldGeometry = renderer->GetCurrentWorldPlaneGeometry();  if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))  {    return;  }  input->Update();  // early out if there is no intersection of the current rendering geometry  // and the geometry of the image that is to be rendered.  if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )  {    // set image to NULL, to clear the texture in 3D, because    // the latest image is used there if the plane is out of the geometry    // see bug-13275    localStorage->m_ReslicedImage = NULL;    localStorage->m_Mapper->SetInputData( localStorage->m_EmptyPolyData );    return;  }  //set main input for ExtractSliceFilter  localStorage->m_Reslicer->SetInput(input);  localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);  localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );  //set the transformation of the image to adapt reslice axis  localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );  //is the geometry of the slice based on the input image or the worldgeometry?  bool inPlaneResampleExtentByGeometry = false;  datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);  localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);  // Initialize the interpolation mode for resampling; switch to nearest  // neighbor if the input image is too small.  if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )  {    VtkResliceInterpolationProperty *resliceInterpolationProperty;    datanode->GetProperty(      resliceInterpolationProperty, "reslice interpolation" );    int interpolationMode = VTK_RESLICE_NEAREST;    if ( resliceInterpolationProperty != NULL )    {      interpolationMode = resliceInterpolationProperty->GetInterpolation();    }    switch ( interpolationMode )    {    case VTK_RESLICE_NEAREST:      localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);      break;    case VTK_RESLICE_LINEAR:      localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);      break;    case VTK_RESLICE_CUBIC:      localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);      break;    }  }  else  {    localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);  }  //set the vtk output property to true, makes sure that no unneeded mitk image convertion  //is done.  localStorage->m_Reslicer->SetVtkOutputRequest(true);  //Thickslicing  int thickSlicesMode = 0;  int thickSlicesNum = 1;  // Thick slices parameters  if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed  {    DataNode *dn=renderer->GetCurrentWorldPlaneGeometryNode();    if(dn)    {      ResliceMethodProperty *resliceMethodEnumProperty=0;      if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )        thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();      IntProperty *intProperty=0;      if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )      {//.........这里部分代码省略.........

bool mitk::PointSetDataInteractor::InitMove(StateMachineAction*, InteractionEvent*){  GetDataNode()->SetProperty("contourcolor", ColorProperty::New(1.0, 1.0, 1.0));  return true;}

void mitk::UnstructuredGridMapper2D::Paint( mitk::BaseRenderer* renderer ){  bool visible = true;  GetDataNode()->GetVisibility(visible, renderer, "visible");  if(!visible) return;  vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform();  vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();  PlaneGeometry::ConstPointer worldGeometry = renderer->GetCurrentWorldPlaneGeometry();  PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );  Point3D point;  Vector3D normal;  if(worldPlaneGeometry.IsNotNull())  {    // set up vtkPlane according to worldGeometry    point=worldPlaneGeometry->GetOrigin();    normal=worldPlaneGeometry->GetNormal(); normal.Normalize();    m_Plane->SetTransform((vtkAbstractTransform*)NULL);  }  else  {    //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?    return;    AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldPlaneGeometry());    if(worldAbstractGeometry.IsNotNull())    {      // set up vtkPlane according to worldGeometry      point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();      FillVector3D(normal, 0, 0, 1);      m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());    }    else      return;  }  double vp[ 3 ], vnormal[ 3 ];  vnl2vtk(point.GetVnlVector(), vp);  vnl2vtk(normal.GetVnlVector(), vnormal);  //normally, we would need to transform the surface and cut the transformed surface with the cutter.  //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.  //@todo It probably does not work for scaling operations yet:scaling operations have to be  //dealed with after the cut is performed by scaling the contour.  inversetransform->TransformPoint( vp, vp );  inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );  m_Plane->SetOrigin( vp );  m_Plane->SetNormal( vnormal );  // set data into cutter  m_Slicer->SetInputData( m_VtkPointSet );  //    m_Cutter->GenerateCutScalarsOff();  //    m_Cutter->SetSortByToSortByCell();  // calculate the cut  m_Slicer->Update();  //apply color and opacity read from the PropertyList  ApplyColorAndOpacityProperties( renderer );  // traverse the cut contour  vtkPolyData * contour = m_Slicer->GetOutput();  vtkPoints *vpoints = contour->GetPoints();  vtkCellArray *vlines = contour->GetLines();  vtkCellArray *vpolys = contour->GetPolys();  vtkPointData *vpointdata = contour->GetPointData();  vtkDataArray* vscalars = vpointdata->GetScalars();  vtkCellData *vcelldata = contour->GetCellData();  vtkDataArray* vcellscalars = vcelldata->GetScalars();  const int numberOfLines = contour->GetNumberOfLines();  const int numberOfPolys = contour->GetNumberOfPolys();  const bool useCellData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT ||      m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA;  const bool usePointData = m_ScalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA;  Point3D p;  Point2D p2d;  vlines->InitTraversal();  vpolys->InitTraversal();  mitk::Color outlineColor = m_Color->GetColor();  glLineWidth((float)m_LineWidth->GetValue());  for (int i = 0;i < numberOfLines;++i )  {    vtkIdType *cell(0);    vtkIdType cellSize(0);    vlines->GetNextCell( cellSize, cell );//.........这里部分代码省略.........

void mitk::VolumeDataVtkMapper3D::UpdateTransferFunctions( mitk::BaseRenderer *renderer ){  vtkPiecewiseFunction *opacityTransferFunction = NULL;  vtkPiecewiseFunction *gradientTransferFunction = NULL;  vtkColorTransferFunction *colorTransferFunction = NULL;  mitk::LookupTableProperty::Pointer lookupTableProp;  lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));  mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction"));  if ( transferFunctionProp.IsNotNull() )   {    opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();    gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();    colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();  }  else if (lookupTableProp.IsNotNull() )  {    lookupTableProp->GetLookupTable()->CreateOpacityTransferFunction(opacityTransferFunction);    opacityTransferFunction->ClampingOn();    lookupTableProp->GetLookupTable()->CreateGradientTransferFunction(gradientTransferFunction);    gradientTransferFunction->ClampingOn();    lookupTableProp->GetLookupTable()->CreateColorTransferFunction(colorTransferFunction);    colorTransferFunction->ClampingOn();  }  else  {    opacityTransferFunction = m_DefaultOpacityTransferFunction;    gradientTransferFunction = m_DefaultGradientTransferFunction;    colorTransferFunction = m_DefaultColorTransferFunction;    float rgb[3]={1.0f,1.0f,1.0f};    // check for color prop and use it for rendering if it exists    if(GetDataNode()->GetColor(rgb, renderer, "color"))    {      colorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );      colorTransferFunction->AddRGBPoint( 127.5, rgb[0], rgb[1], rgb[2] );      colorTransferFunction->AddRGBPoint( 255.0, rgb[0], rgb[1], rgb[2] );    }  }  if (this->m_Mask)  {    opacityTransferFunction->AddPoint(0xffff, 0.0);  }  m_VolumePropertyLow->SetColor( colorTransferFunction );  m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );  m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );  m_VolumePropertyLow->SetInterpolationTypeToNearest();  m_VolumePropertyMed->SetColor( colorTransferFunction );  m_VolumePropertyMed->SetScalarOpacity( opacityTransferFunction );  m_VolumePropertyMed->SetGradientOpacity( gradientTransferFunction );  m_VolumePropertyMed->SetInterpolationTypeToNearest();  m_VolumePropertyHigh->SetColor( colorTransferFunction );  m_VolumePropertyHigh->SetScalarOpacity( opacityTransferFunction );  m_VolumePropertyHigh->SetGradientOpacity( gradientTransferFunction );  m_VolumePropertyHigh->SetInterpolationTypeToLinear();}

void mitk::PointSetVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer){  bool visible = true;  GetDataNode()->GetVisibility(visible, renderer, "visible");  if (!visible)  {    m_UnselectedActor->VisibilityOff();    m_SelectedActor->VisibilityOff();    m_ContourActor->VisibilityOff();    return;  }  // create new vtk render objects (e.g. sphere for a point)  SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);  SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);  BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);  bool needGenerateData = ls->IsGenerateDataRequired(renderer, this, GetDataNode());  if (!needGenerateData)  {    mitk::FloatProperty *pointSizeProp =      dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));    mitk::FloatProperty *contourSizeProp =      dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));    bool useVertexRendering = false;    this->GetDataNode()->GetBoolProperty("Vertex Rendering", useVertexRendering);    // only create new vtk render objects if property values were changed    if (pointSizeProp && m_PointSize != pointSizeProp->GetValue())      needGenerateData = true;    if (contourSizeProp && m_ContourRadius != contourSizeProp->GetValue())      needGenerateData = true;    // when vertex rendering is enabled the pointset is always    // drawn with opengl, thus we leave needGenerateData always false    if (useVertexRendering && m_VertexRendering != useVertexRendering)    {      needGenerateData = false;      m_VertexRendering = true;    }    else if (!useVertexRendering && m_VertexRendering)    {      m_VertexRendering = false;      needGenerateData = true;    }  }  if (needGenerateData)  {    this->CreateVTKRenderObjects();    ls->UpdateGenerateDataTime();  }  this->ApplyAllProperties(renderer, m_ContourActor);  bool showPoints = true;  this->GetDataNode()->GetBoolProperty("show points", showPoints);  m_UnselectedActor->SetVisibility(showPoints && !m_VertexRendering);  m_SelectedActor->SetVisibility(showPoints && !m_VertexRendering);  if (false && dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != nullptr)  {    mitk::FloatProperty::Pointer pointOpacity =      dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));    float opacity = pointOpacity->GetValue();    m_ContourActor->GetProperty()->SetOpacity(opacity);    m_UnselectedActor->GetProperty()->SetOpacity(opacity);    m_SelectedActor->GetProperty()->SetOpacity(opacity);  }  bool showContour = false;  this->GetDataNode()->GetBoolProperty("show contour", showContour);  m_ContourActor->SetVisibility(showContour);  // use vertex rendering  if (m_VertexRendering)  {    VertexRendering();    ls->UpdateGenerateDataTime();  }}

bool mitk::GPUVolumeMapper3D::IsRAYEnabled( mitk::BaseRenderer * renderer ){  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);  bool value = false;  return ls->m_raySupported && GetDataNode()->GetBoolProperty("volumerendering.useray",value,renderer) && value;}

const mitk::UnstructuredGrid* mitk::UnstructuredGridVtkMapper3D::GetInput(){  return static_cast<const mitk::UnstructuredGrid * > ( GetDataNode()->GetData() );}

const mitk::ContourModelSet* mitk::ContourModelSetMapper3D::GetInput( void ){  //convient way to get the data from the dataNode  return static_cast< const mitk::ContourModelSet * >( GetDataNode()->GetData() );}

mitk::FiberBundleX* mitk::FiberBundleXMapper2D::GetInput(){    return dynamic_cast< mitk::FiberBundleX * > ( GetDataNode()->GetData() );}

void mitk::PointSetVtkMapper2D::CreateVTKRenderObjects(mitk::BaseRenderer* renderer){  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);  unsigned i = 0;  // The vtk text actors need to be removed manually from the propassembly  // since the same vtk text actors are not overwriten within this function,  // but new actors are added to the propassembly each time this function is executed.  // Thus, the actors from the last call must be removed in the beginning.  for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)  {    if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextLabelActors.at(i)))      ls->m_PropAssembly->RemovePart(ls->m_VtkTextLabelActors.at(i));  }  for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)  {    if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextDistanceActors.at(i)))      ls->m_PropAssembly->RemovePart(ls->m_VtkTextDistanceActors.at(i));  }  for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)  {    if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextAngleActors.at(i)))      ls->m_PropAssembly->RemovePart(ls->m_VtkTextAngleActors.at(i));  }  // initialize polydata here, otherwise we have update problems when  // executing this function again  ls->m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();  ls->m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();  ls->m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();  // get input point set and update the PointSet  mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());  // only update the input data, if the property tells us to  bool update = true;  this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);  if (update == true)    input->Update();  int timestep = this->GetTimestep();  mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );  if ( itkPointSet.GetPointer() == NULL)  {    ls->m_PropAssembly->VisibilityOff();    return;  }  //iterator for point set  mitk::PointSet::PointsContainer::Iterator pointsIter = itkPointSet->GetPoints()->Begin();  // PointDataContainer has additional information to each point, e.g. whether  // it is selected or not  mitk::PointSet::PointDataContainer::Iterator pointDataIter;  pointDataIter = itkPointSet->GetPointData()->Begin();  //check if the list for the PointDataContainer is the same size as the PointsContainer.  //If not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)  bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());  if( itkPointSet->GetPointData()->size() == 0 || pointDataBroken)  {    ls->m_PropAssembly->VisibilityOff();    return;  }  ls->m_PropAssembly->VisibilityOn();  // empty point sets, cellarrays, scalars  ls->m_UnselectedPoints->Reset();  ls->m_SelectedPoints->Reset();  ls->m_ContourPoints->Reset();  ls->m_ContourLines->Reset();  ls->m_UnselectedScales->Reset();  ls->m_SelectedScales->Reset();  ls->m_DistancesBetweenPoints->Reset();  ls->m_VtkTextLabelActors.clear();  ls->m_VtkTextDistanceActors.clear();  ls->m_VtkTextAngleActors.clear();  ls->m_UnselectedScales->SetNumberOfComponents(3);  ls->m_SelectedScales->SetNumberOfComponents(3);  int NumberContourPoints = 0;  bool pointsOnSameSideOfPlane = false;  const int text2dDistance = 10;  // initialize points with a random start value  // current point in point set  itk::Point<ScalarType> point = pointsIter->Value();//.........这里部分代码省略.........

void mitk::PointSetVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ){  const mitk::DataNode* node = GetDataNode();  if( node == NULL )    return;  LocalStorage *ls = m_LSH.GetLocalStorage(renderer);  // check whether the input data has been changed  bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );  // toggle visibility  bool visible = true;  node->GetVisibility(visible, renderer, "visible");  if(!visible)  {    ls->m_UnselectedActor->VisibilityOff();    ls->m_SelectedActor->VisibilityOff();    ls->m_ContourActor->VisibilityOff();    ls->m_PropAssembly->VisibilityOff();    return;  }else{    ls->m_PropAssembly->VisibilityOn();  }  node->GetBoolProperty("show contour",       m_ShowContour, renderer);  node->GetBoolProperty("close contour",      m_CloseContour, renderer);  node->GetBoolProperty("show points",        m_ShowPoints, renderer);  node->GetBoolProperty("show distances",     m_ShowDistances, renderer);  node->GetIntProperty("distance decimal digits",     m_DistancesDecimalDigits, renderer);  node->GetBoolProperty("show angles",        m_ShowAngles, renderer);  node->GetBoolProperty("show distant lines", m_ShowDistantLines, renderer);  node->GetIntProperty("line width",          m_LineWidth, renderer);  node->GetIntProperty("point line width",    m_PointLineWidth, renderer);  node->GetIntProperty("point 2D size",       m_Point2DSize, renderer);  node->GetBoolProperty("Pointset.2D.fill shape", m_FillShape, renderer);  node->GetFloatProperty("Pointset.2D.distance to plane", m_DistanceToPlane, renderer );  mitk::PointSetShapeProperty::Pointer shape = dynamic_cast<mitk::PointSetShapeProperty*>(this->GetDataNode()->GetProperty( "Pointset.2D.shape", renderer ));  if(shape.IsNotNull())  {    m_IDShapeProperty = shape->GetPointSetShape();  }  //check for color props and use it for rendering of selected/unselected points and contour  //due to different params in VTK (double/float) we have to convert  float unselectedColor[4];  double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};    //red  double contourColor[4]={1.0f,0.0f,0.0f,1.0f};     //red  float opacity = 1.0;  GetDataNode()->GetOpacity(opacity, renderer);  // apply color and opacity  if(m_ShowPoints)  {    ls->m_UnselectedActor->VisibilityOn();    ls->m_SelectedActor->VisibilityOn();    //check if there is a color property    GetDataNode()->GetColor(unselectedColor);    //get selected color property    if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)    {      mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();      selectedColor[0] = tmpColor[0];      selectedColor[1] = tmpColor[1];      selectedColor[2] = tmpColor[2];      selectedColor[3] = 1.0f; // alpha value    }    else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)    {      mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();      selectedColor[0] = tmpColor[0];      selectedColor[1] = tmpColor[1];      selectedColor[2] = tmpColor[2];      selectedColor[3] = 1.0f; // alpha value    }    ls->m_SelectedActor->GetProperty()->SetColor(selectedColor);    ls->m_SelectedActor->GetProperty()->SetOpacity(opacity);    ls->m_UnselectedActor->GetProperty()->SetColor(unselectedColor[0],unselectedColor[1],unselectedColor[2]);    ls->m_UnselectedActor->GetProperty()->SetOpacity(opacity);  }  else  {    ls->m_UnselectedActor->VisibilityOff();    ls-> m_SelectedActor->VisibilityOff();  }  if (m_ShowContour)  {    ls->m_ContourActor->VisibilityOn();    //get contour color property    if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)//.........这里部分代码省略.........

void mitk::ConnectomicsNetworkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer){  if( this->GetInput() == NULL )  {    return;  }  bool propertiesHaveChanged = this->PropertiesChanged();  if( this->GetInput()->GetIsModified( ) || propertiesHaveChanged )  {  m_NetworkAssembly->Delete();  m_NetworkAssembly = vtkPropAssembly::New();  // Here is the part where a graph is given and converted to points and connections between points...  std::vector< mitk::ConnectomicsNetwork::NetworkNode > vectorOfNodes = this->GetInput()->GetVectorOfAllNodes();  std::vector< std::pair<    std::pair< mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode >    , mitk::ConnectomicsNetwork::NetworkEdge > >  vectorOfEdges = this->GetInput()->GetVectorOfAllEdges();  // Decide on the style of rendering due to property  if( m_ChosenRenderingScheme == connectomicsRenderingMITKScheme )  {    mitk::Point3D tempWorldPoint, tempCNFGeometryPoint;    //////////////////////Prepare coloring and radius////////////    std::vector< double > vectorOfNodeRadiusParameterValues;    vectorOfNodeRadiusParameterValues.resize( vectorOfNodes.size() );    double maxNodeRadiusParameterValue( FillNodeParameterVector( &vectorOfNodeRadiusParameterValues, m_NodeRadiusParameter ) );    std::vector< double > vectorOfNodeColorParameterValues;    vectorOfNodeColorParameterValues.resize( vectorOfNodes.size() );    double maxNodeColorParameterValue( FillNodeParameterVector( &vectorOfNodeColorParameterValues, m_NodeColorParameter ) );    std::vector< double > vectorOfEdgeRadiusParameterValues;    vectorOfEdgeRadiusParameterValues.resize( vectorOfEdges.size() );    double maxEdgeRadiusParameterValue( FillEdgeParameterVector( &vectorOfEdgeRadiusParameterValues, m_EdgeRadiusParameter ) );    std::vector< double > vectorOfEdgeColorParameterValues;    vectorOfEdgeColorParameterValues.resize( vectorOfEdges.size() );    double maxEdgeColorParameterValue( FillEdgeParameterVector( &vectorOfEdgeColorParameterValues, m_EdgeColorParameter ) );    //////////////////////Prepare Filtering//////////////////////    // true will be rendered    std::vector< bool > vectorOfNodeFilterBools( vectorOfNodes.size(), true );    if( m_ChosenNodeFilter == connectomicsRenderingNodeThresholdingFilter )    {      FillNodeFilterBoolVector( &vectorOfNodeFilterBools, m_NodeThresholdParameter );    }    std::vector< bool > vectorOfEdgeFilterBools( vectorOfEdges.size(), true );    if( m_ChosenEdgeFilter == connectomicsRenderingEdgeThresholdFilter )    {      FillEdgeFilterBoolVector( &vectorOfEdgeFilterBools, m_EdgeThresholdParameter );    }    //////////////////////Create Spheres/////////////////////////    for(unsigned int i = 0; i < vectorOfNodes.size(); i++)    {      vtkSmartPointer<vtkSphereSource> sphereSource =        vtkSmartPointer<vtkSphereSource>::New();      for(unsigned int dimension = 0; dimension < 3; dimension++)      {        tempCNFGeometryPoint.SetElement( dimension , vectorOfNodes[i].coordinates[dimension] );      }      GetDataNode()->GetData()->GetGeometry()->IndexToWorld( tempCNFGeometryPoint, tempWorldPoint );      sphereSource->SetCenter( tempWorldPoint[0] , tempWorldPoint[1], tempWorldPoint[2] );      // determine radius      double radiusFactor = vectorOfNodeRadiusParameterValues[i] / maxNodeRadiusParameterValue;      double radius = m_NodeRadiusStart + ( m_NodeRadiusEnd - m_NodeRadiusStart) * radiusFactor;      sphereSource->SetRadius( radius );      vtkSmartPointer<vtkPolyDataMapper> mapper =        vtkSmartPointer<vtkPolyDataMapper>::New();      mapper->SetInputConnection(sphereSource->GetOutputPort());      vtkSmartPointer<vtkActor> actor =        vtkSmartPointer<vtkActor>::New();      actor->SetMapper(mapper);      // determine color      double colorFactor = vectorOfNodeColorParameterValues[i] / maxNodeColorParameterValue;      double redStart = m_NodeColorStart.GetElement( 0 );      double greenStart = m_NodeColorStart.GetElement( 1 );      double blueStart = m_NodeColorStart.GetElement( 2 );      double redEnd = m_NodeColorEnd.GetElement( 0 );      double greenEnd = m_NodeColorEnd.GetElement( 1 );      double blueEnd = m_NodeColorEnd.GetElement( 2 );      double red = redStart + ( redEnd - redStart ) * colorFactor;      double green = greenStart + ( greenEnd - greenStart ) * colorFactor;//.........这里部分代码省略.........

void mitk::PointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ){  // create new vtk render objects (e.g. sphere for a point)  this->CreateVTKRenderObjects();  SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);  SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);  mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));  mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));  // only create new vtk render objects if property values were changed  if ( pointSizeProp.IsNotNull() &&  contourSizeProp.IsNotNull() )  {    if (m_PointSize!=pointSizeProp->GetValue() || m_ContourRadius!= contourSizeProp->GetValue())    {      this->CreateVTKRenderObjects();    }  }  this->ApplyAllProperties(renderer, m_ContourActor);  bool visible = true;  GetDataNode()->GetVisibility(visible, renderer, "visible");  if(!visible)  {    m_UnselectedActor->VisibilityOff();    m_SelectedActor->VisibilityOff();    m_ContourActor->VisibilityOff();    return;  }  bool showPoints = true;  this->GetDataNode()->GetBoolProperty("show points", showPoints);  if(showPoints)  {    m_UnselectedActor->VisibilityOn();    m_SelectedActor->VisibilityOn();  }  else  {    m_UnselectedActor->VisibilityOff();    m_SelectedActor->VisibilityOff();  }  if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)  {    mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));    float opacity = pointOpacity->GetValue();    m_ContourActor->GetProperty()->SetOpacity(opacity);    m_UnselectedActor->GetProperty()->SetOpacity(opacity);    m_SelectedActor->GetProperty()->SetOpacity(opacity);  }  bool makeContour = false;  this->GetDataNode()->GetBoolProperty("show contour", makeContour);  if (makeContour)  {    m_ContourActor->VisibilityOn();  }  else  {    m_ContourActor->VisibilityOff();  }}

vtkSmartPointer<vtkPolyData> mitk::DoseImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer* renderer ){  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); //the points to draw  vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); //the lines to connect the points  vtkSmartPointer<vtkUnsignedCharArray> colors = vtkSmartPointer<vtkUnsignedCharArray>::New();  colors->SetNumberOfComponents(3);  colors->SetName("Colors");  float pref;  this->GetDataNode()->GetFloatProperty(mitk::RTConstants::REFERENCE_DOSE_PROPERTY_NAME.c_str(),pref);  mitk::IsoDoseLevelSetProperty::Pointer propIsoSet = dynamic_cast<mitk::IsoDoseLevelSetProperty* >(GetDataNode()->GetProperty(mitk::RTConstants::DOSE_ISO_LEVELS_PROPERTY_NAME.c_str()));  mitk::IsoDoseLevelSet::Pointer isoDoseLevelSet = propIsoSet->GetValue();  for(mitk::IsoDoseLevelSet::ConstIterator doseIT = isoDoseLevelSet->Begin(); doseIT!=isoDoseLevelSet->End();++doseIT)  {    if(doseIT->GetVisibleIsoLine())    {      this->CreateLevelOutline(renderer, &(doseIT.Value()), pref, points, lines, colors);    }//end of if visible dose value  }//end of loop over all does values  mitk::IsoDoseLevelVectorProperty::Pointer propfreeIsoVec = dynamic_cast<mitk::IsoDoseLevelVectorProperty* >(GetDataNode()->GetProperty(mitk::RTConstants::DOSE_FREE_ISO_VALUES_PROPERTY_NAME.c_str()));  mitk::IsoDoseLevelVector::Pointer frereIsoDoseLevelVec = propfreeIsoVec->GetValue();  for(mitk::IsoDoseLevelVector::ConstIterator freeDoseIT = frereIsoDoseLevelVec->Begin(); freeDoseIT!=frereIsoDoseLevelVec->End();++freeDoseIT)  {    if(freeDoseIT->Value()->GetVisibleIsoLine())    {      this->CreateLevelOutline(renderer, freeDoseIT->Value(), pref, points, lines, colors);    }//end of if visible dose value  }//end of loop over all does values  // Create a polydata to store everything in  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();  // Add the points to the dataset  polyData->SetPoints(points);  // Add the lines to the dataset  polyData->SetLines(lines);  polyData->GetCellData()->SetScalars(colors);  return polyData;}

bool mitk::PlanarFigureInteractor::CheckFigureFinished( const InteractionEvent* /*interactionEvent*/ ){  mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );  return ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() );}

void mitk::VolumeDataVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ){  SetVtkMapperImmediateModeRendering(m_BoundingBoxMapper);  mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );  if ( !input || !input->IsInitialized() )    return;  vtkRenderWindow* renderWindow = renderer->GetRenderWindow();  bool volumeRenderingEnabled = true;  bool visible = true;  GetDataNode()->GetVisibility(visible, renderer, "visible");  if ( !visible ||      this->GetDataNode() == NULL ||      dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))==NULL ||      dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == false    )  {    volumeRenderingEnabled = false;    // Check if a bounding box should be displayed around the dataset    // (even if volume rendering is disabled)    bool hasBoundingBox = false;    this->GetDataNode()->GetBoolProperty( "bounding box", hasBoundingBox );    if ( !hasBoundingBox )    {      m_BoundingBoxActor->VisibilityOff();    }    else    {      m_BoundingBoxActor->VisibilityOn();      const BoundingBox::BoundsArrayType &bounds =        input->GetTimeSlicedGeometry()->GetBounds();      m_BoundingBox->SetBounds(        bounds[0], bounds[1],        bounds[2], bounds[3],        bounds[4], bounds[5] );      ColorProperty *colorProperty;      if ( this->GetDataNode()->GetProperty(        colorProperty, "color" ) )      {        const mitk::Color &color = colorProperty->GetColor();        m_BoundingBoxActor->GetProperty()->SetColor(          color[0], color[1], color[2] );      }      else      {        m_BoundingBoxActor->GetProperty()->SetColor(          1.0, 1.0, 1.0 );      }    }  }  // Don't do anything if VR is disabled  if ( !volumeRenderingEnabled )  {    m_VolumeLOD->VisibilityOff();    return;  }  else  {        mitk::VtkVolumeRenderingProperty* vrp=dynamic_cast<mitk::VtkVolumeRenderingProperty*>(GetDataNode()->GetProperty("volumerendering configuration",renderer));        if(vrp)        {          int renderingValue = vrp->GetValueAsId();          switch(renderingValue)          {              case  VTK_VOLUME_RAY_CAST_MIP_FUNCTION:              {                  vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();                  m_HiResMapper->SetVolumeRayCastFunction(mipFunction);                  mipFunction->Delete();                  MITK_INFO <<"in switch" <<std::endl;                  break;              }              case VTK_RAY_CAST_COMPOSITE_FUNCTION:              {                  vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();                  compositeFunction->SetCompositeMethodToClassifyFirst();                  m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);                  compositeFunction->Delete();                  break;              }              default:                  MITK_ERROR <<"Warning: invalid volume rendering option.  " << std::endl;          }        }    m_VolumeLOD->VisibilityOn();  }//.........这里部分代码省略.........

const mitk::Image* mitk::VolumeDataVtkMapper3D::GetInput(){  return static_cast<const mitk::Image*> ( GetDataNode()->GetData() );}

void mitk::PolyDataGLMapper2D::Paint( mitk::BaseRenderer * renderer ){    if ( IsVisible( renderer ) == false )        return ;    // ok, das ist aus GenerateData kopiert    mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetData() );    assert( input );    input->Update();    vtkPolyData * vtkpolydata = this->GetVtkPolyData();    assert( vtkpolydata );    vtkLinearTransform * vtktransform = GetDataNode() ->GetVtkTransform();    if (vtktransform)    {      vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();      Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();      PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );      if ( vtkpolydata != NULL )      {          Point3D point;          Vector3D normal;          if(worldPlaneGeometry.IsNotNull())          {            // set up vtkPlane according to worldGeometry            point=worldPlaneGeometry->GetOrigin();            normal=worldPlaneGeometry->GetNormal(); normal.Normalize();            m_Plane->SetTransform((vtkAbstractTransform*)NULL);          }          else          {            //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?            return;            AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());            if(worldAbstractGeometry.IsNotNull())            {              // set up vtkPlane according to worldGeometry              point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();              FillVector3D(normal, 0, 0, 1);              m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());            }            else              return;          }          vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];          vnl2vtk(point.Get_vnl_vector(), vp);          vnl2vtk(normal.Get_vnl_vector(), vnormal);          //normally, we would need to transform the surface and cut the transformed surface with the cutter.          //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.          //@todo It probably does not work for scaling operations yet:scaling operations have to be          //dealed with after the cut is performed by scaling the contour.          inversetransform->TransformPoint( vp, vp );          inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );          m_Plane->SetOrigin( vp );          m_Plane->SetNormal( vnormal );          // set data into cutter          m_Cutter->SetInput( vtkpolydata );          //    m_Cutter->GenerateCutScalarsOff();          //    m_Cutter->SetSortByToSortByCell();          // calculate the cut          m_Cutter->Update();          // fetch geometry          mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();          assert( displayGeometry );          //  float toGL=displayGeometry->GetSizeInDisplayUnits()[1];          //apply color and opacity read from the PropertyList          ApplyProperties( renderer );          // traverse the cut contour          vtkPolyData * contour = m_Cutter->GetOutput();          vtkPoints *vpoints = contour->GetPoints();          vtkCellArray *vpolys = contour->GetLines();          vtkPointData *vpointdata = contour->GetPointData();          vtkDataArray* vscalars = vpointdata->GetScalars();          vtkCellData *vcelldata = contour->GetCellData();          vtkDataArray* vcellscalars = vcelldata->GetScalars();          int i, numberOfCells = vpolys->GetNumberOfCells();          Point3D p;          Point2D p2d, last, first;//.........这里部分代码省略.........

const mitk::PointSet *mitk::PointSetVtkMapper3D::GetInput(){  return static_cast<const mitk::PointSet *>(GetDataNode()->GetData());}

const mitk::ConnectomicsNetwork *mitk::ConnectomicsNetworkMapper3D::GetInput(){  return static_cast<const mitk::ConnectomicsNetwork *>(GetDataNode()->GetData());}

bool mitk::PointSetDataInteractor::FinishMove(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent){  IsClosedContour(stateMachineAction, interactionEvent);  GetDataNode()->SetProperty("contourcolor", ColorProperty::New(1.0, 0.0, 0.0));  return true;}

void mitk::ConnectomicsNetworkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer){  if (this->GetInput() == nullptr)  {    m_TextOverlay3D->UnRegisterMicroservice();    return;  }  bool propertiesHaveChanged = this->PropertiesChanged();  if (this->GetInput()->GetIsModified() || propertiesHaveChanged)  {    m_NetworkAssembly->Delete();    m_NetworkAssembly = vtkPropAssembly::New();    // Here is the part where a graph is given and converted to points and connections between points...    std::vector<mitk::ConnectomicsNetwork::NetworkNode> vectorOfNodes = this->GetInput()->GetVectorOfAllNodes();    std::vector<std::pair<std::pair<mitk::ConnectomicsNetwork::NetworkNode, mitk::ConnectomicsNetwork::NetworkNode>,                          mitk::ConnectomicsNetwork::NetworkEdge>>      vectorOfEdges = this->GetInput()->GetVectorOfAllEdges();    // Decide on the style of rendering due to property    if (m_ChosenRenderingScheme == connectomicsRenderingMITKScheme)    {      mitk::Point3D tempWorldPoint, tempCNFGeometryPoint;      ////// Prepare BalloonWidgets/Overlays: ////////////////////      if ((m_ChosenNodeLabel == "" || m_ChosenNodeLabel == "-1") && m_TextOverlay3D)      {        m_TextOverlay3D->UnRegisterMicroservice();        GetDataNode()->SetProperty(          connectomicsRenderingBalloonTextName.c_str(), mitk::StringProperty::New(""), nullptr);        GetDataNode()->SetProperty(          connectomicsRenderingBalloonNodeStatsName.c_str(), mitk::StringProperty::New(""), nullptr);      }      //////////////////////Prepare coloring and radius////////////      std::vector<double> vectorOfNodeRadiusParameterValues;      vectorOfNodeRadiusParameterValues.resize(vectorOfNodes.size());      double maxNodeRadiusParameterValue(        FillNodeParameterVector(&vectorOfNodeRadiusParameterValues, m_NodeRadiusParameter));      std::vector<double> vectorOfNodeColorParameterValues;      vectorOfNodeColorParameterValues.resize(vectorOfNodes.size());      double maxNodeColorParameterValue(        FillNodeParameterVector(&vectorOfNodeColorParameterValues, m_NodeColorParameter));      std::vector<double> vectorOfEdgeRadiusParameterValues;      vectorOfEdgeRadiusParameterValues.resize(vectorOfEdges.size());      double maxEdgeRadiusParameterValue(        FillEdgeParameterVector(&vectorOfEdgeRadiusParameterValues, m_EdgeRadiusParameter));      std::vector<double> vectorOfEdgeColorParameterValues;      vectorOfEdgeColorParameterValues.resize(vectorOfEdges.size());      double maxEdgeColorParameterValue(        FillEdgeParameterVector(&vectorOfEdgeColorParameterValues, m_EdgeColorParameter));      //////////////////////Prepare Filtering//////////////////////      // true will be rendered      std::vector<bool> vectorOfNodeFilterBools(vectorOfNodes.size(), true);      if (m_ChosenNodeFilter == connectomicsRenderingNodeThresholdingFilter)      {        FillNodeFilterBoolVector(&vectorOfNodeFilterBools, m_NodeThresholdParameter);      }      std::vector<bool> vectorOfEdgeFilterBools(vectorOfEdges.size(), true);      if (m_ChosenEdgeFilter == connectomicsRenderingEdgeThresholdFilter)      {        FillEdgeFilterBoolVector(&vectorOfEdgeFilterBools, m_EdgeThresholdParameter);      }      //////////////////////Create Spheres/////////////////////////      std::stringstream        nodeLabelStream; // local stream variable to hold csv list of node label names and node label numbers.      for (unsigned int i = 0; i < vectorOfNodes.size(); i++)      {        vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();        for (unsigned int dimension = 0; dimension < 3; dimension++)        {          tempCNFGeometryPoint.SetElement(dimension, vectorOfNodes[i].coordinates[dimension]);        }        GetDataNode()->GetData()->GetGeometry()->IndexToWorld(tempCNFGeometryPoint, tempWorldPoint);        sphereSource->SetCenter(tempWorldPoint[0], tempWorldPoint[1], tempWorldPoint[2]);        // determine radius        double radiusFactor = vectorOfNodeRadiusParameterValues[i] / maxNodeRadiusParameterValue;        double radius = m_NodeRadiusStart + (m_NodeRadiusEnd - m_NodeRadiusStart) * radiusFactor;        sphereSource->SetRadius(radius);        vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();        mapper->SetInputConnection(sphereSource->GetOutputPort());        vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();        actor->SetMapper(mapper);//.........这里部分代码省略.........

const mitk::Image* mitk::DoseImageVtkMapper2D::GetInput( void ){  return static_cast< const mitk::Image * >( GetDataNode()->GetData() );}