mitk: mitkVolumeDataVtkMapper3D.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 #include "mitkVolumeDataVtkMapper3D.h"
00019 
00020 #include "mitkDataNode.h"
00021 
00022 #include "mitkProperties.h"
00023 #include "mitkLevelWindow.h"
00024 #include "mitkColorProperty.h"
00025 #include "mitkLevelWindowProperty.h"
00026 #include "mitkLookupTableProperty.h"
00027 #include "mitkTransferFunctionProperty.h"
00028 #include "mitkTransferFunctionInitializer.h"
00029 #include "mitkColorProperty.h"
00030 #include "mitkVtkPropRenderer.h"
00031 #include "mitkRenderingManager.h"
00032 
00033 
00034 #include <vtkActor.h>
00035 #include <vtkProperty.h>
00036 #include <vtkVolumeRayCastMapper.h>
00037 
00038 #include <vtkVolumeTextureMapper2D.h>
00039 #include <vtkVolume.h>
00040 #include <vtkVolumeProperty.h>
00041 #include <vtkColorTransferFunction.h>
00042 #include <vtkPiecewiseFunction.h>
00043 #include <vtkVolumeRayCastCompositeFunction.h>
00044 #include <vtkVolumeRayCastMIPFunction.h>
00045 #include <vtkFiniteDifferenceGradientEstimator.h>
00046 #include <vtkRenderWindow.h>
00047 #include <vtkRenderWindowInteractor.h>
00048 #include <vtkImageShiftScale.h>
00049 #include <vtkImageChangeInformation.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 #include "mitkVtkVolumeRenderingProperty.h"
00061 
00062 
00063 #include <itkMultiThreader.h>
00064 
00065 const mitk::Image* mitk::VolumeDataVtkMapper3D::GetInput()
00066 {
00067   return static_cast<const mitk::Image*> ( GetData() );
00068 }
00069 
00070 mitk::VolumeDataVtkMapper3D::VolumeDataVtkMapper3D()
00071 : m_Mask( NULL )
00072 {
00073   m_PlaneSet = false;
00074 
00075   m_ClippingPlane = vtkPlane::New();
00076   m_PlaneWidget = vtkImplicitPlaneWidget::New();
00077 
00078   /*
00079   m_T2DMapper =  vtkVolumeTextureMapper2D::New();
00080   m_T2DMapper->SetMaximumNumberOfPlanes( 100 );
00081 */
00082   m_HiResMapper = vtkVolumeRayCastMapper::New();
00083   m_HiResMapper->SetSampleDistance(1.0); // 4 rays for every pixel
00084 
00085   m_HiResMapper->IntermixIntersectingGeometryOn();
00086   m_HiResMapper->SetNumberOfThreads( itk::MultiThreader::GetGlobalDefaultNumberOfThreads() );
00087   /*
00088   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
00089   compositeFunction->SetCompositeMethodToClassifyFirst();
00090   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
00091   compositeFunction->Delete();
00092 
00093   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
00094   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
00095   mipFunction->Delete();
00096  */
00097 
00098   vtkFiniteDifferenceGradientEstimator* gradientEstimator =
00099   vtkFiniteDifferenceGradientEstimator::New();
00100   m_HiResMapper->SetGradientEstimator(gradientEstimator);
00101   gradientEstimator->Delete();
00102 
00103   m_VolumePropertyLow = vtkVolumeProperty::New();
00104   m_VolumePropertyMed = vtkVolumeProperty::New();
00105   m_VolumePropertyHigh = vtkVolumeProperty::New();
00106 
00107   m_VolumeLOD = vtkLODProp3D::New();
00108   m_VolumeLOD->VisibilityOff();
00109 
00110   m_HiResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyHigh,0.0); // RayCast
00111 
00112 //  m_LowResID = m_VolumeLOD->AddLOD(m_T2DMapper,m_VolumePropertyLow,0.0); // TextureMapper2D
00113 
00114 
00115   m_MedResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyMed,0.0); // RayCast
00116 
00117 
00118   m_Resampler = vtkImageResample::New();
00119   m_Resampler->SetAxisMagnificationFactor(0,0.25);
00120   m_Resampler->SetAxisMagnificationFactor(1,0.25);
00121   m_Resampler->SetAxisMagnificationFactor(2,0.25);
00122 
00123   // For abort rendering mechanism
00124   m_VolumeLOD->AutomaticLODSelectionOff();
00125 
00126 
00127   m_BoundingBox = vtkCubeSource::New();
00128   m_BoundingBox->SetXLength( 0.0 );
00129   m_BoundingBox->SetYLength( 0.0 );
00130   m_BoundingBox->SetZLength( 0.0 );
00131 
00132   m_BoundingBoxMapper = vtkPolyDataMapper::New();
00133   m_BoundingBoxMapper->SetInput( m_BoundingBox->GetOutput() );
00134 
00135   m_BoundingBoxActor = vtkActor::New();
00136   m_BoundingBoxActor->SetMapper( m_BoundingBoxMapper );
00137   m_BoundingBoxActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
00138   m_BoundingBoxActor->GetProperty()->SetRepresentationToWireframe();
00139 
00140 
00141   // BoundingBox rendering is not working due to problem with assembly
00142   // transformation; see bug #454
00143   // If commenting in the following, do not forget to comment in the
00144   // m_Prop3DAssembly->Delete() line in the destructor.
00145   //m_Prop3DAssembly = vtkAssembly::New();
00146   //m_Prop3DAssembly->AddPart( m_VolumeLOD );
00147   //m_Prop3DAssembly->AddPart( m_BoundingBoxActor );
00148   //m_Prop3D = m_Prop3DAssembly;
00149 
00150   m_ImageCast = vtkImageShiftScale::New();
00151   m_ImageCast->SetOutputScalarTypeToUnsignedShort();
00152   m_ImageCast->ClampOverflowOn();
00153 
00154   m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
00155   m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
00156   m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
00157 
00158   m_ImageMaskFilter = vtkImageMask::New();
00159   m_ImageMaskFilter->SetMaskedOutputValue(0xffff);
00160 
00161   this->m_Resampler->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
00162   this->m_HiResMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
00163 
00164 //  m_T2DMapper->SetInput(m_Resampler->GetOutput());
00165 
00166 
00167   this->CreateDefaultTransferFunctions();
00168 }
00169 
00170 vtkProp *mitk::VolumeDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
00171 {
00172   return m_VolumeLOD;
00173 }
00174 
00175 mitk::VolumeDataVtkMapper3D::~VolumeDataVtkMapper3D()
00176 {
00177   m_UnitSpacingImageFilter->Delete();
00178   m_ImageCast->Delete();
00179 //  m_T2DMapper->Delete();
00180   m_HiResMapper->Delete();
00181   m_Resampler->Delete();
00182   m_VolumePropertyLow->Delete();
00183   m_VolumePropertyMed->Delete();
00184   m_VolumePropertyHigh->Delete();
00185   m_VolumeLOD->Delete();
00186   m_ClippingPlane->Delete();
00187   m_PlaneWidget->Delete();
00188   // m_Prop3DAssembly->Delete();
00189   m_BoundingBox->Delete();
00190   m_BoundingBoxMapper->Delete();
00191   m_BoundingBoxActor->Delete();
00192   m_ImageMaskFilter->Delete();
00193   m_DefaultColorTransferFunction->Delete();
00194   m_DefaultOpacityTransferFunction->Delete();
00195   m_DefaultGradientTransferFunction->Delete();
00196 
00197   if (m_Mask)
00198   {
00199     m_Mask->Delete();
00200   }
00201 }
00202 
00203 void mitk::VolumeDataVtkMapper3D::GenerateData( mitk::BaseRenderer *renderer )
00204 {
00205   SetVtkMapperImmediateModeRendering(m_BoundingBoxMapper);
00206 
00207   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
00208   if ( !input || !input->IsInitialized() )
00209     return;
00210 
00211   vtkRenderWindow* renderWindow = renderer->GetRenderWindow();
00212 
00213   bool volumeRenderingEnabled = true;
00214 
00215   if (this->IsVisible(renderer)==false ||
00216       this->GetDataNode() == NULL ||
00217       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))==NULL ||
00218       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == false
00219     )
00220   {
00221     volumeRenderingEnabled = false;
00222 
00223     // Check if a bounding box should be displayed around the dataset
00224     // (even if volume rendering is disabled)
00225     bool hasBoundingBox = false;
00226     this->GetDataNode()->GetBoolProperty( "bounding box", hasBoundingBox );
00227 
00228     if ( !hasBoundingBox )
00229     {
00230       m_BoundingBoxActor->VisibilityOff();
00231     }
00232     else
00233     {
00234       m_BoundingBoxActor->VisibilityOn();
00235 
00236       const BoundingBox::BoundsArrayType &bounds =
00237         input->GetTimeSlicedGeometry()->GetBounds();
00238 
00239       m_BoundingBox->SetBounds(
00240         bounds[0], bounds[1],
00241         bounds[2], bounds[3],
00242         bounds[4], bounds[5] );
00243 
00244       ColorProperty *colorProperty;
00245       if ( this->GetDataNode()->GetProperty(
00246         colorProperty, "color" ) )
00247       {
00248         const mitk::Color &color = colorProperty->GetColor();
00249         m_BoundingBoxActor->GetProperty()->SetColor(
00250           color[0], color[1], color[2] );
00251       }
00252       else
00253       {
00254         m_BoundingBoxActor->GetProperty()->SetColor(
00255           1.0, 1.0, 1.0 );
00256       }
00257     }
00258   }
00259 
00260   // Don't do anything if VR is disabled
00261   if ( !volumeRenderingEnabled )
00262   {
00263     m_VolumeLOD->VisibilityOff();
00264     return;
00265   }
00266   else
00267   {
00268         mitk::VtkVolumeRenderingProperty* vrp=dynamic_cast<mitk::VtkVolumeRenderingProperty*>(GetDataNode()->GetProperty("volumerendering configuration",renderer));
00269         if(vrp)
00270         {
00271           int renderingValue = vrp->GetValueAsId();
00272           
00273           switch(renderingValue)
00274           {
00275               case  VTK_VOLUME_RAY_CAST_MIP_FUNCTION:
00276               {
00277                   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
00278                   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
00279                   mipFunction->Delete();
00280                   MITK_INFO <<"in switch" <<std::endl;
00281                   break;
00282               }
00283               
00284               case VTK_RAY_CAST_COMPOSITE_FUNCTION:
00285               {
00286                   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
00287                   compositeFunction->SetCompositeMethodToClassifyFirst();
00288                   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
00289                   compositeFunction->Delete();
00290                   break;
00291               }
00292               default:
00293                   MITK_ERROR <<"Warning: invalid volume rendering option.  " << std::endl;
00294 
00295           }
00296         }
00297     m_VolumeLOD->VisibilityOn();
00298   }
00299 
00300   this->SetPreferences();
00301 /*
00302   switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
00303   {
00304   case 0:
00305     m_VolumeLOD->SetSelectedLODID(m_MedResID);  m_LowResID );
00306     break;
00307 
00308   default:
00309   case 1:
00310     m_VolumeLOD->SetSelectedLODID( m_HiResID );
00311     break;
00312   }
00313 */  
00314   m_VolumeLOD->SetSelectedLODID( m_HiResID );
00315 
00316   assert(input->GetTimeSlicedGeometry());
00317 
00318   const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
00319   if(worldgeometry==NULL)
00320   {
00321     GetDataNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
00322     return;
00323   }
00324 
00325   vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
00326   if(inputData==NULL)
00327     return;
00328 
00329 
00330   m_ImageCast->SetInput( inputData );
00331 
00332   //If mask exists, process mask before resampling.
00333   if (this->m_Mask)
00334   {
00335     this->m_ImageMaskFilter->SetImageInput(this->m_UnitSpacingImageFilter->GetOutput());
00336     this->m_Resampler->SetInput(this->m_ImageMaskFilter->GetOutput());
00337     this->m_HiResMapper->SetInput(this->m_ImageMaskFilter->GetOutput());
00338   }
00339   else
00340   {
00341     this->m_Resampler->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
00342     this->m_HiResMapper->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
00343   }
00344 
00345   this->UpdateTransferFunctions( renderer );
00346 
00347   vtkRenderWindowInteractor *interactor = renderWindow->GetInteractor();
00348   
00349   float frameRate;
00350   if( this->GetDataNode()->GetFloatProperty( "framerate", frameRate ) && frameRate > 0 && frameRate <= 60)
00351   {
00352     interactor->SetDesiredUpdateRate(  frameRate );
00353     interactor->SetStillUpdateRate( frameRate );
00354   }
00355   else if( frameRate > 60 )
00356   {
00357     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(60));
00358     interactor->SetDesiredUpdateRate(  60 );
00359     interactor->SetStillUpdateRate( 60 );
00360   }
00361   else
00362   {
00363     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(0.00001));
00364     interactor->SetDesiredUpdateRate(  0.00001 );
00365     interactor->SetStillUpdateRate( 0.00001 );
00366   }
00367 
00368   if ( m_RenderWindowInitialized.find( renderWindow ) == m_RenderWindowInitialized.end() )
00369   {
00370     m_RenderWindowInitialized.insert( renderWindow );
00371 
00372     mitk::RenderingManager::GetInstance()->SetNextLOD( 0, renderer );
00373 
00374     mitk::RenderingManager::GetInstance()->SetShading( true, 0 );
00375     mitk::RenderingManager::GetInstance()->SetShading( true, 1 );
00376     //mitk::RenderingManager::GetInstance()->SetShading( true, 2 );
00377 
00378     mitk::RenderingManager::GetInstance()->SetShadingValues(
00379       m_VolumePropertyHigh->GetAmbient(),
00380       m_VolumePropertyHigh->GetDiffuse(),
00381       m_VolumePropertyHigh->GetSpecular(),
00382       m_VolumePropertyHigh->GetSpecularPower());
00383 
00384     mitk::RenderingManager::GetInstance()->SetClippingPlaneStatus(false);
00385   }
00386 
00387   this->SetClippingPlane( interactor );
00388 }
00389 
00390 
00391 void mitk::VolumeDataVtkMapper3D::CreateDefaultTransferFunctions()
00392 {
00393   m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
00394   m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
00395   m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
00396   m_DefaultOpacityTransferFunction->ClampingOn();
00397 
00398   m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
00399   m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
00400   m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
00401   m_DefaultGradientTransferFunction->ClampingOn();
00402 
00403   m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
00404   m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
00405   m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
00406   m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
00407   m_DefaultColorTransferFunction->ClampingOn();
00408 }
00409 
00410 void mitk::VolumeDataVtkMapper3D::UpdateTransferFunctions( mitk::BaseRenderer *renderer )
00411 {
00412   vtkPiecewiseFunction *opacityTransferFunction = NULL;
00413   vtkPiecewiseFunction *gradientTransferFunction = NULL;
00414   vtkColorTransferFunction *colorTransferFunction = NULL;
00415 
00416   mitk::LookupTableProperty::Pointer lookupTableProp;
00417   lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
00418   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction"));
00419 
00420   if ( transferFunctionProp.IsNotNull() )   {
00421 
00422     opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
00423     gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
00424     colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
00425   }
00426   else if (lookupTableProp.IsNotNull() )
00427   {
00428     lookupTableProp->GetLookupTable()->CreateOpacityTransferFunction(opacityTransferFunction);
00429     opacityTransferFunction->ClampingOn();
00430     lookupTableProp->GetLookupTable()->CreateGradientTransferFunction(gradientTransferFunction);
00431     gradientTransferFunction->ClampingOn();
00432     lookupTableProp->GetLookupTable()->CreateColorTransferFunction(colorTransferFunction);
00433     colorTransferFunction->ClampingOn();
00434   }
00435   else
00436   {
00437     opacityTransferFunction = m_DefaultOpacityTransferFunction;
00438     gradientTransferFunction = m_DefaultGradientTransferFunction;
00439     colorTransferFunction = m_DefaultColorTransferFunction;
00440 
00441     float rgb[3]={1.0f,1.0f,1.0f};
00442     // check for color prop and use it for rendering if it exists
00443     if(GetColor(rgb, renderer))
00444     {
00445       colorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
00446       colorTransferFunction->AddRGBPoint( 127.5, rgb[0], rgb[1], rgb[2] );
00447       colorTransferFunction->AddRGBPoint( 255.0, rgb[0], rgb[1], rgb[2] );
00448     }
00449   }
00450 
00451   if (this->m_Mask)
00452   {
00453     opacityTransferFunction->AddPoint(0xffff, 0.0);
00454   }
00455 
00456   m_VolumePropertyLow->SetColor( colorTransferFunction );
00457   m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );
00458   m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );
00459   m_VolumePropertyLow->SetInterpolationTypeToNearest();
00460 
00461   m_VolumePropertyMed->SetColor( colorTransferFunction );
00462   m_VolumePropertyMed->SetScalarOpacity( opacityTransferFunction );
00463   m_VolumePropertyMed->SetGradientOpacity( gradientTransferFunction );
00464   m_VolumePropertyMed->SetInterpolationTypeToNearest();
00465 
00466   m_VolumePropertyHigh->SetColor( colorTransferFunction );
00467   m_VolumePropertyHigh->SetScalarOpacity( opacityTransferFunction );
00468   m_VolumePropertyHigh->SetGradientOpacity( gradientTransferFunction );
00469   m_VolumePropertyHigh->SetInterpolationTypeToLinear();
00470 }
00471 
00472 
00473 /* Shading enabled / disabled */
00474 void mitk::VolumeDataVtkMapper3D::SetPreferences()
00475 {
00476   //LOD 0
00477   /*if(mitk::RenderingManager::GetInstance()->GetShading(0))
00478   {
00479     m_VolumePropertyLow->ShadeOn();
00480     m_VolumePropertyLow->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
00481     m_VolumePropertyLow->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
00482     m_VolumePropertyLow->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
00483     m_VolumePropertyLow->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
00484   }
00485   else*/
00486   {
00487     m_VolumePropertyLow->ShadeOff();
00488   }
00489 
00490   //LOD 1
00491   /*if(mitk::RenderingManager::GetInstance()->GetShading(1))
00492   {
00493     m_VolumePropertyMed->ShadeOn();
00494     m_VolumePropertyMed->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
00495     m_VolumePropertyMed->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
00496     m_VolumePropertyMed->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
00497     m_VolumePropertyMed->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
00498   }
00499   else*/
00500   {
00501     m_VolumePropertyMed->ShadeOff();
00502   }
00503 
00504   //LOD 2
00505   /*
00506   if(mitk::RenderingManager::GetInstance()->GetShading(2))
00507   {
00508     m_VolumePropertyHigh->ShadeOn();
00509     //Shading Properties
00510     m_VolumePropertyHigh->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
00511     m_VolumePropertyHigh->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
00512     m_VolumePropertyHigh->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
00513     m_VolumePropertyHigh->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
00514   }
00515   else
00516   {
00517     m_VolumePropertyHigh->ShadeOff();
00518   }
00519   */
00520 
00521 }
00522 
00523 /* Adds A Clipping Plane to the Mapper */
00524 void mitk::VolumeDataVtkMapper3D::SetClippingPlane(vtkRenderWindowInteractor* interactor)
00525 {
00526 
00527   if(mitk::RenderingManager::GetInstance()->GetClippingPlaneStatus()) //if clipping plane is enabled
00528   {
00529 
00530     if(!m_PlaneSet)
00531     {
00532     m_PlaneWidget->SetInteractor(interactor);
00533     m_PlaneWidget->SetPlaceFactor(1.0);
00534     m_PlaneWidget->SetInput(m_UnitSpacingImageFilter->GetOutput());
00535     m_PlaneWidget->OutlineTranslationOff(); //disables scaling of the bounding box
00536 #if (VTK_MAJOR_VERSION >= 5)
00537     m_PlaneWidget->ScaleEnabledOff(); //disables scaling of the bounding box
00538 #endif
00539     m_PlaneWidget->DrawPlaneOff(); //clipping plane is transparent
00540     mitk::Image* input  = const_cast<mitk::Image *>(this->GetInput());
00541 
00542     /*places the widget within the specified bounds*/
00543     m_PlaneWidget->PlaceWidget(
00544         input->GetGeometry()->GetOrigin()[0],(input->GetGeometry()->GetOrigin()[0])+(input->GetDimension(0))*(input->GetVtkImageData()->GetSpacing()[0]),                               input->GetGeometry()->GetOrigin()[1],(input->GetGeometry()->GetOrigin()[1])+(input->GetDimension(1))*(input->GetVtkImageData()->GetSpacing()[1]),                               input->GetGeometry()->GetOrigin()[2],(input->GetGeometry()->GetOrigin()[2])+(input->GetDimension(2))*(input->GetVtkImageData()->GetSpacing()[2]));
00545 
00546 //    m_T2DMapper->AddClippingPlane(m_ClippingPlane);
00547     m_HiResMapper->AddClippingPlane(m_ClippingPlane);
00548     }
00549 
00550     m_PlaneWidget->GetPlane(m_ClippingPlane);
00551     m_PlaneSet = true;
00552   }
00553   else //if clippingplane is disabled
00554   {
00555     if(m_PlaneSet) //if plane exists
00556     {
00557     DelClippingPlane();
00558     }
00559   }
00560 
00561 }
00562 
00563 
00564 /* Removes the clipping plane */
00565 void mitk::VolumeDataVtkMapper3D::DelClippingPlane()
00566 {
00567 //  m_T2DMapper->RemoveAllClippingPlanes();
00568   m_HiResMapper->RemoveAllClippingPlanes();
00569   m_PlaneSet = false;
00570 }
00571 
00572 void mitk::VolumeDataVtkMapper3D::ApplyProperties(vtkActor* /*actor*/, mitk::BaseRenderer* /*renderer*/)
00573 {
00574 
00575 }
00576 
00577 void mitk::VolumeDataVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
00578 {
00579   node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
00580   node->AddProperty( "volumerendering configuration", mitk::VtkVolumeRenderingProperty::New( 1 ), renderer, overwrite );
00581   node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
00582  
00583   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
00584   if(image.IsNotNull() && image->IsInitialized())
00585   {
00586     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
00587     {
00588       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
00589       mitk::LevelWindow levelwindow;
00590       levelwindow.SetAuto( image );
00591       levWinProp->SetLevelWindow( levelwindow );
00592       node->SetProperty( "levelwindow", levWinProp, renderer );
00593     }
00594     if((overwrite) || (node->GetProperty("LookupTable", renderer)==NULL))
00595     {
00596       // add a default rainbow lookup table for color mapping
00597       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
00598       vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
00599       vtkLut->SetHueRange(0.6667, 0.0);
00600       vtkLut->SetTableRange(0.0, 20.0);
00601       vtkLut->Build();
00602       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
00603       mitkLutProp->SetLookupTable(mitkLut);
00604       node->SetProperty( "LookupTable", mitkLutProp );
00605     }
00606     if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
00607     {
00608       // add a default transfer function
00609       mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
00610       mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
00611       tfInit->SetTransferFunctionMode(0);
00612       node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
00613     }
00614   }
00615 
00616   Superclass::SetDefaultProperties(node, renderer, overwrite);
00617 }
00618 
00619 
00620 bool mitk::VolumeDataVtkMapper3D::IsLODEnabled( mitk::BaseRenderer * /*renderer*/ ) const
00621 {
00622   return false;
00623   
00624 
00625   // Volume mapper is LOD enabled if volumerendering is enabled
00626   /*
00627   return
00628     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer)) != NULL &&
00629     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == true;
00630   */
00631 }
00632 
00633 
00634 void mitk::VolumeDataVtkMapper3D::EnableMask()
00635 {
00636   if (!this->m_Mask)
00637   {
00638     const Image *orig_image = this->GetInput();
00639     unsigned int *dimensions = orig_image->GetDimensions();
00640 
00641     this->m_Mask = vtkImageData::New();
00642     this->m_Mask->SetDimensions(dimensions[0], dimensions[1], dimensions[2]);
00643     this->m_Mask->SetScalarTypeToUnsignedChar();
00644     this->m_Mask->SetNumberOfScalarComponents(1);
00645     this->m_Mask->AllocateScalars();
00646 
00647     unsigned char *mask_data = static_cast<unsigned char*>(this->m_Mask->GetScalarPointer());
00648     unsigned int size = dimensions[0] * dimensions[1] * dimensions[2];
00649 
00650     for (unsigned int i = 0u; i < size; ++i)
00651     {
00652       *mask_data++ = 1u;
00653     }
00654     this->m_ImageMaskFilter->SetMaskInput(this->m_Mask);
00655     this->m_ImageMaskFilter->Modified();
00656   }
00657 }
00658 
00659 void mitk::VolumeDataVtkMapper3D::DisableMask()
00660 {
00661   if (this->m_Mask)
00662   {
00663     this->m_Mask->Delete();
00664     this->m_Mask = 0;
00665   }
00666 }
00667 
00668 mitk::Image::Pointer mitk::VolumeDataVtkMapper3D::GetMask()
00669 {
00670   if (this->m_Mask)
00671   {
00672     Image::Pointer mask = Image::New();
00673 
00674     mask->Initialize(this->m_Mask);
00675     mask->SetImportVolume(this->m_Mask->GetScalarPointer(), 0, 0, Image::ReferenceMemory);
00676     mask->SetGeometry(this->GetInput()->GetGeometry());
00677     return mask;
00678   }
00679 
00680   return 0;
00681 }
00682 
00683 void mitk::VolumeDataVtkMapper3D::UpdateMask()
00684 {
00685   if (this->m_Mask)
00686   {
00687     this->m_ImageMaskFilter->Modified();
00688   }
00689 }
00690 
00691 bool mitk::VolumeDataVtkMapper3D::SetMask(const mitk::Image* mask)
00692 {
00693   if (this->m_Mask)
00694   {
00695     if (mask->GetPixelType() == PixelType(typeid(unsigned char)))
00696     {
00697       Image *img = const_cast<Image*>(mask);
00698 
00699       this->m_Mask->DeepCopy(img->GetVtkImageData());
00700       this->m_ImageMaskFilter->Modified();
00701       return true;
00702     }
00703   }
00704 
00705   return false;
00706 }