mitkGPUVolumeMapper3D.cpp
Go to the documentation of this file.
00001 /*========================================================================= 00002 00003 Program: Medical Imaging & Interaction Toolkit 00004 Language: C++ 00005 Date: $Date: 2009-06-18 15:59:04 +0200 (Thu, 18 Jun 2009) $ 00006 Version: $Revision: 17786 $ 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 #define GPU_INFO MITK_INFO("mapper.vr") 00019 #define GPU_WARN MITK_WARN("mapper.vr") 00020 #define GPU_ERROR MITK_ERROR("mapper.vr") 00021 00022 #include "mitkGPUVolumeMapper3D.h" 00023 00024 #include "mitkDataNode.h" 00025 00026 #include "mitkProperties.h" 00027 #include "mitkLevelWindow.h" 00028 #include "mitkColorProperty.h" 00029 #include "mitkLevelWindowProperty.h" 00030 #include "mitkLookupTableProperty.h" 00031 #include "mitkTransferFunctionProperty.h" 00032 #include "mitkTransferFunctionInitializer.h" 00033 #include "mitkColorProperty.h" 00034 #include "mitkVtkPropRenderer.h" 00035 #include "mitkRenderingManager.h" 00036 00037 #include <vtkActor.h> 00038 #include <vtkProperty.h> 00039 00040 #include <vtkVolumeTextureMapper2D.h> 00041 #include <vtkVolume.h> 00042 #include <vtkVolumeProperty.h> 00043 #include <vtkColorTransferFunction.h> 00044 #include <vtkPiecewiseFunction.h> 00045 #include <vtkVolumeRayCastCompositeFunction.h> 00046 #include <vtkVolumeRayCastMIPFunction.h> 00047 #include <vtkFiniteDifferenceGradientEstimator.h> 00048 #include <vtkRenderWindow.h> 00049 #include <vtkRenderWindowInteractor.h> 00050 #include <vtkImageWriter.h> 00051 #include <vtkImageData.h> 00052 #include <vtkLODProp3D.h> 00053 #include <vtkImageResample.h> 00054 #include <vtkPlane.h> 00055 #include <vtkImplicitPlaneWidget.h> 00056 #include <vtkAssembly.h> 00057 00058 #include <vtkCubeSource.h> 00059 #include <vtkPolyDataMapper.h> 00060 00061 #include <itkMultiThreader.h> 00062 00063 // Only with VTK 5.6 or above 00064 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00065 00066 #include "vtkMitkGPUVolumeRayCastMapper.h" 00067 00068 #endif 00069 00070 #include "vtkMitkOpenGLGPUVolumeRayCastMapper.h" 00071 #include "vtkMitkOpenGLVolumeTextureMapper3D.h" 00072 00073 00074 const mitk::Image* mitk::GPUVolumeMapper3D::GetInput() 00075 { 00076 return static_cast<const mitk::Image*> ( GetData() ); 00077 } 00078 00079 void mitk::GPUVolumeMapper3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer* renderer) 00080 { 00081 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00082 00083 VtkMapper3D::MitkRenderVolumetricGeometry(renderer); 00084 00085 if(ls->m_gpuInitialized) 00086 ls->m_MapperGPU->UpdateMTime(); 00087 } 00088 00089 bool mitk::GPUVolumeMapper3D::InitGPU(mitk::BaseRenderer* renderer) 00090 { 00091 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00092 00093 if(ls->m_gpuInitialized) 00094 return ls->m_gpuSupported; 00095 00096 // GPU_INFO << "initializing hardware-accelerated (slicing) renderer"; 00097 ls->m_MapperGPU = vtkMitkOpenGLVolumeTextureMapper3D::New(); 00098 ls->m_MapperGPU->SetUseCompressedTexture(false); 00099 ls->m_MapperGPU->SetSampleDistance(1.0); 00100 00101 ls->m_VolumePropertyGPU = vtkVolumeProperty::New(); 00102 ls->m_VolumePropertyGPU->ShadeOn(); 00103 ls->m_VolumePropertyGPU->SetAmbient (0.25f); //0.05f 00104 ls->m_VolumePropertyGPU->SetDiffuse (0.50f); //0.45f 00105 ls->m_VolumePropertyGPU->SetSpecular(0.40f); //0.50f 00106 ls->m_VolumePropertyGPU->SetSpecularPower(16.0f); 00107 ls->m_VolumePropertyGPU->SetInterpolationTypeToLinear(); 00108 00109 ls->m_VolumeGPU = vtkVolume::New(); 00110 ls->m_VolumeGPU->SetMapper( ls->m_MapperGPU ); 00111 ls->m_VolumeGPU->SetProperty( ls->m_VolumePropertyGPU ); 00112 ls->m_VolumeGPU->VisibilityOn(); 00113 00114 ls->m_MapperGPU->SetInput( this->m_UnitSpacingImageFilter->GetOutput() ); 00115 00116 ls->m_gpuSupported = ls->m_MapperGPU->IsRenderSupported(renderer->GetVtkRenderer(),ls->m_VolumePropertyGPU); 00117 00118 if(!ls->m_gpuSupported) 00119 GPU_INFO << "hardware-accelerated (slicing) rendering is not supported"; 00120 00121 ls->m_gpuInitialized = true; 00122 00123 return ls->m_gpuSupported; 00124 } 00125 00126 void mitk::GPUVolumeMapper3D::InitCPU(mitk::BaseRenderer* renderer) 00127 { 00128 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00129 00130 if(ls->m_cpuInitialized) 00131 return; 00132 00133 // GPU_INFO << "initializing software (raycast) renderer"; 00134 ls->m_MapperCPU = vtkFixedPointVolumeRayCastMapper::New(); 00135 ls->m_MapperCPU->SetSampleDistance(1.0); 00136 // ls->m_MapperCPU->LockSampleDistanceToInputSpacingOn(); 00137 ls->m_MapperCPU->SetImageSampleDistance(1.0); 00138 ls->m_MapperCPU->IntermixIntersectingGeometryOn(); 00139 ls->m_MapperCPU->SetAutoAdjustSampleDistances(0); 00140 00141 int numThreads = itk::MultiThreader::GetGlobalDefaultNumberOfThreads(); 00142 00143 ls->m_MapperCPU->SetNumberOfThreads( numThreads ); 00144 00145 ls->m_VolumePropertyCPU = vtkVolumeProperty::New(); 00146 ls->m_VolumePropertyCPU->ShadeOn(); 00147 ls->m_VolumePropertyCPU->SetAmbient (0.10f); //0.05f 00148 ls->m_VolumePropertyCPU->SetDiffuse (0.50f); //0.45f 00149 ls->m_VolumePropertyCPU->SetSpecular(0.40f); //0.50f 00150 ls->m_VolumePropertyCPU->SetSpecularPower(16.0f); 00151 ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear(); 00152 00153 ls->m_VolumeCPU = vtkVolume::New(); 00154 ls->m_VolumeCPU->SetMapper( ls->m_MapperCPU ); 00155 ls->m_VolumeCPU->SetProperty( ls->m_VolumePropertyCPU ); 00156 ls->m_VolumeCPU->VisibilityOn(); 00157 00158 ls->m_MapperCPU->SetInput( m_UnitSpacingImageFilter->GetOutput() );//m_Resampler->GetOutput()); 00159 00160 // GPU_INFO << "software (raycast) renderer uses " << numThreads << " threads"; 00161 00162 ls->m_cpuInitialized=true; 00163 } 00164 00165 void mitk::GPUVolumeMapper3D::DeinitGPU(mitk::BaseRenderer* renderer) 00166 { 00167 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00168 00169 if(ls->m_gpuInitialized) 00170 { 00171 // GPU_INFO << "deinitializing hardware (slicing) renderer"; 00172 00173 ls->m_VolumeGPU->Delete(); 00174 ls->m_MapperGPU->Delete(); 00175 ls->m_VolumePropertyGPU->Delete(); 00176 ls->m_gpuInitialized=false; 00177 } 00178 } 00179 00180 void mitk::GPUVolumeMapper3D::DeinitCPU(mitk::BaseRenderer* renderer) 00181 { 00182 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00183 00184 if(!ls->m_cpuInitialized) 00185 return; 00186 00187 // GPU_INFO << "deinitializing software (raycast) renderer"; 00188 ls->m_VolumeCPU->Delete(); 00189 ls->m_MapperCPU->Delete(); 00190 ls->m_VolumePropertyCPU->Delete(); 00191 ls->m_cpuInitialized=false; 00192 } 00193 00194 00195 mitk::GPUVolumeMapper3D::GPUVolumeMapper3D() 00196 { 00197 m_VolumeNULL=0; 00198 m_commonInitialized=false; 00199 } 00200 00201 00202 mitk::GPUVolumeMapper3D::~GPUVolumeMapper3D() 00203 { 00204 DeinitCommon(); 00205 if(m_VolumeNULL) 00206 m_VolumeNULL->Delete(); 00207 } 00208 00209 void mitk::GPUVolumeMapper3D::InitCommon() 00210 { 00211 if(m_commonInitialized) 00212 return; 00213 00214 m_UnitSpacingImageFilter = vtkImageChangeInformation::New(); 00215 m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 ); 00216 00217 CreateDefaultTransferFunctions(); 00218 00219 m_commonInitialized=true; 00220 } 00221 00222 void mitk::GPUVolumeMapper3D::DeinitCommon() 00223 { 00224 if(!m_commonInitialized) 00225 return; 00226 00227 m_UnitSpacingImageFilter->Delete(); 00228 00229 m_DefaultColorTransferFunction->Delete(); 00230 m_DefaultOpacityTransferFunction->Delete(); 00231 m_DefaultGradientTransferFunction->Delete(); 00232 m_BinaryColorTransferFunction->Delete(); 00233 m_BinaryOpacityTransferFunction->Delete(); 00234 m_BinaryGradientTransferFunction->Delete(); 00235 00236 m_commonInitialized=false; 00237 } 00238 00239 bool mitk::GPUVolumeMapper3D::IsRenderable(mitk::BaseRenderer* renderer) 00240 { 00241 if(!IsVisible(renderer)) 00242 return false; 00243 00244 if(!GetDataNode()) 00245 return false; 00246 00247 bool value = false; 00248 00249 if(!GetDataNode()->GetBoolProperty("volumerendering",value,renderer)) 00250 return false; 00251 00252 if(!value) 00253 return false; 00254 00255 mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() ); 00256 00257 if ( !input || !input->IsInitialized() ) 00258 return false; 00259 00260 vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() ); 00261 00262 if(inputData==NULL) 00263 return false; 00264 00265 return true; 00266 } 00267 00268 vtkProp *mitk::GPUVolumeMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) 00269 { 00270 if(!IsRenderable(renderer)) 00271 { 00272 if(!m_VolumeNULL) 00273 { 00274 m_VolumeNULL = vtkVolume::New(); 00275 m_VolumeNULL->VisibilityOff(); 00276 } 00277 return m_VolumeNULL; 00278 } 00279 00280 InitCommon(); 00281 00282 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00283 00284 // Only with VTK 5.6 or above 00285 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00286 00287 if(IsRAYEnabled(renderer)) 00288 { 00289 DeinitCPU(renderer); 00290 DeinitGPU(renderer); 00291 if(!InitRAY(renderer)) 00292 goto fallback; 00293 return ls->m_VolumeRAY; 00294 } 00295 else 00296 00297 #endif 00298 00299 if(IsGPUEnabled(renderer)) 00300 { 00301 DeinitCPU(renderer); 00302 // Only with VTK 5.6 or above 00303 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00304 DeinitRAY(renderer); 00305 #endif 00306 if(!InitGPU(renderer)) 00307 goto fallback; 00308 return ls->m_VolumeGPU; 00309 } 00310 else 00311 { 00312 fallback: 00313 DeinitGPU(renderer); 00314 // Only with VTK 5.6 or above 00315 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00316 DeinitRAY(renderer); 00317 #endif 00318 InitCPU(renderer); 00319 return ls->m_VolumeCPU; 00320 } 00321 } 00322 00323 00324 void mitk::GPUVolumeMapper3D::GenerateData( mitk::BaseRenderer *renderer ) 00325 { 00326 if(!IsRenderable(renderer)) 00327 return; 00328 00329 InitCommon(); 00330 00331 mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() ); 00332 vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() ); 00333 m_UnitSpacingImageFilter->SetInput( inputData ); 00334 00335 // Only with VTK 5.6 or above 00336 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00337 00338 if(IsRAYEnabled(renderer)) 00339 { 00340 DeinitCPU(renderer); 00341 DeinitGPU(renderer); 00342 if(!InitRAY(renderer)) 00343 goto fallback; 00344 GenerateDataRAY(renderer); 00345 } 00346 else 00347 00348 #endif 00349 00350 if(IsGPUEnabled(renderer)) 00351 { 00352 DeinitCPU(renderer); 00353 // Only with VTK 5.6 or above 00354 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00355 DeinitRAY(renderer); 00356 #endif 00357 if(!InitGPU(renderer)) 00358 goto fallback; 00359 GenerateDataGPU(renderer); 00360 } 00361 else 00362 { 00363 fallback: 00364 DeinitGPU(renderer); 00365 // Only with VTK 5.6 or above 00366 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00367 DeinitRAY(renderer); 00368 #endif 00369 InitCPU(renderer); 00370 GenerateDataCPU(renderer); 00371 } 00372 00373 // UpdateTransferFunctions 00374 UpdateTransferFunctions( renderer ); 00375 } 00376 00377 void mitk::GPUVolumeMapper3D::GenerateDataGPU( mitk::BaseRenderer *renderer ) 00378 { 00379 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00380 00381 bool useCompression = false; 00382 GetDataNode()->GetBoolProperty("volumerendering.gpu.usetexturecompression",useCompression,renderer); 00383 ls->m_MapperGPU->SetUseCompressedTexture(useCompression); 00384 00385 if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 ) 00386 ls->m_MapperGPU->SetSampleDistance(2.0); 00387 else 00388 ls->m_MapperGPU->SetSampleDistance(1.0); 00389 00390 // Updating shadings 00391 { 00392 float value=0; 00393 if(GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient",value,renderer)) 00394 ls->m_VolumePropertyGPU->SetAmbient(value); 00395 if(GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse",value,renderer)) 00396 ls->m_VolumePropertyGPU->SetDiffuse(value); 00397 if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular",value,renderer)) 00398 ls->m_VolumePropertyGPU->SetSpecular(value); 00399 if(GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power",value,renderer)) 00400 ls->m_VolumePropertyGPU->SetSpecularPower(value); 00401 } 00402 } 00403 00404 void mitk::GPUVolumeMapper3D::GenerateDataCPU( mitk::BaseRenderer *renderer ) 00405 { 00406 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00407 00408 int nextLod = mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ); 00409 00410 if( IsLODEnabled(renderer) && nextLod == 0 ) 00411 { 00412 ls->m_MapperCPU->SetImageSampleDistance(3.5); 00413 ls->m_MapperCPU->SetSampleDistance(1.25); 00414 ls->m_VolumePropertyCPU->SetInterpolationTypeToNearest(); 00415 } 00416 else 00417 { 00418 ls->m_MapperCPU->SetImageSampleDistance(1.0); 00419 ls->m_MapperCPU->SetSampleDistance(1.0); 00420 ls->m_VolumePropertyCPU->SetInterpolationTypeToLinear(); 00421 } 00422 00423 // Check raycasting mode 00424 if(IsMIPEnabled(renderer)) 00425 ls->m_MapperCPU->SetBlendModeToMaximumIntensity(); 00426 else 00427 ls->m_MapperCPU->SetBlendModeToComposite(); 00428 00429 // Updating shadings 00430 { 00431 float value=0; 00432 if(GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient",value,renderer)) 00433 ls->m_VolumePropertyCPU->SetAmbient(value); 00434 if(GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse",value,renderer)) 00435 ls->m_VolumePropertyCPU->SetDiffuse(value); 00436 if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular",value,renderer)) 00437 ls->m_VolumePropertyCPU->SetSpecular(value); 00438 if(GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power",value,renderer)) 00439 ls->m_VolumePropertyCPU->SetSpecularPower(value); 00440 } 00441 } 00442 00443 void mitk::GPUVolumeMapper3D::CreateDefaultTransferFunctions() 00444 { 00445 //GPU_INFO << "CreateDefaultTransferFunctions"; 00446 00447 m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New(); 00448 m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 ); 00449 m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 ); 00450 m_DefaultOpacityTransferFunction->ClampingOn(); 00451 00452 m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New(); 00453 m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 ); 00454 m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 ); 00455 m_DefaultGradientTransferFunction->ClampingOn(); 00456 00457 m_DefaultColorTransferFunction = vtkColorTransferFunction::New(); 00458 m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 ); 00459 m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 ); 00460 m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 ); 00461 m_DefaultColorTransferFunction->ClampingOn(); 00462 00463 m_BinaryOpacityTransferFunction = vtkPiecewiseFunction::New(); 00464 m_BinaryOpacityTransferFunction->AddPoint( 0, 0.0 ); 00465 m_BinaryOpacityTransferFunction->AddPoint( 1, 1.0 ); 00466 00467 m_BinaryGradientTransferFunction = vtkPiecewiseFunction::New(); 00468 m_BinaryGradientTransferFunction->AddPoint( 0.0, 1.0 ); 00469 00470 m_BinaryColorTransferFunction = vtkColorTransferFunction::New(); 00471 } 00472 00473 void mitk::GPUVolumeMapper3D::UpdateTransferFunctions( mitk::BaseRenderer * renderer ) 00474 { 00475 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00476 00477 //GPU_INFO << "UpdateTransferFunctions"; 00478 00479 vtkPiecewiseFunction *opacityTransferFunction = m_DefaultOpacityTransferFunction; 00480 vtkPiecewiseFunction *gradientTransferFunction = m_DefaultGradientTransferFunction; 00481 vtkColorTransferFunction *colorTransferFunction = m_DefaultColorTransferFunction; 00482 00483 bool isBinary = false; 00484 00485 GetDataNode()->GetBoolProperty("binary", isBinary, renderer); 00486 00487 if(isBinary) 00488 { 00489 opacityTransferFunction = m_BinaryOpacityTransferFunction; 00490 gradientTransferFunction = m_BinaryGradientTransferFunction; 00491 colorTransferFunction = m_BinaryColorTransferFunction; 00492 00493 colorTransferFunction->RemoveAllPoints(); 00494 float rgb[3]; 00495 if( !GetDataNode()->GetColor( rgb,renderer ) ) 00496 rgb[0]=rgb[1]=rgb[2]=1; 00497 colorTransferFunction->AddRGBPoint( 0,rgb[0],rgb[1],rgb[2] ); 00498 colorTransferFunction->Modified(); 00499 } 00500 else 00501 { 00502 mitk::TransferFunctionProperty *transferFunctionProp = 00503 dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction",renderer)); 00504 00505 if( transferFunctionProp ) 00506 { 00507 opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction(); 00508 gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction(); 00509 colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction(); 00510 } 00511 } 00512 00513 if(ls->m_gpuInitialized) 00514 { 00515 ls->m_VolumePropertyGPU->SetColor( colorTransferFunction ); 00516 ls->m_VolumePropertyGPU->SetScalarOpacity( opacityTransferFunction ); 00517 ls->m_VolumePropertyGPU->SetGradientOpacity( gradientTransferFunction ); 00518 } 00519 00520 // Only with VTK 5.6 or above 00521 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00522 00523 if(ls->m_rayInitialized) 00524 { 00525 ls->m_VolumePropertyRAY->SetColor( colorTransferFunction ); 00526 ls->m_VolumePropertyRAY->SetScalarOpacity( opacityTransferFunction ); 00527 ls->m_VolumePropertyRAY->SetGradientOpacity( gradientTransferFunction ); 00528 } 00529 00530 #endif 00531 00532 if(ls->m_cpuInitialized) 00533 { 00534 ls->m_VolumePropertyCPU->SetColor( colorTransferFunction ); 00535 ls->m_VolumePropertyCPU->SetScalarOpacity( opacityTransferFunction ); 00536 ls->m_VolumePropertyCPU->SetGradientOpacity( gradientTransferFunction ); 00537 } 00538 } 00539 00540 00541 void mitk::GPUVolumeMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* /*renderer*/) 00542 { 00543 //GPU_INFO << "ApplyProperties"; 00544 } 00545 00546 void mitk::GPUVolumeMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) 00547 { 00548 //GPU_INFO << "SetDefaultProperties"; 00549 00550 node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite ); 00551 node->AddProperty( "volumerendering.usemip", mitk::BoolProperty::New( false ), renderer, overwrite ); 00552 node->AddProperty( "volumerendering.uselod", mitk::BoolProperty::New( false ), renderer, overwrite ); 00553 00554 node->AddProperty( "volumerendering.cpu.ambient", mitk::FloatProperty::New( 0.10f ), renderer, overwrite ); 00555 node->AddProperty( "volumerendering.cpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite ); 00556 node->AddProperty( "volumerendering.cpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite ); 00557 node->AddProperty( "volumerendering.cpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite ); 00558 00559 node->AddProperty( "volumerendering.usegpu", mitk::BoolProperty::New( true ), renderer, overwrite ); 00560 00561 // Only with VTK 5.6 or above 00562 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00563 00564 node->AddProperty( "volumerendering.useray", mitk::BoolProperty::New( false ), renderer, overwrite ); 00565 00566 node->AddProperty( "volumerendering.ray.ambient", mitk::FloatProperty::New( 0.25f ), renderer, overwrite ); 00567 node->AddProperty( "volumerendering.ray.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite ); 00568 node->AddProperty( "volumerendering.ray.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite ); 00569 node->AddProperty( "volumerendering.ray.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite ); 00570 00571 #endif 00572 node->AddProperty( "volumerendering.gpu.ambient", mitk::FloatProperty::New( 0.25f ), renderer, overwrite ); 00573 node->AddProperty( "volumerendering.gpu.diffuse", mitk::FloatProperty::New( 0.50f ), renderer, overwrite ); 00574 node->AddProperty( "volumerendering.gpu.specular", mitk::FloatProperty::New( 0.40f ), renderer, overwrite ); 00575 node->AddProperty( "volumerendering.gpu.specular.power", mitk::FloatProperty::New( 16.0f ), renderer, overwrite ); 00576 node->AddProperty( "volumerendering.gpu.usetexturecompression", mitk::BoolProperty ::New( false ), renderer, overwrite ); 00577 node->AddProperty( "volumerendering.gpu.reducesliceartifacts" , mitk::BoolProperty ::New( false ), renderer, overwrite ); 00578 00579 node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite ); 00580 00581 mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData()); 00582 if(image.IsNotNull() && image->IsInitialized()) 00583 { 00584 if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL)) 00585 { 00586 mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New(); 00587 mitk::LevelWindow levelwindow; 00588 levelwindow.SetAuto( image ); 00589 levWinProp->SetLevelWindow( levelwindow ); 00590 node->SetProperty( "levelwindow", levWinProp, renderer ); 00591 } 00592 00593 if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL)) 00594 { 00595 // add a default transfer function 00596 mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New(); 00597 mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf); 00598 tfInit->SetTransferFunctionMode(0); 00599 node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) ); 00600 } 00601 } 00602 00603 Superclass::SetDefaultProperties(node, renderer, overwrite); 00604 } 00605 00606 bool mitk::GPUVolumeMapper3D::IsLODEnabled( mitk::BaseRenderer * renderer ) const 00607 { 00608 bool value = false; 00609 return GetDataNode()->GetBoolProperty("volumerendering.uselod",value,renderer) && value; 00610 } 00611 00612 bool mitk::GPUVolumeMapper3D::IsMIPEnabled( mitk::BaseRenderer * renderer ) 00613 { 00614 bool value = false; 00615 return GetDataNode()->GetBoolProperty("volumerendering.usemip",value,renderer) && value; 00616 } 00617 00618 bool mitk::GPUVolumeMapper3D::IsGPUEnabled( mitk::BaseRenderer * renderer ) 00619 { 00620 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00621 bool value = false; 00622 return ls->m_gpuSupported && GetDataNode()->GetBoolProperty("volumerendering.usegpu",value,renderer) && value; 00623 } 00624 00625 // Only with VTK 5.6 or above 00626 #if ((VTK_MAJOR_VERSION > 5) || ((VTK_MAJOR_VERSION==5) && (VTK_MINOR_VERSION>=6) )) 00627 00628 bool mitk::GPUVolumeMapper3D::InitRAY(mitk::BaseRenderer* renderer) 00629 { 00630 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00631 00632 if(ls->m_rayInitialized) 00633 return ls->m_raySupported; 00634 00635 // GPU_INFO << "initializing hardware-accelerated (raycast) renderer"; 00636 ls->m_MapperRAY = vtkMitkOpenGLGPUVolumeRayCastMapper::New(); 00637 ls->m_MapperRAY->SetAutoAdjustSampleDistances(0); 00638 ls->m_MapperRAY->SetSampleDistance(1.0); 00639 00640 ls->m_VolumePropertyRAY = vtkVolumeProperty::New(); 00641 ls->m_VolumePropertyRAY->ShadeOn(); 00642 ls->m_VolumePropertyRAY->SetAmbient (0.25f); //0.05f 00643 ls->m_VolumePropertyRAY->SetDiffuse (0.50f); //0.45f 00644 ls->m_VolumePropertyRAY->SetSpecular(0.40f); //0.50f 00645 ls->m_VolumePropertyRAY->SetSpecularPower(16.0f); 00646 ls->m_VolumePropertyRAY->SetInterpolationTypeToLinear(); 00647 00648 ls->m_VolumeRAY = vtkVolume::New(); 00649 ls->m_VolumeRAY->SetMapper( ls->m_MapperRAY ); 00650 ls->m_VolumeRAY->SetProperty( ls->m_VolumePropertyRAY ); 00651 ls->m_VolumeRAY->VisibilityOn(); 00652 00653 ls->m_MapperRAY->SetInput( this->m_UnitSpacingImageFilter->GetOutput() ); 00654 00655 ls->m_raySupported = ls->m_MapperRAY->IsRenderSupported(renderer->GetRenderWindow(),ls->m_VolumePropertyRAY); 00656 00657 if(!ls->m_raySupported) 00658 GPU_INFO << "hardware-accelerated (raycast) rendering is not supported"; 00659 00660 ls->m_rayInitialized = true; 00661 00662 return ls->m_raySupported; 00663 } 00664 00665 void mitk::GPUVolumeMapper3D::DeinitRAY(mitk::BaseRenderer* renderer) 00666 { 00667 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00668 00669 if(ls->m_rayInitialized) 00670 { 00671 // GPU_INFO << "deinitializing hardware (raycast) renderer"; 00672 00673 ls->m_VolumeRAY->Delete(); 00674 ls->m_MapperRAY->Delete(); 00675 ls->m_VolumePropertyRAY->Delete(); 00676 ls->m_rayInitialized=false; 00677 } 00678 } 00679 00680 void mitk::GPUVolumeMapper3D::GenerateDataRAY( mitk::BaseRenderer *renderer ) 00681 { 00682 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00683 00684 if( IsLODEnabled(renderer) && mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) == 0 ) 00685 ls->m_MapperRAY->SetImageSampleDistance(4.0); 00686 else 00687 ls->m_MapperRAY->SetImageSampleDistance(1.0); 00688 00689 // Check raycasting mode 00690 if(IsMIPEnabled(renderer)) 00691 ls->m_MapperRAY->SetBlendModeToMaximumIntensity(); 00692 else 00693 ls->m_MapperRAY->SetBlendModeToComposite(); 00694 00695 // Updating shadings 00696 { 00697 float value=0; 00698 if(GetDataNode()->GetFloatProperty("volumerendering.ray.ambient",value,renderer)) 00699 ls->m_VolumePropertyRAY->SetAmbient(value); 00700 if(GetDataNode()->GetFloatProperty("volumerendering.ray.diffuse",value,renderer)) 00701 ls->m_VolumePropertyRAY->SetDiffuse(value); 00702 if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular",value,renderer)) 00703 ls->m_VolumePropertyRAY->SetSpecular(value); 00704 if(GetDataNode()->GetFloatProperty("volumerendering.ray.specular.power",value,renderer)) 00705 ls->m_VolumePropertyRAY->SetSpecularPower(value); 00706 } 00707 00708 } 00709 00710 bool mitk::GPUVolumeMapper3D::IsRAYEnabled( mitk::BaseRenderer * renderer ) 00711 { 00712 LocalStorage *ls = m_LSH.GetLocalStorage(renderer); 00713 bool value = false; 00714 return ls->m_raySupported && GetDataNode()->GetBoolProperty("volumerendering.useray",value,renderer) && value; 00715 } 00716 00717 #endif
