mitkOdfVtkMapper2D.txx
Go to the documentation of this file.
00001 /*========================================================================= 00002 00003 Program: Medical Imaging & Interaction Toolkit 00004 Language: C++ 00005 Date: $Date: 2008-08-25 18:10:57 +0200 (Mo, 25 Aug 2008) $ 00006 Version: $Revision: 15062 $ 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 #ifndef __mitkOdfVtkMapper2D_txx__ 00020 #define __mitkOdfVtkMapper2D_txx__ 00021 00022 #include "mitkOdfVtkMapper2D.h" 00023 #include "mitkDataNode.h" 00024 #include "mitkBaseRenderer.h" 00025 #include "mitkMatrixConvert.h" 00026 #include "mitkGeometry3D.h" 00027 #include "mitkOdfNormalizationMethodProperty.h" 00028 #include "mitkOdfScaleByProperty.h" 00029 #include "mitkProperties.h" 00030 #include "mitkTensorImage.h" 00031 00032 #include "vtkSphereSource.h" 00033 #include "vtkPropCollection.h" 00034 #include "vtkMaskedGlyph3D.h" 00035 #include "vtkGlyph2D.h" 00036 #include "vtkGlyph3D.h" 00037 #include "vtkMaskedProgrammableGlyphFilter.h" 00038 #include "vtkImageData.h" 00039 #include "vtkLinearTransform.h" 00040 #include "vtkCamera.h" 00041 #include "vtkPointData.h" 00042 #include "vtkTransformPolyDataFilter.h" 00043 #include "vtkTransform.h" 00044 #include "vtkOdfSource.h" 00045 #include "vtkDoubleArray.h" 00046 #include "vtkLookupTable.h" 00047 #include "vtkProperty.h" 00048 #include "vtkPolyDataNormals.h" 00049 #include "vtkLight.h" 00050 #include "vtkLightCollection.h" 00051 #include "vtkMath.h" 00052 #include "vtkFloatArray.h" 00053 #include "vtkDelaunay2D.h" 00054 #include "vtkMapper.h" 00055 00056 #include "vtkRenderer.h" 00057 #include "vtkCamera.h" 00058 00059 #include "itkOrientationDistributionFunction.h" 00060 00061 #include "itkFixedArray.h" 00062 00063 #include <mitkGL.h> 00064 #include "vtkOpenGLRenderer.h" 00065 00066 template<class T, int N> 00067 vtkSmartPointer<vtkTransform> mitk::OdfVtkMapper2D<T,N>::m_OdfTransform = vtkSmartPointer<vtkTransform>::New(); 00068 00069 template<class T, int N> 00070 vtkSmartPointer<vtkDoubleArray> mitk::OdfVtkMapper2D<T,N>::m_OdfVals = vtkSmartPointer<vtkDoubleArray>::New(); 00071 00072 template<class T, int N> 00073 vtkSmartPointer<vtkOdfSource> mitk::OdfVtkMapper2D<T,N>::m_OdfSource = vtkSmartPointer<vtkOdfSource>::New(); 00074 00075 template<class T, int N> 00076 float mitk::OdfVtkMapper2D<T,N>::m_Scaling; 00077 00078 template<class T, int N> 00079 int mitk::OdfVtkMapper2D<T,N>::m_Normalization; 00080 00081 template<class T, int N> 00082 int mitk::OdfVtkMapper2D<T,N>::m_ScaleBy; 00083 00084 template<class T, int N> 00085 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam1; 00086 00087 template<class T, int N> 00088 float mitk::OdfVtkMapper2D<T,N>::m_IndexParam2; 00089 00090 #define ODF_MAPPER_PI 3.1415926535897932384626433832795 00091 00092 //#include "vtkSphereSource.h" 00093 //#include "vtkPolyDataMapper.h" 00094 //#include "vtkActor.h" 00095 //#include "vtkRenderWindow.h" 00096 //#include "vtkRenderer.h" 00097 //#include "vtkRenderWindowInteractor.h" 00098 //#include "vtkProperty.h" 00099 // 00100 //void bla(vtkPolyData* poly) 00101 //{ 00102 // 00103 // // map to graphics library 00104 // vtkPolyDataMapper *map = vtkPolyDataMapper::New(); 00105 // map->SetInput(poly); 00106 // 00107 // // actor coordinates geometry, properties, transformation 00108 // vtkActor *aSphere = vtkActor::New(); 00109 // aSphere->SetMapper(map); 00110 // aSphere->GetProperty()->SetColor(0,0,1); // sphere color blue 00111 // 00112 // // a renderer and render window 00113 // vtkRenderer *ren1 = vtkRenderer::New(); 00114 // vtkRenderWindow *renWin = vtkRenderWindow::New(); 00115 // renWin->AddRenderer(ren1); 00116 // 00117 // // an interactor 00118 // vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New(); 00119 // iren->SetRenderWindow(renWin); 00120 // 00121 // // add the actor to the scene 00122 // ren1->AddActor(aSphere); 00123 // ren1->SetBackground(1,1,1); // Background color white 00124 // 00125 // // render an image (lights and cameras are created automatically) 00126 // renWin->Render(); 00127 // 00128 // // begin mouse interaction 00129 // iren->Start(); 00130 //} 00131 00132 template<class T, int N> 00133 mitk::OdfVtkMapper2D<T,N> 00134 ::OdfVtkMapper2D() 00135 { 00136 m_VtkBased = true; 00137 m_LastDisplayGeometry = 0; 00138 00139 m_PropAssemblies.push_back(vtkPropAssembly::New()); 00140 m_PropAssemblies.push_back(vtkPropAssembly::New()); 00141 m_PropAssemblies.push_back(vtkPropAssembly::New()); 00142 00143 m_OdfsPlanes.push_back(vtkAppendPolyData::New()); 00144 m_OdfsPlanes.push_back(vtkAppendPolyData::New()); 00145 m_OdfsPlanes.push_back(vtkAppendPolyData::New()); 00146 00147 m_OdfsPlanes[0]->AddInput(vtkPolyData::New()); 00148 m_OdfsPlanes[1]->AddInput(vtkPolyData::New()); 00149 m_OdfsPlanes[2]->AddInput(vtkPolyData::New()); 00150 00151 m_OdfsActors.push_back(vtkActor::New()); 00152 m_OdfsActors.push_back(vtkActor::New()); 00153 m_OdfsActors.push_back(vtkActor::New()); 00154 00155 m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud(); 00156 m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud(); 00157 m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud(); 00158 00159 m_OdfsMappers.push_back(vtkPolyDataMapper::New()); 00160 m_OdfsMappers.push_back(vtkPolyDataMapper::New()); 00161 m_OdfsMappers.push_back(vtkPolyDataMapper::New()); 00162 00163 vtkLookupTable *lut = vtkLookupTable::New(); 00164 //lut->SetMinimumTableValue(0,0,1,1); 00165 //lut->SetMaximumTableValue(1,0,0,1); 00166 //lut->SetWindow(0.1); 00167 //lut->SetLevel(0.05); <== not recognized or reset by mapper ?? 00168 //lut->Build(); 00169 m_OdfsMappers[0]->SetLookupTable(lut); 00170 m_OdfsMappers[1]->SetLookupTable(lut); 00171 m_OdfsMappers[2]->SetLookupTable(lut); 00172 00173 m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]); 00174 m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]); 00175 m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]); 00176 00177 m_Planes.push_back(vtkPlane::New()); 00178 m_Planes.push_back(vtkPlane::New()); 00179 m_Planes.push_back(vtkPlane::New()); 00180 00181 m_Cutters.push_back(vtkCutter::New()); 00182 m_Cutters.push_back(vtkCutter::New()); 00183 m_Cutters.push_back(vtkCutter::New()); 00184 00185 m_Cutters[0]->SetCutFunction( m_Planes[0] ); 00186 m_Cutters[0]->GenerateValues( 1, 0, 1 ); 00187 00188 m_Cutters[1]->SetCutFunction( m_Planes[1] ); 00189 m_Cutters[1]->GenerateValues( 1, 0, 1 ); 00190 00191 m_Cutters[2]->SetCutFunction( m_Planes[2] ); 00192 m_Cutters[2]->GenerateValues( 1, 0, 1 ); 00193 00194 // Windowing the cutted planes in direction 1 00195 m_ThickPlanes1.push_back(vtkThickPlane::New()); 00196 m_ThickPlanes1.push_back(vtkThickPlane::New()); 00197 m_ThickPlanes1.push_back(vtkThickPlane::New()); 00198 00199 m_Clippers1.push_back(vtkClipPolyData::New()); 00200 m_Clippers1.push_back(vtkClipPolyData::New()); 00201 m_Clippers1.push_back(vtkClipPolyData::New()); 00202 00203 m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] ); 00204 m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] ); 00205 m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] ); 00206 00207 // Windowing the cutted planes in direction 2 00208 m_ThickPlanes2.push_back(vtkThickPlane::New()); 00209 m_ThickPlanes2.push_back(vtkThickPlane::New()); 00210 m_ThickPlanes2.push_back(vtkThickPlane::New()); 00211 00212 m_Clippers2.push_back(vtkClipPolyData::New()); 00213 m_Clippers2.push_back(vtkClipPolyData::New()); 00214 m_Clippers2.push_back(vtkClipPolyData::New()); 00215 00216 m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] ); 00217 m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] ); 00218 m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] ); 00219 00220 m_TemplateOdf = itk::OrientationDistributionFunction<T,N>::GetBaseMesh(); 00221 00222 //vtkPoints* points = m_TemplateOdf->GetPoints(); 00223 00224 m_OdfVals->Allocate(N); 00225 m_OdfSource->SetTemplateOdf(m_TemplateOdf); 00226 m_OdfSource->SetOdfVals(m_OdfVals); 00227 00228 m_ShowMaxNumber = 500; 00229 00230 //vtkMapper::GlobalImmediateModeRenderingOn(); 00231 } 00232 00233 template<class T, int N> 00234 mitk::OdfVtkMapper2D<T,N> 00235 ::~OdfVtkMapper2D() 00236 { 00237 m_PropAssemblies[0]->Delete(); 00238 m_PropAssemblies[1]->Delete(); 00239 m_PropAssemblies[2]->Delete(); 00240 m_OdfsPlanes[0]->Delete(); 00241 m_OdfsPlanes[1]->Delete(); 00242 m_OdfsPlanes[2]->Delete(); 00243 m_OdfsActors[0]->Delete(); 00244 m_OdfsActors[1]->Delete(); 00245 m_OdfsActors[2]->Delete(); 00246 m_OdfsMappers[0]->Delete(); 00247 m_OdfsMappers[1]->Delete(); 00248 m_OdfsMappers[2]->Delete(); 00249 m_Planes[0]->Delete(); 00250 m_Planes[1]->Delete(); 00251 m_Planes[2]->Delete(); 00252 m_Cutters[0]->Delete(); 00253 m_Cutters[1]->Delete(); 00254 m_Cutters[2]->Delete(); 00255 m_ThickPlanes1[0]->Delete(); 00256 m_ThickPlanes1[1]->Delete(); 00257 m_ThickPlanes1[2]->Delete(); 00258 m_ThickPlanes2[0]->Delete(); 00259 m_ThickPlanes2[1]->Delete(); 00260 m_ThickPlanes2[2]->Delete(); 00261 m_Clippers1[0]->Delete(); 00262 m_Clippers1[1]->Delete(); 00263 m_Clippers1[2]->Delete(); 00264 m_Clippers2[0]->Delete(); 00265 m_Clippers2[1]->Delete(); 00266 m_Clippers2[2]->Delete(); 00267 } 00268 00269 template<class T, int N> 00270 mitk::Image* mitk::OdfVtkMapper2D<T,N> 00271 ::GetInput() 00272 { 00273 return static_cast<mitk::Image * > ( m_DataNode->GetData() ); 00274 } 00275 00276 template<class T, int N> 00277 vtkProp* mitk::OdfVtkMapper2D<T,N> 00278 ::GetProp(mitk::BaseRenderer* renderer) 00279 { 00280 return m_PropAssemblies[GetIndex(renderer)]; 00281 } 00282 00283 template<class T, int N> 00284 int mitk::OdfVtkMapper2D<T,N> 00285 ::GetIndex(mitk::BaseRenderer* renderer) 00286 { 00287 if(!strcmp(renderer->GetName(),"stdmulti.widget1")) 00288 return 0; 00289 00290 if(!strcmp(renderer->GetName(),"stdmulti.widget2")) 00291 return 1; 00292 00293 if(!strcmp(renderer->GetName(),"stdmulti.widget3")) 00294 return 2; 00295 00296 return 0; 00297 } 00298 00299 template<class T, int N> 00300 void mitk::OdfVtkMapper2D<T,N> 00301 ::GlyphMethod(void *arg) 00302 { 00303 vtkMaskedProgrammableGlyphFilter 00304 *pfilter=(vtkMaskedProgrammableGlyphFilter*)arg; 00305 00306 double point[3]; 00307 double debugpoint[3]; 00308 pfilter->GetPoint(point); 00309 pfilter->GetPoint(debugpoint); 00310 00311 itk::Point<double,3> p(point); 00312 Point3D origin = pfilter->GetGeometry()->GetOrigin(); 00313 Vector3D spacing = pfilter->GetGeometry()->GetSpacing(); 00314 p[0] += origin[0];//+spacing[0]*0.5; 00315 p[1] += origin[1];//+spacing[1]*0.5; 00316 p[2] += origin[2];//+spacing[2]*0.5; 00317 mitk::Point3D p2; 00318 pfilter->GetGeometry()->ItkPhysicalPointToWorld( p, p2 ); 00319 point[0] = p2[0]; 00320 point[1] = p2[1]; 00321 point[2] = p2[2]; 00322 00323 vtkPointData* data = pfilter->GetPointData(); 00324 vtkDataArray* odfvals = data->GetArray("vector"); 00325 vtkIdType id = pfilter->GetPointId(); 00326 m_OdfTransform->Identity(); 00327 m_OdfTransform->Translate(point[0],point[1],point[2]); 00328 00329 typedef itk::OrientationDistributionFunction<float,N> OdfType; 00330 OdfType odf; 00331 00332 if(odfvals->GetNumberOfComponents()==6) 00333 { 00334 float tensorelems[6] = { 00335 (float)odfvals->GetComponent(id,0), 00336 (float)odfvals->GetComponent(id,1), 00337 (float)odfvals->GetComponent(id,2), 00338 (float)odfvals->GetComponent(id,3), 00339 (float)odfvals->GetComponent(id,4), 00340 (float)odfvals->GetComponent(id,5), 00341 }; 00342 itk::DiffusionTensor3D<float> tensor(tensorelems); 00343 odf.InitFromTensor(tensor); 00344 } 00345 else 00346 { 00347 for(int i=0; i<N; i++) 00348 odf[i] = (double)odfvals->GetComponent(id,i); 00349 } 00350 00351 switch(m_Normalization) 00352 { 00353 case ODFN_MINMAX: 00354 odf = odf.MinMaxNormalize(); 00355 break; 00356 case ODFN_MAX: 00357 odf = odf.MaxNormalize(); 00358 break; 00359 case ODFN_NONE: 00360 // nothing 00361 break; 00362 case ODFN_GLOBAL_MAX: 00363 // global max not implemented yet 00364 break; 00365 default: 00366 odf = odf.MinMaxNormalize(); 00367 } 00368 00369 switch(m_ScaleBy) 00370 { 00371 case ODFSB_NONE: 00372 break; 00373 case ODFSB_GFA: 00374 odf = odf * odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2); 00375 break; 00376 case ODFSB_PC: 00377 odf = odf * odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0); 00378 break; 00379 } 00380 00381 for(int i=0; i<N; i++) 00382 m_OdfVals->SetComponent(0,i,0.5*odf[i]*m_Scaling); 00383 00384 //double max = -100000; 00385 //double min = 100000; 00386 //for( unsigned int i=0; i<N; i++) 00387 //{ 00388 // max = odf[i] > max ? odf[i] : max; 00389 // min = odf[i] < min ? odf[i] : min; 00390 //} 00391 00392 m_OdfSource->Modified(); 00393 } 00394 00395 template<class T, int N> 00396 void mitk::OdfVtkMapper2D<T,N> 00397 ::AdaptCameraPosition(mitk::BaseRenderer* renderer, OdfDisplayGeometry* dispGeo ) 00398 { 00399 00400 double viewAngle = renderer->GetVtkRenderer()->GetActiveCamera()->GetViewAngle(); 00401 viewAngle = viewAngle * (ODF_MAPPER_PI/180.0); 00402 viewAngle /= 2; 00403 double dist = dispGeo->d/tan(viewAngle); 00404 00405 mitk::Point3D mfoc; 00406 mfoc[0]=dispGeo->M3D[0]; 00407 mfoc[1]=dispGeo->M3D[1]; 00408 mfoc[2]=dispGeo->M3D[2]; 00409 00410 mitk::Point3D mpos; 00411 mpos[0]=mfoc[0]+dist*dispGeo->normal[0]; 00412 mpos[1]=mfoc[1]+dist*dispGeo->normal[1]; 00413 mpos[2]=mfoc[2]+dist*dispGeo->normal[2]; 00414 00415 mitk::Point3D mup; 00416 mup[0]=dispGeo->O3D[0]-dispGeo->M3D[0]; 00417 mup[1]=dispGeo->O3D[1]-dispGeo->M3D[1]; 00418 mup[2]=dispGeo->O3D[2]-dispGeo->M3D[2]; 00419 00420 renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true); 00421 renderer->GetVtkRenderer()->GetActiveCamera()->SetParallelScale(dist/3.74); 00422 00423 vtkCamera* camera = renderer->GetVtkRenderer()->GetActiveCamera(); 00424 if (camera) 00425 { 00426 camera->SetPosition(mpos[0],mpos[1],mpos[2]); 00427 camera->SetFocalPoint(mfoc[0], mfoc[1],mfoc[2]); 00428 camera->SetViewUp(mup[0],mup[1],mup[2]); 00429 } 00430 renderer->GetVtkRenderer()->ResetCameraClippingRange(); 00431 } 00432 00433 template<class T, int N> 00434 typename mitk::OdfVtkMapper2D<T,N>::OdfDisplayGeometry* mitk::OdfVtkMapper2D<T,N> 00435 ::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer) 00436 { 00437 //vtkLinearTransform * vtktransform = this->GetDataNode()->GetVtkTransform(this->GetTimestep()); 00438 Geometry2D::ConstPointer worldGeometry = 00439 renderer->GetCurrentWorldGeometry2D(); 00440 PlaneGeometry::ConstPointer worldPlaneGeometry = 00441 dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() ); 00442 00443 // set up the cutter orientation according to the current geometry of 00444 // the renderers plane 00445 vtkFloatingPointType vp[ 3 ], vnormal[ 3 ]; 00446 Point3D point = worldPlaneGeometry->GetOrigin(); 00447 Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize(); 00448 vnl2vtk( point.Get_vnl_vector(), vp ); 00449 vnl2vtk( normal.Get_vnl_vector(), vnormal ); 00450 00451 mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry(); 00452 mitk::Vector2D size = dispGeometry->GetSizeInMM(); 00453 mitk::Vector2D origin = dispGeometry->GetOriginInMM(); 00454 00455 // 00456 // |------O------| 00457 // | d2 | 00458 // L d1 M | 00459 // | | 00460 // |-------------| 00461 // 00462 00463 mitk::Vector2D M; 00464 mitk::Vector2D L; 00465 mitk::Vector2D O; 00466 00467 M[0] = origin[0] + size[0]/2; 00468 M[1] = origin[1] + size[1]/2; 00469 00470 L[0] = origin[0]; 00471 L[1] = origin[1] + size[1]/2; 00472 00473 O[0] = origin[0] + size[0]/2; 00474 O[1] = origin[1] + size[1]; 00475 00476 mitk::Point2D point1; 00477 point1[0] = M[0]; point1[1] = M[1]; point1[2] = M[2]; 00478 mitk::Point3D M3D; 00479 dispGeometry->Map(point1, M3D); 00480 00481 point1[0] = L[0]; point1[1] = L[1]; point1[2] = L[2]; 00482 mitk::Point3D L3D; 00483 dispGeometry->Map(point1, L3D); 00484 00485 point1[0] = O[0]; point1[1] = O[1]; point1[2] = O[2]; 00486 mitk::Point3D O3D; 00487 dispGeometry->Map(point1, O3D); 00488 00489 double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0]) 00490 + (M3D[1]-L3D[1])*(M3D[1]-L3D[1]) 00491 + (M3D[2]-L3D[2])*(M3D[2]-L3D[2])); 00492 double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0]) 00493 + (M3D[1]-O3D[1])*(M3D[1]-O3D[1]) 00494 + (M3D[2]-O3D[2])*(M3D[2]-O3D[2])); 00495 double d = d1>d2 ? d1 : d2; 00496 d = d2; 00497 00498 OdfDisplayGeometry* retval = new OdfDisplayGeometry(); 00499 retval->vp[0] = vp[0]; 00500 retval->vp[1] = vp[1]; 00501 retval->vp[2] = vp[2]; 00502 retval->vnormal[0] = vnormal[0]; 00503 retval->vnormal[1] = vnormal[1]; 00504 retval->vnormal[2] = vnormal[2]; 00505 retval->normal[0] = normal[0]; 00506 retval->normal[1] = normal[1]; 00507 retval->normal[2] = normal[2]; 00508 retval->d = d; 00509 retval->d1 = d1; 00510 retval->d2 = d2; 00511 retval->M3D[0] = M3D[0]; 00512 retval->M3D[1] = M3D[1]; 00513 retval->M3D[2] = M3D[2]; 00514 retval->L3D[0] = L3D[0]; 00515 retval->L3D[1] = L3D[1]; 00516 retval->L3D[2] = L3D[2]; 00517 retval->O3D[0] = O3D[0]; 00518 retval->O3D[1] = O3D[1]; 00519 retval->O3D[2] = O3D[2]; 00520 00521 retval->vp_original[0] = vp[0]; 00522 retval->vp_original[1] = vp[1]; 00523 retval->vp_original[2] = vp[2]; 00524 retval->vnormal_original[0] = vnormal[0]; 00525 retval->vnormal_original[1] = vnormal[1]; 00526 retval->vnormal_original[2] = vnormal[2]; 00527 retval->size[0] = size[0]; 00528 retval->size[1] = size[1]; 00529 retval->origin[0] = origin[0]; 00530 retval->origin[1] = origin[1]; 00531 return retval; 00532 00533 } 00534 00535 template<class T, int N> 00536 void mitk::OdfVtkMapper2D<T,N> 00537 ::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry* dispGeo) 00538 { 00539 vtkLinearTransform * vtktransform = 00540 this->GetDataNode()->GetVtkTransform(this->GetTimestep()); 00541 00542 int index = GetIndex(renderer); 00543 00544 vtkTransform* inversetransform = vtkTransform::New(); 00545 inversetransform->Identity(); 00546 inversetransform->Concatenate(vtktransform->GetLinearInverse()); 00547 double myscale[3]; 00548 ((vtkTransform*)vtktransform)->GetScale(myscale); 00549 inversetransform->PostMultiply(); 00550 inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]); 00551 inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp ); 00552 inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal ); 00553 00554 // vtk works in axis align coords 00555 // thus the normal also must be axis align, since 00556 // we do not allow arbitrary cutting through volume 00557 // 00558 // vnormal should already be axis align, but in order 00559 // to get rid of precision effects, we set the two smaller 00560 // components to zero here 00561 int dims[3]; 00562 m_VtkImage->GetDimensions(dims); 00563 double spac[3]; 00564 m_VtkImage->GetSpacing(spac); 00565 if(fabs(dispGeo->vnormal[0]) > fabs(dispGeo->vnormal[1]) 00566 && fabs(dispGeo->vnormal[0]) > fabs(dispGeo->vnormal[2]) ) 00567 { 00568 if(fabs(dispGeo->vp[0]/spac[0]) < 0.4) 00569 dispGeo->vp[0] = 0.4*spac[0]; 00570 if(fabs(dispGeo->vp[0]/spac[0]) > (dims[0]-1)-0.4) 00571 dispGeo->vp[0] = ((dims[0]-1)-0.4)*spac[0]; 00572 dispGeo->vnormal[1] = 0; 00573 dispGeo->vnormal[2] = 0; 00574 } 00575 00576 if(fabs(dispGeo->vnormal[1]) > fabs(dispGeo->vnormal[0]) && fabs(dispGeo->vnormal[1]) > fabs(dispGeo->vnormal[2]) ) 00577 { 00578 if(fabs(dispGeo->vp[1]/spac[1]) < 0.4) 00579 dispGeo->vp[1] = 0.4*spac[1]; 00580 if(fabs(dispGeo->vp[1]/spac[1]) > (dims[1]-1)-0.4) 00581 dispGeo->vp[1] = ((dims[1]-1)-0.4)*spac[1]; 00582 dispGeo->vnormal[0] = 0; 00583 dispGeo->vnormal[2] = 0; 00584 } 00585 00586 if(fabs(dispGeo->vnormal[2]) > fabs(dispGeo->vnormal[1]) && fabs(dispGeo->vnormal[2]) > fabs(dispGeo->vnormal[0]) ) 00587 { 00588 if(fabs(dispGeo->vp[2]/spac[2]) < 0.4) 00589 dispGeo->vp[2] = 0.4*spac[2]; 00590 if(fabs(dispGeo->vp[2]/spac[2]) > (dims[2]-1)-0.4) 00591 dispGeo->vp[2] = ((dims[2]-1)-0.4)*spac[2]; 00592 dispGeo->vnormal[0] = 0; 00593 dispGeo->vnormal[1] = 0; 00594 } 00595 00596 00597 m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL ); 00598 m_Planes[index]->SetOrigin( dispGeo->vp ); 00599 m_Planes[index]->SetNormal( dispGeo->vnormal ); 00600 00601 vtkPoints* points = NULL; 00602 vtkPoints* tmppoints = NULL; 00603 vtkPolyData* polydata = NULL; 00604 vtkFloatArray* pointdata = NULL; 00605 vtkDelaunay2D *delaunay = NULL; 00606 vtkPolyData* cuttedPlane = NULL; 00607 if(!( (dims[0] == 1 && dispGeo->vnormal[0] != 0) || 00608 (dims[1] == 1 && dispGeo->vnormal[1] != 0) || 00609 (dims[2] == 1 && dispGeo->vnormal[2] != 0) )) 00610 { 00611 m_Cutters[index]->SetCutFunction( m_Planes[index] ); 00612 m_Cutters[index]->SetInput( m_VtkImage ); 00613 m_Cutters[index]->Update(); 00614 cuttedPlane = m_Cutters[index]->GetOutput(); 00615 } 00616 else 00617 { 00618 // cutting of a 2D-Volume does not work, 00619 // so we have to build up our own polydata object 00620 cuttedPlane = vtkPolyData::New(); 00621 points = vtkPoints::New(); 00622 points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints()); 00623 for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++) 00624 { 00625 points->SetPoint(i, m_VtkImage->GetPoint(i)); 00626 } 00627 cuttedPlane->SetPoints(points); 00628 00629 pointdata = vtkFloatArray::New(); 00630 int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents(); 00631 pointdata->SetNumberOfComponents(comps); 00632 int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples(); 00633 pointdata->SetNumberOfTuples(tuples); 00634 for(int i=0; i<tuples; i++) 00635 pointdata->SetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i)); 00636 pointdata->SetName( "vector" ); 00637 cuttedPlane->GetPointData()->AddArray(pointdata); 00638 00639 int nZero1, nZero2; 00640 if(dims[0]==1) 00641 { 00642 nZero1 = 1; nZero2 = 2; 00643 } 00644 else if(dims[1]==1) 00645 { 00646 nZero1 = 0; nZero2 = 2; 00647 } 00648 else 00649 { 00650 nZero1 = 0; nZero2 = 1; 00651 } 00652 00653 tmppoints = vtkPoints::New(); 00654 for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){ 00655 double pt[3]; 00656 m_VtkImage->GetPoint(j,pt); 00657 tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0); 00658 } 00659 00660 polydata = vtkPolyData::New(); 00661 polydata->SetPoints( tmppoints ); 00662 delaunay = vtkDelaunay2D::New(); 00663 delaunay->SetInput( polydata ); 00664 delaunay->Update(); 00665 vtkCellArray* polys = delaunay->GetOutput()->GetPolys(); 00666 cuttedPlane->SetPolys(polys); 00667 } 00668 00669 if(cuttedPlane->GetNumberOfPoints()) 00670 { 00671 // WINDOWING HERE 00672 inversetransform = vtkTransform::New(); 00673 inversetransform->Identity(); 00674 inversetransform->Concatenate(vtktransform->GetLinearInverse()); 00675 double myscale[3]; 00676 ((vtkTransform*)vtktransform)->GetScale(myscale); 00677 inversetransform->PostMultiply(); 00678 inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]); 00679 00680 dispGeo->vnormal[0] = dispGeo->M3D[0]-dispGeo->O3D[0]; 00681 dispGeo->vnormal[1] = dispGeo->M3D[1]-dispGeo->O3D[1]; 00682 dispGeo->vnormal[2] = dispGeo->M3D[2]-dispGeo->O3D[2]; 00683 vtkMath::Normalize(dispGeo->vnormal); 00684 dispGeo->vp[0] = dispGeo->M3D[0]; 00685 dispGeo->vp[1] = dispGeo->M3D[1]; 00686 dispGeo->vp[2] = dispGeo->M3D[2]; 00687 00688 inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp ); 00689 inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal ); 00690 00691 m_ThickPlanes1[index]->count = 0; 00692 m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL ); 00693 m_ThickPlanes1[index]->SetPose( dispGeo->vnormal, dispGeo->vp ); 00694 m_ThickPlanes1[index]->SetThickness(dispGeo->d2); 00695 m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] ); 00696 m_Clippers1[index]->SetInput( cuttedPlane ); 00697 m_Clippers1[index]->SetInsideOut(1); 00698 m_Clippers1[index]->Update(); 00699 00700 dispGeo->vnormal[0] = dispGeo->M3D[0]-dispGeo->L3D[0]; 00701 dispGeo->vnormal[1] = dispGeo->M3D[1]-dispGeo->L3D[1]; 00702 dispGeo->vnormal[2] = dispGeo->M3D[2]-dispGeo->L3D[2]; 00703 vtkMath::Normalize(dispGeo->vnormal); 00704 dispGeo->vp[0] = dispGeo->M3D[0]; 00705 dispGeo->vp[1] = dispGeo->M3D[1]; 00706 dispGeo->vp[2] = dispGeo->M3D[2]; 00707 00708 inversetransform->TransformPoint( dispGeo->vp, dispGeo->vp ); 00709 inversetransform->TransformNormalAtPoint( dispGeo->vp, dispGeo->vnormal, dispGeo->vnormal ); 00710 00711 m_ThickPlanes2[index]->count = 0; 00712 m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL ); 00713 m_ThickPlanes2[index]->SetPose( dispGeo->vnormal, dispGeo->vp ); 00714 m_ThickPlanes2[index]->SetThickness(dispGeo->d1); 00715 m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] ); 00716 m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() ); 00717 m_Clippers2[index]->SetInsideOut(1); 00718 m_Clippers2[index]->Update(); 00719 00720 cuttedPlane = m_Clippers2[index]->GetOutput (); 00721 00722 if(cuttedPlane->GetNumberOfPoints()) 00723 { 00724 m_OdfsPlanes[index]->RemoveAllInputs(); 00725 00726 vtkPolyDataNormals* normals = vtkPolyDataNormals::New(); 00727 normals->SetInputConnection( m_OdfSource->GetOutputPort() ); 00728 normals->SplittingOff(); 00729 normals->ConsistencyOff(); 00730 normals->AutoOrientNormalsOff(); 00731 normals->ComputePointNormalsOn(); 00732 normals->ComputeCellNormalsOff(); 00733 normals->FlipNormalsOff(); 00734 normals->NonManifoldTraversalOff(); 00735 00736 vtkTransformPolyDataFilter* trans = vtkTransformPolyDataFilter::New(); 00737 trans->SetInputConnection( normals->GetOutputPort() ); 00738 trans->SetTransform(m_OdfTransform); 00739 00740 vtkMaskedProgrammableGlyphFilter* glyphGenerator = vtkMaskedProgrammableGlyphFilter::New(); 00741 glyphGenerator->SetMaximumNumberOfPoints(m_ShowMaxNumber); 00742 glyphGenerator->SetRandomMode(1); 00743 glyphGenerator->SetUseMaskPoints(1); 00744 glyphGenerator->SetSource( trans->GetOutput() ); 00745 glyphGenerator->SetInput(cuttedPlane); 00746 glyphGenerator->SetColorModeToColorBySource(); 00747 glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector"); 00748 glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry()); 00749 glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator); 00750 try 00751 { 00752 glyphGenerator->Update(); 00753 } 00754 catch( itk::ExceptionObject& err ) 00755 { 00756 std::cout << err << std::endl; 00757 } 00758 m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput()); 00759 00760 trans->Delete(); 00761 glyphGenerator->Delete(); 00762 normals->Delete(); 00763 00764 m_OdfsPlanes[index]->Update(); 00765 } 00766 00767 } 00768 m_PropAssemblies[index]->VisibilityOn(); 00769 if(m_PropAssemblies[index]->GetParts()->IsItemPresent(m_OdfsActors[index])) 00770 m_PropAssemblies[index]->RemovePart(m_OdfsActors[index]); 00771 m_OdfsMappers[index]->SetInput(m_OdfsPlanes[index]->GetOutput()); 00772 m_PropAssemblies[index]->AddPart(m_OdfsActors[index]); 00773 00774 if(inversetransform) inversetransform->Delete(); 00775 if(points) points->Delete(); 00776 if(pointdata) pointdata->Delete(); 00777 if(tmppoints) tmppoints->Delete(); 00778 if(polydata) polydata->Delete(); 00779 if(delaunay) delaunay->Delete(); 00780 00781 } 00782 00783 template<class T, int N> 00784 void mitk::OdfVtkMapper2D<T,N> 00785 ::MitkRenderOverlay(mitk::BaseRenderer* renderer) 00786 { 00787 //std::cout << "MitkRenderOverlay(" << renderer->GetName() << ")" << std::endl; 00788 if ( this->IsVisible(renderer, "VisibleOdfs")==false ) 00789 return; 00790 00791 if ( this->GetProp(renderer)->GetVisibility() ) 00792 { 00793 this->GetProp(renderer)->RenderOverlay(renderer->GetVtkRenderer()); 00794 } 00795 } 00796 00797 template<class T, int N> 00798 void mitk::OdfVtkMapper2D<T,N> 00799 ::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer) 00800 { 00801 //std::cout << "MitkRenderOpaqueGeometry(" << renderer->GetName() << ")" << std::endl; 00802 if ( this->IsVisible( renderer, "VisibleOdfs" )==false ) 00803 return; 00804 00805 if ( this->GetProp(renderer)->GetVisibility() ) 00806 { 00807 00808 // adapt cam pos 00809 OdfDisplayGeometry* dispGeo = MeasureDisplayedGeometry( renderer); 00810 AdaptCameraPosition(renderer, dispGeo); 00811 00812 if(this->GetDataNode()->IsOn("DoRefresh",NULL)) 00813 { 00814 glMatrixMode( GL_PROJECTION ); 00815 glPushMatrix(); 00816 glLoadIdentity(); 00817 00818 glMatrixMode( GL_MODELVIEW ); 00819 glPushMatrix(); 00820 glLoadIdentity(); 00821 00822 renderer->GetVtkRenderer()->SetErase(false); 00823 renderer->GetVtkRenderer()->GetActiveCamera()->Render(renderer->GetVtkRenderer()); 00824 renderer->GetVtkRenderer()->SetErase(true); 00825 00826 //GLfloat matrix[16]; 00827 //glGetFloatv(GL_MODELVIEW_MATRIX, matrix); 00828 00829 float LightPos[4] = {0,0,0,0}; 00830 int index = GetIndex(renderer); 00831 if(index==0) 00832 { 00833 LightPos[2] = -1000; 00834 } 00835 if(index==1) 00836 { 00837 LightPos[0] = 1000; 00838 } 00839 if(index==2) 00840 { 00841 LightPos[1] = -1000; 00842 } 00843 glLightfv(GL_LIGHT0,GL_POSITION,LightPos); 00844 glLightfv(GL_LIGHT1,GL_POSITION,LightPos); 00845 glLightfv(GL_LIGHT2,GL_POSITION,LightPos); 00846 glLightfv(GL_LIGHT3,GL_POSITION,LightPos); 00847 glLightfv(GL_LIGHT4,GL_POSITION,LightPos); 00848 glLightfv(GL_LIGHT5,GL_POSITION,LightPos); 00849 glLightfv(GL_LIGHT6,GL_POSITION,LightPos); 00850 glLightfv(GL_LIGHT7,GL_POSITION,LightPos); 00851 00852 } 00853 00854 this->GetProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() ); 00855 00856 if(this->GetDataNode()->IsOn("DoRefresh",NULL)) 00857 { 00858 glMatrixMode( GL_PROJECTION ); 00859 glPopMatrix(); 00860 00861 glMatrixMode( GL_MODELVIEW ); 00862 glPopMatrix(); 00863 } 00864 } 00865 } 00866 00867 template<class T, int N> 00868 void mitk::OdfVtkMapper2D<T,N> 00869 ::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer) 00870 { 00871 //std::cout << "MitkRenderTranslucentGeometry(" << renderer->GetName() << ")" << std::endl; 00872 if ( this->IsVisible(renderer, "VisibleOdfs")==false ) 00873 return; 00874 00875 if ( this->GetProp(renderer)->GetVisibility() ) 00876 //BUG (#1551) changed VTK_MINOR_VERSION FROM 3 to 2 cause RenderTranslucentGeometry was changed in minor version 2 00877 #if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2) ) 00878 this->GetProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer()); 00879 #else 00880 this->GetProp(renderer)->RenderTranslucentGeometry(renderer->GetVtkRenderer()); 00881 #endif 00882 } 00883 00884 template<class T, int N> 00885 void mitk::OdfVtkMapper2D<T,N> 00886 ::GenerateData() 00887 { 00888 mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() ); 00889 if ( input.IsNull() ) return ; 00890 00891 std::string classname("TensorImage"); 00892 if(classname.compare(input->GetNameOfClass())==0) 00893 { 00894 m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData(); 00895 } 00896 00897 std::string qclassname("QBallImage"); 00898 if(qclassname.compare(input->GetNameOfClass())==0) 00899 { 00900 m_VtkImage = dynamic_cast<mitk::QBallImage*>( this->GetInput() )->GetNonRgbVtkImageData(); 00901 } 00902 00903 if( m_VtkImage ) 00904 { 00905 // make sure, that we have point data with more than 1 component (as vectors) 00906 vtkPointData* pointData = m_VtkImage->GetPointData(); 00907 if ( pointData == NULL ) 00908 { 00909 itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" ); 00910 return ; 00911 } 00912 if ( pointData->GetNumberOfArrays() == 0 ) 00913 { 00914 itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" ); 00915 return ; 00916 } 00917 else if ( pointData->GetArray(0)->GetNumberOfComponents() != N 00918 && pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/) 00919 { 00920 itkWarningMacro( << "number of components != number of directions in ODF!" ); 00921 return; 00922 } 00923 else if ( pointData->GetArrayName( 0 ) == NULL ) 00924 { 00925 m_VtkImage->GetPointData()->GetArray(0)->SetName("vector"); 00926 } 00927 } 00928 else 00929 { 00930 itkWarningMacro( << "m_VtkImage is NULL!" ); 00931 return ; 00932 } 00933 } 00934 00935 template<class T, int N> 00936 void mitk::OdfVtkMapper2D<T,N> 00937 ::AdaptOdfScalingToImageSpacing( int index ) 00938 { 00939 // Spacing adapted scaling 00940 double spacing[3]; 00941 m_VtkImage->GetSpacing(spacing); 00942 double min; 00943 if(index==0) 00944 { 00945 min = spacing[0]; 00946 min = min > spacing[1] ? spacing[1] : min; 00947 } 00948 if(index==1) 00949 { 00950 min = spacing[1]; 00951 min = min > spacing[2] ? spacing[2] : min; 00952 } 00953 if(index==2) 00954 { 00955 min = spacing[0]; 00956 min = min > spacing[2] ? spacing[2] : min; 00957 } 00958 m_OdfSource->SetScale(min); 00959 } 00960 00961 template<class T, int N> 00962 void mitk::OdfVtkMapper2D<T,N> 00963 ::SetRendererLightSources( mitk::BaseRenderer *renderer ) 00964 { 00965 // Light Sources 00966 vtkCollectionSimpleIterator sit; 00967 vtkLight* light; 00968 for(renderer->GetVtkRenderer()->GetLights()->InitTraversal(sit); 00969 (light = renderer->GetVtkRenderer()->GetLights()->GetNextLight(sit)); ) 00970 { 00971 renderer->GetVtkRenderer()->RemoveLight(light); 00972 } 00973 00974 light = vtkLight::New(); 00975 light->SetFocalPoint(0,0,0); 00976 light->SetLightTypeToSceneLight(); 00977 light->SwitchOn(); 00978 light->SetIntensity(1.0); 00979 light->PositionalOff(); 00980 00981 itk::Point<float> p; 00982 int index = GetIndex(renderer); 00983 if(index==0) 00984 { 00985 p[0] = 0; p[1] = 0; p[2] = 10000; 00986 } 00987 if(index==1) 00988 { 00989 p[0] = 0; p[1] = 10000; p[2] = 0; 00990 } 00991 if(index==2) 00992 { 00993 p[0] = 10000; p[1] = 0; p[2] = 0; 00994 } 00995 00996 mitk::Point3D p2; 00997 this->GetInput()->GetGeometry()->IndexToWorld(p,p2); 00998 light->SetPosition(p2[0],p2[1],p2[2]); 00999 renderer->GetVtkRenderer()->AddLight(light); 01000 } 01001 01002 template<class T, int N> 01003 void mitk::OdfVtkMapper2D<T,N> 01004 ::ApplyPropertySettings() 01005 { 01006 this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling ); 01007 this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber ); 01008 01009 OdfNormalizationMethodProperty* nmp = dynamic_cast 01010 <OdfNormalizationMethodProperty*>( 01011 this->GetDataNode()->GetProperty( "Normalization" )); 01012 if(nmp) 01013 { 01014 m_Normalization = nmp->GetNormalization(); 01015 } 01016 01017 OdfScaleByProperty* sbp = dynamic_cast 01018 <OdfScaleByProperty*>( 01019 this->GetDataNode()->GetProperty( "ScaleBy" )); 01020 if(sbp) 01021 { 01022 m_ScaleBy = sbp->GetScaleBy(); 01023 } 01024 01025 this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1); 01026 this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2); 01027 } 01028 01029 template<class T, int N> 01030 void mitk::OdfVtkMapper2D<T,N> 01031 ::GenerateData( mitk::BaseRenderer *renderer ) 01032 { 01033 if(!m_VtkImage) 01034 { 01035 itkWarningMacro( << "m_VtkImage is NULL!" ); 01036 return ; 01037 } 01038 01039 int index = GetIndex(renderer); 01040 01041 if(IsVisible(renderer, "VisibleOdfs")==false) 01042 { 01043 m_OdfsActors[0]->VisibilityOff(); 01044 m_OdfsActors[1]->VisibilityOff(); 01045 m_OdfsActors[2]->VisibilityOff(); 01046 return; 01047 } 01048 else 01049 { 01050 m_OdfsActors[0]->VisibilityOn(); 01051 m_OdfsActors[1]->VisibilityOn(); 01052 m_OdfsActors[2]->VisibilityOn(); 01053 01054 OdfDisplayGeometry* dispGeo = 01055 MeasureDisplayedGeometry( renderer); 01056 01057 if(!m_LastDisplayGeometry || !dispGeo->Equals(m_LastDisplayGeometry)) 01058 { 01059 AdaptOdfScalingToImageSpacing(index); 01060 SetRendererLightSources(renderer); 01061 ApplyPropertySettings(); 01062 AdaptCameraPosition(renderer, dispGeo); 01063 Slice(renderer, dispGeo); 01064 m_LastDisplayGeometry = dispGeo; 01065 } 01066 } 01067 01068 // Get the TimeSlicedGeometry of the input object 01069 mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput()); 01070 const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry(); 01071 if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetTimeSteps() == 0 )) 01072 { 01073 m_PropAssemblies[0]->VisibilityOff(); 01074 m_PropAssemblies[1]->VisibilityOff(); 01075 m_PropAssemblies[2]->VisibilityOff(); 01076 return; 01077 } 01078 01079 if( inputTimeGeometry->IsValidTime( this->GetTimestep() ) == false ) 01080 { 01081 m_PropAssemblies[0]->VisibilityOff(); 01082 m_PropAssemblies[1]->VisibilityOff(); 01083 m_PropAssemblies[2]->VisibilityOff(); 01084 return; 01085 } 01086 01087 01088 } 01089 01090 template<class T, int N> 01091 void mitk::OdfVtkMapper2D<T,N> 01092 ::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* /*renderer*/, bool /*overwrite*/) 01093 { 01094 node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) ); 01095 node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) ); 01096 node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New()); 01097 node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New()); 01098 node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2)); 01099 node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1)); 01100 node->SetProperty( "visible", mitk::BoolProperty::New( true ) ); 01101 node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) ); 01102 node->SetProperty ("layer", mitk::IntProperty::New(100)); 01103 node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) ); 01104 //node->SetProperty( "opacity", mitk::FloatProperty::New(1.0f) ); 01105 } 01106 01107 #endif // __mitkOdfVtkMapper2D_txx__ 01108
