mitk: mitkUnstructuredGridVtkMapper3D.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision: $
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 
00019 #include "mitkUnstructuredGridVtkMapper3D.h"
00020 #include "mitkDataNode.h"
00021 #include "mitkProperties.h"
00022 #include "mitkTransferFunctionProperty.h"
00023 #include "mitkColorProperty.h"
00024 //#include "mitkLookupTableProperty.h"
00025 #include "mitkGridRepresentationProperty.h"
00026 #include "mitkGridVolumeMapperProperty.h"
00027 #include "mitkVtkInterpolationProperty.h"
00028 #include "mitkVtkScalarModeProperty.h"
00029 
00030 #include "mitkDataStorage.h"
00031 
00032 #include "mitkSurfaceVtkMapper3D.h"
00033 
00034 #include <vtkUnstructuredGrid.h>
00035 #include <vtkVolume.h>
00036 #include <vtkVolumeProperty.h>
00037 #include <vtkProperty.h>
00038 
00039 #include <vtkPlanes.h>
00040 
00041 
00042 
00043 const mitk::UnstructuredGrid* mitk::UnstructuredGridVtkMapper3D::GetInput()
00044 {
00045   return static_cast<const mitk::UnstructuredGrid * > ( GetData() );
00046 }
00047 
00048 
00049 mitk::UnstructuredGridVtkMapper3D::UnstructuredGridVtkMapper3D()
00050 {
00051 
00052   m_VtkTriangleFilter = vtkDataSetTriangleFilter::New();
00053 
00054   m_Assembly = vtkAssembly::New();
00055 
00056   m_Volume = vtkVolume::New();
00057   m_Actor = vtkActor::New();
00058   m_ActorWireframe = vtkActor::New();
00059 
00060   m_VtkDataSetMapper = vtkUnstructuredGridMapper::New();
00061   m_VtkDataSetMapper->SetResolveCoincidentTopologyToPolygonOffset();
00062   m_VtkDataSetMapper->SetResolveCoincidentTopologyPolygonOffsetParameters(0,1);
00063   m_Actor->SetMapper(m_VtkDataSetMapper);
00064 
00065   m_VtkDataSetMapper2 = vtkUnstructuredGridMapper::New();
00066   m_VtkDataSetMapper2->SetResolveCoincidentTopologyToPolygonOffset();
00067   m_VtkDataSetMapper2->SetResolveCoincidentTopologyPolygonOffsetParameters(1,1);
00068   m_ActorWireframe->SetMapper(m_VtkDataSetMapper2);
00069   m_ActorWireframe->GetProperty()->SetRepresentationToWireframe();
00070 
00071   m_Assembly->AddPart(m_Actor);
00072   m_Assembly->AddPart(m_ActorWireframe);
00073   m_Assembly->AddPart(m_Volume);
00074 
00075   m_VtkVolumeRayCastMapper = 0;
00076   #if (VTK_MAJOR_VERSION >= 5)
00077   m_VtkPTMapper = 0;
00078   m_VtkVolumeZSweepMapper = 0;
00079   #endif
00080 
00081   //m_GenerateNormals = false;
00082 }
00083 
00084 
00085 mitk::UnstructuredGridVtkMapper3D::~UnstructuredGridVtkMapper3D()
00086 {
00087 
00088   if (m_VtkTriangleFilter != 0)
00089     m_VtkTriangleFilter->Delete();
00090 
00091   if (m_VtkVolumeRayCastMapper != 0)
00092     m_VtkVolumeRayCastMapper->Delete();
00093 
00094   #if (VTK_MAJOR_VERSION >= 5)
00095   if (m_VtkVolumeZSweepMapper != 0)
00096     m_VtkVolumeZSweepMapper->Delete();
00097 
00098   if (m_VtkPTMapper != 0)
00099     m_VtkPTMapper->Delete();
00100   #endif
00101 
00102   if (m_VtkDataSetMapper != 0)
00103     m_VtkDataSetMapper->Delete();
00104 
00105   if (m_VtkDataSetMapper2 != 0)
00106       m_VtkDataSetMapper2->Delete();
00107 
00108   if (m_Assembly != 0)
00109     m_Assembly->Delete();
00110 
00111   if (m_Actor != 0)
00112     m_Actor->Delete();
00113 
00114   if (m_ActorWireframe != 0)
00115       m_ActorWireframe->Delete();
00116 
00117   if (m_Volume != 0)
00118     m_Volume->Delete();
00119 
00120 }
00121 
00122 vtkProp* mitk::UnstructuredGridVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
00123 {
00124   return m_Assembly;
00125 }
00126 
00127 void mitk::UnstructuredGridVtkMapper3D::GenerateData()
00128 {
00129   m_Assembly->VisibilityOn();
00130 
00131   m_ActorWireframe->GetProperty()->SetAmbient(1.0);
00132   m_ActorWireframe->GetProperty()->SetDiffuse(0.0);
00133   m_ActorWireframe->GetProperty()->SetSpecular(0.0);
00134 }
00135 
00136 void mitk::UnstructuredGridVtkMapper3D::GenerateData(mitk::BaseRenderer* renderer)
00137 {
00138 
00139   if(!IsVisible(renderer))
00140   {
00141     m_Assembly->VisibilityOff();
00142     return;
00143   }
00144 
00145   //
00146   // get the TimeSlicedGeometry of the input object
00147   //
00148   mitk::UnstructuredGrid::Pointer input  = const_cast< mitk::UnstructuredGrid* >( this->GetInput() );
00149 
00150   //
00151   // set the input-object at time t for the mapper
00152   //
00153   vtkUnstructuredGrid * grid = input->GetVtkUnstructuredGrid( this->GetTimestep() );
00154   if(grid == 0)
00155   {
00156     m_Assembly->VisibilityOff();
00157     return;
00158   }
00159 
00160   m_Assembly->VisibilityOn();
00161 
00162   m_VtkTriangleFilter->SetInput(grid);
00163   m_VtkDataSetMapper->SetInput(grid);
00164   m_VtkDataSetMapper2->SetInput(grid);
00165 
00166   mitk::DataNode::ConstPointer node = this->GetDataNode();
00167   bool clip = false;
00168   node->GetBoolProperty("enable clipping", clip);
00169   mitk::DataNode::Pointer bbNode = renderer->GetDataStorage()->GetNamedDerivedNode("Clipping Bounding Object", node);
00170   if (clip && bbNode.IsNotNull())
00171   {
00172     m_VtkDataSetMapper->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
00173     m_VtkDataSetMapper2->SetBoundingObject(dynamic_cast<mitk::BoundingObject*>(bbNode->GetData()));
00174   }
00175   else
00176   {
00177     m_VtkDataSetMapper->SetBoundingObject(0);
00178     m_VtkDataSetMapper2->SetBoundingObject(0);
00179   }
00180 
00181   //
00182   // apply properties read from the PropertyList
00183   //
00184   ApplyProperties(0, renderer);
00185 }
00186 
00187 
00188 void mitk::UnstructuredGridVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
00189 {
00190   m_Assembly->VisibilityOff();
00191 }
00192 
00193 
00194 void mitk::UnstructuredGridVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer)
00195 {
00196   mitk::DataNode::Pointer node = this->GetDataNode();
00197   Superclass::ApplyProperties(m_Actor, renderer);
00198   Superclass::ApplyProperties(m_ActorWireframe, renderer);
00199 
00200   vtkVolumeProperty* volProp = m_Volume->GetProperty();
00201   vtkProperty* property = m_Actor->GetProperty();
00202 
00203   mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,property,renderer);
00204 
00205   mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(node,m_ActorWireframe->GetProperty(),renderer);
00206 
00207   mitk::TransferFunctionProperty::Pointer transferFuncProp;
00208   if (node->GetProperty(transferFuncProp, "TransferFunction", renderer))
00209   {
00210     mitk::TransferFunction::Pointer transferFunction = transferFuncProp->GetValue();
00211 
00212     volProp->SetColor(transferFunction->GetColorTransferFunction());
00213     volProp->SetScalarOpacity(transferFunction->GetScalarOpacityFunction());
00214 
00215     m_VtkDataSetMapper->SetLookupTable(transferFunction->GetColorTransferFunction());
00216     m_VtkDataSetMapper2->SetLookupTable(transferFunction->GetColorTransferFunction());
00217   }
00218 
00219   mitk::GridRepresentationProperty::Pointer gridRepProp;
00220   if (node->GetProperty(gridRepProp, "grid representation", renderer))
00221   {
00222     mitk::GridRepresentationProperty::IdType type = gridRepProp->GetValueAsId();
00223     bool isVolume = false;
00224     switch (type) {
00225       case mitk::GridRepresentationProperty::POINTS:
00226         property->SetRepresentationToPoints();
00227         break;
00228       case mitk::GridRepresentationProperty::WIREFRAME:
00229         property->SetRepresentationToWireframe();
00230         break;
00231       case mitk::GridRepresentationProperty::SURFACE:
00232         property->SetRepresentationToSurface();
00233         break;
00234       case mitk::GridRepresentationProperty::VOLUME:
00235         m_Assembly->RemovePart(m_Actor);
00236         m_Assembly->RemovePart(m_ActorWireframe);
00237         m_Assembly->AddPart(m_Volume);
00238         isVolume = true;
00239         break;
00240     }
00241 
00242     if (!isVolume) {
00243       m_Assembly->RemovePart(m_Volume);
00244       m_Assembly->AddPart(m_Actor);
00245       if (type == mitk::GridRepresentationProperty::SURFACE)
00246         m_Assembly->AddPart(m_ActorWireframe);
00247       else
00248         m_Assembly->RemovePart(m_ActorWireframe);
00249     }
00250 
00251 
00252   }
00253 
00254   mitk::GridVolumeMapperProperty::Pointer mapperProp;
00255   if (node->GetProperty(mapperProp, "grid volume mapper", renderer))
00256   {
00257     mitk::GridVolumeMapperProperty::IdType type = mapperProp->GetValueAsId();
00258     switch (type) {
00259       case mitk::GridVolumeMapperProperty::RAYCAST:
00260         if (m_VtkVolumeRayCastMapper == 0) {
00261           m_VtkVolumeRayCastMapper = vtkUnstructuredGridVolumeRayCastMapper::New();
00262           m_VtkVolumeRayCastMapper->SetInput(m_VtkTriangleFilter->GetOutput());
00263         }
00264         m_Volume->SetMapper(m_VtkVolumeRayCastMapper);
00265         break;
00266       #if (VTK_MAJOR_VERSION >= 5)
00267       case mitk::GridVolumeMapperProperty::PT:
00268         if (m_VtkPTMapper == 0) {
00269           m_VtkPTMapper = vtkProjectedTetrahedraMapper::New();
00270           m_VtkPTMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
00271         }
00272         m_Volume->SetMapper(m_VtkPTMapper);
00273         break;
00274       case mitk::GridVolumeMapperProperty::ZSWEEP:
00275         if (m_VtkVolumeZSweepMapper == 0) {
00276           m_VtkVolumeZSweepMapper = vtkUnstructuredGridVolumeZSweepMapper::New();
00277           m_VtkVolumeZSweepMapper->SetInputConnection(m_VtkTriangleFilter->GetOutputPort());
00278         }
00279         m_Volume->SetMapper(m_VtkVolumeZSweepMapper);
00280         break;
00281       #endif
00282     }
00283   }
00284 
00285 
00286 //   mitk::LevelWindow levelWindow;
00287 //   if(node->GetLevelWindow(levelWindow, renderer, "levelWindow"))
00288 //   {
00289 //     m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
00290 //   }
00291 //   else
00292 //   if(node->GetLevelWindow(levelWindow, renderer))
00293 //   {
00294 //     m_VtkVolumeRayCastMapper->SetScalarRange(levelWindow.GetMin(),levelWindow.GetMax());
00295 //   }
00296 //
00297 //   mitk::VtkRepresentationProperty* representationProperty;
00298 //   node->GetProperty(representationProperty, "material.representation", renderer);
00299 //   if ( representationProperty != NULL )
00300 //     m_Volume->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
00301 //
00302 //   mitk::VtkInterpolationProperty* interpolationProperty;
00303 //   node->GetProperty(interpolationProperty, "material.interpolation", renderer);
00304 //   if ( interpolationProperty != NULL )
00305 //     m_Volume->GetProperty()->SetInterpolation( interpolationProperty->GetVtkInterpolation() );
00306 //
00307 //   bool scalarVisibility = false;
00308 //   node->GetBoolProperty("scalar visibility", scalarVisibility);
00309 //   m_VtkVolumeRayCastMapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );
00310 //
00311 //   if(scalarVisibility)
00312 //   {
00313 //     mitk::VtkScalarModeProperty* scalarMode;
00314 //     if(node->GetProperty(scalarMode, "scalar mode", renderer))
00315 //     {
00316 //       m_VtkVolumeRayCastMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
00317 //     }
00318 //     else
00319 //       m_VtkVolumeRayCastMapper->SetScalarModeToDefault();
00320 //
00321 //     bool colorMode = false;
00322 //     node->GetBoolProperty("color mode", colorMode);
00323 //     m_VtkVolumeRayCastMapper->SetColorMode( (colorMode ? 1 : 0) );
00324 //
00325 //     float scalarsMin = 0;
00326 //     if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMinimum").GetPointer()) != NULL)
00327 //       scalarsMin = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMinimum").GetPointer())->GetValue();
00328 //
00329 //     float scalarsMax = 1.0;
00330 //     if (dynamic_cast<mitk::FloatProperty *>(node->GetProperty("ScalarsRangeMaximum").GetPointer()) != NULL)
00331 //       scalarsMax = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("ScalarsRangeMaximum").GetPointer())->GetValue();
00332 //
00333 //     m_VtkVolumeRayCastMapper->SetScalarRange(scalarsMin,scalarsMax);
00334 //   }
00335 }
00336 
00337 void mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
00338 {
00339 
00340   SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node, renderer, overwrite);
00341 
00342   //node->AddProperty("TransferFunction", TransferFunctionProperty::New(), renderer, overwrite);
00343   node->AddProperty("grid representation", GridRepresentationProperty::New(), renderer, overwrite);
00344   node->AddProperty("grid volume mapper", GridVolumeMapperProperty::New(), renderer, overwrite);
00345   node->AddProperty("scalar mode", VtkScalarModeProperty::New(0), renderer, overwrite);
00346   node->AddProperty("scalar visibility", BoolProperty::New(true), renderer, overwrite);
00347   node->AddProperty("outline polygons", BoolProperty::New(false), renderer, overwrite);
00348   node->AddProperty("color", ColorProperty::New(1.0f, 1.0f, 1.0f), renderer, overwrite);
00349   node->AddProperty("line width", IntProperty::New(1), renderer, overwrite);
00350 
00351   Superclass::SetDefaultProperties(node, renderer, overwrite);
00352 }
00353