mitkSurfaceVtkMapper3D.cpp
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 "mitkSurfaceVtkMapper3D.h" 00020 #include "mitkDataNode.h" 00021 #include "mitkProperties.h" 00022 #include "mitkColorProperty.h" 00023 #include "mitkLookupTableProperty.h" 00024 #include "mitkVtkRepresentationProperty.h" 00025 #include "mitkVtkInterpolationProperty.h" 00026 #include "mitkVtkScalarModeProperty.h" 00027 #include "mitkClippingProperty.h" 00028 00029 #include "mitkShaderProperty.h" 00030 #include "mitkShaderRepository.h" 00031 00032 00033 #include <vtkActor.h> 00034 #include <vtkProperty.h> 00035 #include <vtkPolyData.h> 00036 #include <vtkPolyDataMapper.h> 00037 #include <vtkPolyDataNormals.h> 00038 #include <vtkPointData.h> 00039 #include <vtkPlaneCollection.h> 00040 00041 00042 const mitk::Surface* mitk::SurfaceVtkMapper3D::GetInput() 00043 { 00044 return static_cast<const mitk::Surface * > ( GetData() ); 00045 } 00046 00047 mitk::SurfaceVtkMapper3D::SurfaceVtkMapper3D() 00048 { 00049 // m_Prop3D = vtkActor::New(); 00050 m_GenerateNormals = false; 00051 } 00052 00053 mitk::SurfaceVtkMapper3D::~SurfaceVtkMapper3D() 00054 { 00055 // m_Prop3D->Delete(); 00056 } 00057 00058 void mitk::SurfaceVtkMapper3D::GenerateData(mitk::BaseRenderer* renderer) 00059 { 00060 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00061 00062 bool visible = IsVisible(renderer); 00063 00064 if(visible==false) 00065 { 00066 ls->m_Actor->VisibilityOff(); 00067 return; 00068 } 00069 00070 // 00071 // set the input-object at time t for the mapper 00072 // 00073 mitk::Surface::Pointer input = const_cast< mitk::Surface* >( this->GetInput() ); 00074 vtkPolyData * polydata = input->GetVtkPolyData( this->GetTimestep() ); 00075 if(polydata == NULL) 00076 { 00077 ls->m_Actor->VisibilityOff(); 00078 return; 00079 } 00080 00081 if ( m_GenerateNormals ) 00082 { 00083 ls->m_VtkPolyDataNormals->SetInput( polydata ); 00084 ls->m_VtkPolyDataMapper->SetInput( ls->m_VtkPolyDataNormals->GetOutput() ); 00085 } 00086 else 00087 { 00088 ls->m_VtkPolyDataMapper->SetInput( polydata ); 00089 } 00090 00091 // 00092 // apply properties read from the PropertyList 00093 // 00094 ApplyProperties(ls->m_Actor, renderer); 00095 00096 if(visible) 00097 ls->m_Actor->VisibilityOn(); 00098 } 00099 00100 00101 void mitk::SurfaceVtkMapper3D::ResetMapper( BaseRenderer* renderer ) 00102 { 00103 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00104 ls->m_Actor->VisibilityOff(); 00105 } 00106 00107 void mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty* property, mitk::BaseRenderer* renderer) 00108 { 00109 // Colors 00110 { 00111 double ambient [3] = { 0.5,0.5,0.0 }; 00112 double diffuse [3] = { 0.5,0.5,0.0 }; 00113 double specular[3] = { 1.0,1.0,1.0 }; 00114 00115 float coeff_ambient = 0.5f; 00116 float coeff_diffuse = 0.5f; 00117 float coeff_specular= 0.5f; 00118 float power_specular=10.0f; 00119 00120 // Color 00121 { 00122 mitk::ColorProperty::Pointer p; 00123 node->GetProperty(p, "color", renderer); 00124 if(p.IsNotNull()) 00125 { 00126 mitk::Color c = p->GetColor(); 00127 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue(); 00128 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue(); 00129 // Setting specular color to the same, make physically no real sense, however vtk rendering slows down, if these colors are different. 00130 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue(); 00131 } 00132 } 00133 00134 // Ambient 00135 { 00136 mitk::ColorProperty::Pointer p; 00137 node->GetProperty(p, "material.ambientColor", renderer); 00138 if(p.IsNotNull()) 00139 { 00140 mitk::Color c = p->GetColor(); 00141 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue(); 00142 } 00143 } 00144 00145 // Diffuse 00146 { 00147 mitk::ColorProperty::Pointer p; 00148 node->GetProperty(p, "material.diffuseColor", renderer); 00149 if(p.IsNotNull()) 00150 { 00151 mitk::Color c = p->GetColor(); 00152 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue(); 00153 } 00154 } 00155 00156 // Specular 00157 { 00158 mitk::ColorProperty::Pointer p; 00159 node->GetProperty(p, "material.specularColor", renderer); 00160 if(p.IsNotNull()) 00161 { 00162 mitk::Color c = p->GetColor(); 00163 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue(); 00164 } 00165 } 00166 00167 // Ambient coeff 00168 { 00169 node->GetFloatProperty("material.ambientCoefficient", coeff_ambient, renderer); 00170 } 00171 00172 // Diffuse coeff 00173 { 00174 node->GetFloatProperty("material.diffuseCoefficient", coeff_diffuse, renderer); 00175 } 00176 00177 // Specular coeff 00178 { 00179 node->GetFloatProperty("material.specularCoefficient", coeff_specular, renderer); 00180 } 00181 00182 // Specular power 00183 { 00184 node->GetFloatProperty("material.specularPower", power_specular, renderer); 00185 } 00186 00187 property->SetAmbient( coeff_ambient ); 00188 property->SetDiffuse( coeff_diffuse ); 00189 property->SetSpecular( coeff_specular ); 00190 property->SetSpecularPower( power_specular ); 00191 00192 property->SetAmbientColor( ambient ); 00193 property->SetDiffuseColor( diffuse ); 00194 property->SetSpecularColor( specular ); 00195 } 00196 00197 // Render mode 00198 { 00199 // Opacity 00200 { 00201 float opacity = 1.0f; 00202 if( node->GetOpacity(opacity,renderer) ) 00203 property->SetOpacity( opacity ); 00204 } 00205 00206 // Wireframe line width 00207 { 00208 float lineWidth = 1; 00209 node->GetFloatProperty("material.wireframeLineWidth", lineWidth, renderer); 00210 property->SetLineWidth( lineWidth ); 00211 } 00212 00213 // Representation 00214 { 00215 mitk::VtkRepresentationProperty::Pointer p; 00216 node->GetProperty(p, "material.representation", renderer); 00217 if(p.IsNotNull()) 00218 property->SetRepresentation( p->GetVtkRepresentation() ); 00219 } 00220 00221 // Interpolation 00222 { 00223 mitk::VtkInterpolationProperty::Pointer p; 00224 node->GetProperty(p, "material.interpolation", renderer); 00225 if(p.IsNotNull()) 00226 property->SetInterpolation( p->GetVtkInterpolation() ); 00227 } 00228 } 00229 } 00230 00231 00232 00233 void mitk::SurfaceVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* renderer) 00234 { 00235 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00236 00237 // Applying shading properties 00238 { 00239 Superclass::ApplyProperties( ls->m_Actor, renderer ) ; 00240 // VTK Properties 00241 ApplyMitkPropertiesToVtkProperty( this->GetDataNode(), ls->m_Actor->GetProperty(), renderer ); 00242 // Shaders 00243 mitk::ShaderRepository::GetGlobalShaderRepository()->ApplyProperties(this->GetDataNode(),ls->m_Actor,renderer,ls->m_ShaderTimestampUpdate); 00244 } 00245 00246 mitk::LookupTableProperty::Pointer lookupTableProp; 00247 this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer); 00248 if (lookupTableProp.IsNotNull() ) 00249 { 00250 ls->m_VtkPolyDataMapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable()); 00251 } 00252 00253 mitk::LevelWindow levelWindow; 00254 if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow")) 00255 { 00256 ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound()); 00257 } 00258 else 00259 if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer)) 00260 { 00261 ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound()); 00262 } 00263 00264 bool scalarVisibility = false; 00265 this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility); 00266 ls->m_VtkPolyDataMapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) ); 00267 00268 if(scalarVisibility) 00269 { 00270 mitk::VtkScalarModeProperty* scalarMode; 00271 if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer)) 00272 { 00273 ls->m_VtkPolyDataMapper->SetScalarMode(scalarMode->GetVtkScalarMode()); 00274 } 00275 else 00276 ls->m_VtkPolyDataMapper->SetScalarModeToDefault(); 00277 00278 bool colorMode = false; 00279 this->GetDataNode()->GetBoolProperty("color mode", colorMode); 00280 ls->m_VtkPolyDataMapper->SetColorMode( (colorMode ? 1 : 0) ); 00281 00282 float scalarsMin = 0; 00283 if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL) 00284 scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue(); 00285 00286 float scalarsMax = 1.0; 00287 if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL) 00288 scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue(); 00289 00290 ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax); 00291 } 00292 00293 // deprecated settings 00294 bool deprecatedUseCellData = false; 00295 this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", deprecatedUseCellData); 00296 00297 bool deprecatedUsePointData = false; 00298 this->GetDataNode()->GetBoolProperty("deprecated usePointDataForColouring", deprecatedUsePointData); 00299 00300 if (deprecatedUseCellData) 00301 { 00302 ls->m_VtkPolyDataMapper->SetColorModeToDefault(); 00303 ls->m_VtkPolyDataMapper->SetScalarRange(0,255); 00304 ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); 00305 ls->m_VtkPolyDataMapper->SetScalarModeToUseCellData(); 00306 ls->m_Actor->GetProperty()->SetSpecular (1); 00307 ls->m_Actor->GetProperty()->SetSpecularPower (50); 00308 ls->m_Actor->GetProperty()->SetInterpolationToPhong(); 00309 } 00310 else if (deprecatedUsePointData) 00311 { 00312 float scalarsMin = 0; 00313 if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL) 00314 scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue(); 00315 00316 float scalarsMax = 0.1; 00317 if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL) 00318 scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue(); 00319 00320 ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax); 00321 ls->m_VtkPolyDataMapper->SetColorModeToMapScalars(); 00322 ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); 00323 ls->m_Actor->GetProperty()->SetSpecular (1); 00324 ls->m_Actor->GetProperty()->SetSpecularPower (50); 00325 ls->m_Actor->GetProperty()->SetInterpolationToPhong(); 00326 } 00327 00328 int deprecatedScalarMode = VTK_COLOR_MODE_DEFAULT; 00329 if(this->GetDataNode()->GetIntProperty("deprecated scalar mode", deprecatedScalarMode, renderer)) 00330 { 00331 ls->m_VtkPolyDataMapper->SetScalarMode(deprecatedScalarMode); 00332 ls->m_VtkPolyDataMapper->ScalarVisibilityOn(); 00333 ls->m_Actor->GetProperty()->SetSpecular (1); 00334 ls->m_Actor->GetProperty()->SetSpecularPower (50); 00335 //m_Actor->GetProperty()->SetInterpolationToPhong(); 00336 } 00337 00338 00339 // Check whether one or more ClippingProperty objects have been defined for 00340 // this node. Check both renderer specific and global property lists, since 00341 // properties in both should be considered. 00342 const PropertyList::PropertyMap *rendererProperties = this->GetDataNode()->GetPropertyList( renderer )->GetMap(); 00343 const PropertyList::PropertyMap *globalProperties = this->GetDataNode()->GetPropertyList( NULL )->GetMap(); 00344 00345 // Add clipping planes (if any) 00346 ls->m_ClippingPlaneCollection->RemoveAllItems(); 00347 00348 PropertyList::PropertyMap::const_iterator it; 00349 for ( it = rendererProperties->begin(); it != rendererProperties->end(); ++it ) 00350 { 00351 this->CheckForClippingProperty( renderer,(*it).second.first.GetPointer() ); 00352 } 00353 00354 for ( it = globalProperties->begin(); it != globalProperties->end(); ++it ) 00355 { 00356 this->CheckForClippingProperty( renderer,(*it).second.first.GetPointer() ); 00357 } 00358 00359 if ( ls->m_ClippingPlaneCollection->GetNumberOfItems() > 0 ) 00360 { 00361 ls->m_VtkPolyDataMapper->SetClippingPlanes( ls->m_ClippingPlaneCollection ); 00362 } 00363 else 00364 { 00365 ls->m_VtkPolyDataMapper->RemoveAllClippingPlanes(); 00366 } 00367 00368 00369 } 00370 00371 vtkProp *mitk::SurfaceVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) 00372 { 00373 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00374 return ls->m_Actor; 00375 } 00376 00377 void mitk::SurfaceVtkMapper3D::CheckForClippingProperty( mitk::BaseRenderer* renderer, mitk::BaseProperty *property ) 00378 { 00379 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00380 // m_Prop3D = ls->m_Actor; 00381 00382 ClippingProperty *clippingProperty = dynamic_cast< ClippingProperty * >( property ); 00383 00384 if ( (clippingProperty != NULL) 00385 && (clippingProperty->GetClippingEnabled()) ) 00386 { 00387 const Point3D &origin = clippingProperty->GetOrigin(); 00388 const Vector3D &normal = clippingProperty->GetNormal(); 00389 00390 vtkPlane *clippingPlane = vtkPlane::New(); 00391 clippingPlane->SetOrigin( origin[0], origin[1], origin[2] ); 00392 clippingPlane->SetNormal( normal[0], normal[1], normal[2] ); 00393 00394 ls->m_ClippingPlaneCollection->AddItem( clippingPlane ); 00395 00396 clippingPlane->UnRegister( NULL ); 00397 } 00398 } 00399 00400 00401 void mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) 00402 { 00403 // Shading 00404 { 00405 node->AddProperty( "material.wireframeLineWidth", mitk::FloatProperty::New(1.0f) , renderer, overwrite ); 00406 00407 node->AddProperty( "material.ambientCoefficient" , mitk::FloatProperty::New(0.05f) , renderer, overwrite ); 00408 node->AddProperty( "material.diffuseCoefficient" , mitk::FloatProperty::New(0.9f) , renderer, overwrite ); 00409 node->AddProperty( "material.specularCoefficient", mitk::FloatProperty::New(1.0f) , renderer, overwrite ); 00410 node->AddProperty( "material.specularPower" , mitk::FloatProperty::New(16.0f) , renderer, overwrite ); 00411 00412 //node->AddProperty( "material.ambientColor" , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite ); 00413 //node->AddProperty( "material.diffuseColor" , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite ); 00414 //node->AddProperty( "material.specularColor" , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite ); 00415 00416 node->AddProperty( "material.representation" , mitk::VtkRepresentationProperty::New() , renderer, overwrite ); 00417 node->AddProperty( "material.interpolation" , mitk::VtkInterpolationProperty::New() , renderer, overwrite ); 00418 } 00419 00420 // Shaders 00421 { 00422 mitk::ShaderRepository::GetGlobalShaderRepository()->AddDefaultProperties(node,renderer,overwrite); 00423 } 00424 } 00425 00426 00427 void mitk::SurfaceVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) 00428 { 00429 node->AddProperty( "color", mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite ); 00430 node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite ); 00431 00432 mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node,renderer,overwrite); // Shading 00433 00434 node->AddProperty( "scalar visibility", mitk::BoolProperty::New(false), renderer, overwrite ); 00435 node->AddProperty( "color mode", mitk::BoolProperty::New(false), renderer, overwrite ); 00436 node->AddProperty( "scalar mode", mitk::VtkScalarModeProperty::New(), renderer, overwrite ); 00437 mitk::Surface::Pointer surface = dynamic_cast<Surface*>(node->GetData()); 00438 if(surface.IsNotNull()) 00439 { 00440 if((surface->GetVtkPolyData() != 0) && (surface->GetVtkPolyData()->GetPointData() != NULL) && (surface->GetVtkPolyData()->GetPointData()->GetScalars() != 0)) 00441 { 00442 node->AddProperty( "scalar visibility", mitk::BoolProperty::New(true), renderer, overwrite ); 00443 node->AddProperty( "color mode", mitk::BoolProperty::New(true), renderer, overwrite ); 00444 } 00445 } 00446 Superclass::SetDefaultProperties(node, renderer, overwrite); 00447 } 00448 00449 00450 void mitk::SurfaceVtkMapper3D::SetImmediateModeRenderingOn(int /*on*/) 00451 { 00452 /* 00453 if (m_VtkPolyDataMapper != NULL) 00454 m_VtkPolyDataMapper->SetImmediateModeRendering(on); 00455 */ 00456 }
