mitk: QmitkControlVisualizationPropertiesView.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Module:    $RCSfile$
00005 Language:  C++
00006 Date:      $Date: 2009-05-28 17:19:30 +0200 (Do, 28 Mai 2009) $
00007 Version:   $Revision: 17495 $ 
00008 
00009 Copyright (c) German Cancer Research Center, Division of Medical and
00010 Biological Informatics. All rights reserved.
00011 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00012 
00013 This software is distributed WITHOUT ANY WARRANTY; without even
00014 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00015 PURPOSE.  See the above copyright notices for more information.
00016 
00017 =========================================================================*/
00018 
00019 #include "QmitkControlVisualizationPropertiesView.h"
00020 
00021 #include "mitkNodePredicateDataType.h"
00022 #include "mitkDataNodeObject.h"
00023 #include "mitkOdfNormalizationMethodProperty.h"
00024 #include "mitkOdfScaleByProperty.h"
00025 
00026 #include "QmitkDataStorageComboBox.h"
00027 #include "QmitkStdMultiWidget.h"
00028 
00029 #include "berryIWorkbenchWindow.h"
00030 #include "berryIWorkbenchPage.h"
00031 #include "berryISelectionService.h"
00032 #include "berryConstants.h"
00033 #include "berryPlatformUI.h"
00034 
00035 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
00036 
00037 using namespace berry;
00038 
00039 struct CvpSelListener : ISelectionListener
00040 {
00041 
00042   berryObjectMacro(CvpSelListener);
00043 
00044   CvpSelListener(QmitkControlVisualizationPropertiesView* view)
00045   {
00046     m_View = view;
00047   }
00048 
00049   void ApplySettings(mitk::DataNode::Pointer node)
00050   {
00051     bool do_vis;
00052     node->GetBoolProperty("VisibleOdfs", do_vis);
00053     if(do_vis)
00054     {
00055       m_View->m_Controls->m_VisibleOdfsON->setIcon(*m_View->m_IconGlyON);
00056       m_View->m_Controls->m_VisibleOdfsON->setChecked(true);
00057       m_View->m_GlyIsOn = true;
00058     }
00059     else
00060     {
00061       m_View->m_Controls->m_VisibleOdfsON->setIcon(*m_View->m_IconGlyOFF);
00062       m_View->m_Controls->m_VisibleOdfsON->setChecked(false);
00063       m_View->m_GlyIsOn = false;
00064     }
00065 
00066     bool tex_int;
00067     node->GetBoolProperty("texture interpolation", tex_int);
00068     if(tex_int)
00069     {
00070       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
00071       m_View->m_Controls->m_TextureIntON->setChecked(true);
00072       m_View->m_TexIsOn = true;
00073     }
00074     else
00075     {
00076       m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
00077       m_View->m_Controls->m_TextureIntON->setChecked(false);
00078       m_View->m_TexIsOn = false;
00079     }
00080 
00081     int val;
00082     node->GetIntProperty("ShowMaxNumber", val);
00083     m_View->m_Controls->m_ShowMaxNumber->setValue(val);
00084 
00085     m_View->m_Controls->m_NormalizationDropdown->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))->GetValueAsId());
00086 
00087     float fval;
00088     node->GetFloatProperty("Scaling",fval);
00089     m_View->m_Controls->m_ScalingFactor->setValue(fval);
00090 
00091     m_View->m_Controls->m_AdditionalScaling->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
00092 
00093     node->GetFloatProperty("IndexParam1",fval);
00094     m_View->m_Controls->m_IndexParam1->setValue(fval);
00095 
00096     node->GetFloatProperty("IndexParam2",fval);
00097     m_View->m_Controls->m_IndexParam2->setValue(fval);
00098   }
00099 
00100   void DoSelectionChanged(ISelection::ConstPointer selection)
00101   {
00102     // save current selection in member variable
00103     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
00104 
00105     m_View->m_Controls->m_VisibleOdfsON->setVisible(false);
00106     m_View->m_Controls->m_TextureIntON->setVisible(false);
00107 
00108     bool foundDiffusionImage = false;
00109     bool foundQBIVolume = false;
00110     bool foundTensorVolume = false;
00111     bool foundImage = false;
00112     bool foundMultipleOdfImages = false;
00113 
00114     // do something with the selected items
00115     if(m_View->m_CurrentSelection)
00116     {
00117       // iterate selection
00118       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin(); 
00119       i != m_View->m_CurrentSelection->End(); ++i)
00120       {
00121 
00122         // extract datatree node
00123         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00124         {
00125           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00126 
00127           // only look at interesting types
00128           if(QString("DiffusionImage").compare(node->GetData()->GetNameOfClass())==0)
00129           {
00130             foundDiffusionImage = true;
00131             bool tex_int;
00132             node->GetBoolProperty("texture interpolation", tex_int);
00133             if(tex_int)
00134             {
00135               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
00136               m_View->m_Controls->m_TextureIntON->setChecked(true);
00137               m_View->m_TexIsOn = true;
00138             }
00139             else
00140             {
00141               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
00142               m_View->m_Controls->m_TextureIntON->setChecked(false);
00143               m_View->m_TexIsOn = false;
00144             }
00145             int val;
00146             node->GetIntProperty("DisplayChannel", val);
00147             m_View->m_Controls->m_DisplayIndex->setValue(val);
00148 
00149           }
00150 
00151           else if(QString("QBallImage").compare(node->GetData()->GetNameOfClass())==0)
00152           {
00153             foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
00154             foundQBIVolume = true;
00155             ApplySettings(node);
00156           }
00157 
00158           else if(QString("TensorImage").compare(node->GetData()->GetNameOfClass())==0)
00159           {
00160             foundMultipleOdfImages = foundQBIVolume || foundTensorVolume;
00161             foundTensorVolume = true;
00162             ApplySettings(node);
00163           }
00164 
00165           else if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
00166           {
00167             foundImage = true;
00168             bool tex_int;
00169             node->GetBoolProperty("texture interpolation", tex_int);
00170             if(tex_int)
00171             {
00172               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexON);
00173               m_View->m_Controls->m_TextureIntON->setChecked(true);
00174               m_View->m_TexIsOn = true;
00175             }
00176             else
00177             {
00178               m_View->m_Controls->m_TextureIntON->setIcon(*m_View->m_IconTexOFF);
00179               m_View->m_Controls->m_TextureIntON->setChecked(false);
00180               m_View->m_TexIsOn = false;
00181             }
00182           }
00183         }
00184       }
00185     }
00186 
00187     m_View->m_Controls->m_DisplayIndex->setVisible(foundDiffusionImage);
00188 
00189     m_View->m_FoundSingleOdfImage = (foundQBIVolume || foundTensorVolume)
00190                                     && !foundMultipleOdfImages;
00191     m_View->m_Controls->m_ShowMaxNumber->setVisible(m_View->m_FoundSingleOdfImage);
00192     m_View->m_Controls->m_NormalizationDropdown->setVisible(m_View->m_FoundSingleOdfImage);
00193     m_View->m_Controls->label->setVisible(m_View->m_FoundSingleOdfImage);
00194     m_View->m_Controls->m_ScalingFactor->setVisible(m_View->m_FoundSingleOdfImage);
00195     m_View->m_Controls->m_AdditionalScaling->setVisible(m_View->m_FoundSingleOdfImage);
00196 
00197     m_View->m_Controls->OpacMinFrame->setVisible(m_View->m_FoundSingleOdfImage);
00198     m_View->m_Controls->OpacMaxFrame->setVisible(m_View->m_FoundSingleOdfImage);
00199 
00200     // changed for SPIE paper, Principle curvature scaling
00201     //m_View->m_Controls->params_frame->setVisible(m_View->m_FoundSingleOdfImage);
00202     m_View->m_Controls->params_frame->setVisible(false);
00203 
00204     m_View->m_Controls->m_VisibleOdfsON->setVisible(m_View->m_FoundSingleOdfImage);
00205 
00206     bool foundAnyImage = foundDiffusionImage ||
00207                          foundQBIVolume || foundTensorVolume || foundImage;
00208 
00209     m_View->m_Controls->m_Reinit->setVisible(foundAnyImage);
00210     m_View->m_Controls->m_TextureIntON->setVisible(foundAnyImage);
00211 
00212     if(m_View->m_IsInitialized)
00213     {
00214       //m_View->GetSite()->GetWorkbenchWindow()->GetActivePage()
00215       //  ->HideView(IViewPart::Pointer(m_View));
00216 
00217       //berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()
00218       //  ->ShowView(QmitkControlVisualizationPropertiesView::VIEW_ID,
00219       //  "", berry::IWorkbenchPage::VIEW_VISIBLE);
00220 
00221     }
00222   }
00223 
00224   void SelectionChanged(IWorkbenchPart::Pointer part, ISelection::ConstPointer selection)
00225   {
00226     // check, if selection comes from datamanager
00227     if (part)
00228     {
00229       QString partname(part->GetPartName().c_str());
00230       if(partname.compare("Datamanager")==0)
00231       {
00232 
00233         // apply selection
00234         DoSelectionChanged(selection);
00235 
00236       }
00237     }
00238   }
00239 
00240   QmitkControlVisualizationPropertiesView* m_View;
00241 };
00242 
00243 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
00244   : QmitkFunctionality(),
00245   m_Controls(NULL),
00246   m_MultiWidget(NULL),
00247   m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
00248   m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
00249   m_IconGlyOFF(new QIcon(":/QmitkDiffusionImaging/glyphsoff.png")),
00250   m_IconGlyON(new QIcon(":/QmitkDiffusionImaging/glyphson.png"))
00251 {
00252 }
00253 
00254 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
00255 {
00256   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00257 }
00258 
00259 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
00260 {
00261   if (!m_Controls)
00262   {
00263     // create GUI widgets
00264     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
00265     m_Controls->setupUi(parent);
00266     this->CreateConnections();
00267 
00268     m_Controls->params_frame->setVisible(false);
00269 
00270     QIcon icon5(":/QmitkDiffusionImaging/Refresh_48.png");
00271     m_Controls->m_Reinit->setIcon(icon5);
00272 
00273     m_Controls->m_TextureIntON->setCheckable(true);
00274     m_Controls->m_VisibleOdfsON->setCheckable(true);
00275 
00276 #ifndef DIFFUSION_IMAGING_EXTENDED
00277     int size = m_Controls->m_AdditionalScaling->count();
00278     for(int t=0; t<size; t++)
00279     {
00280       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
00281       {
00282         m_Controls->m_AdditionalScaling->removeItem(t);
00283       }
00284     }
00285 #endif
00286 
00287   }
00288 
00289   
00290 
00291   m_IsInitialized = false;
00292   m_SelListener = berry::ISelectionListener::Pointer(new CvpSelListener(this));
00293   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener);
00294   berry::ISelection::ConstPointer sel(
00295       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00296   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00297   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
00298   m_IsInitialized = true;
00299 }
00300 
00301 void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
00302 {
00303   m_MultiWidget = &stdMultiWidget;
00304 }
00305 
00306 void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
00307 {
00308   m_MultiWidget = NULL;
00309 }
00310 
00311 void QmitkControlVisualizationPropertiesView::CreateConnections()
00312 {
00313   if ( m_Controls )
00314   {
00315     connect( (QObject*)(m_Controls->m_DisplayIndex), SIGNAL(valueChanged(int)), this, SLOT(DisplayIndexChanged(int)) );
00316     connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
00317     connect( (QObject*)(m_Controls->m_Reinit), SIGNAL(clicked()), this, SLOT(Reinit()) );
00318 
00319     connect( (QObject*)(m_Controls->m_VisibleOdfsON), SIGNAL(clicked()), this, SLOT(VisibleOdfsON()) );
00320     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
00321     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
00322     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
00323     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
00324     connect( (QObject*)(m_Controls->m_IndexParam1), SIGNAL(valueChanged(double)), this, SLOT(IndexParam1Changed(double)) );
00325     connect( (QObject*)(m_Controls->m_IndexParam2), SIGNAL(valueChanged(double)), this, SLOT(IndexParam2Changed(double)) );
00326 
00327     connect( (QObject*)(m_Controls->m_OpacityMinFa), SIGNAL(valueChanged(int)), this, SLOT(OpacityMinFaChanged(int)) );
00328     connect( (QObject*)(m_Controls->m_OpacityMaxFa), SIGNAL(valueChanged(int)), this, SLOT(OpacityMaxFaChanged(int)) );
00329 
00330   }
00331 }
00332 
00333 void QmitkControlVisualizationPropertiesView::Activated()
00334 {
00335   berry::ISelection::ConstPointer sel(
00336       this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00337   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
00338   m_SelListener.Cast<CvpSelListener>()->DoSelectionChanged(sel);
00339   QmitkFunctionality::Activated();
00340 }
00341 
00342 void QmitkControlVisualizationPropertiesView::Deactivated()
00343 {
00344   QmitkFunctionality::Deactivated();
00345 }
00346 
00347 int QmitkControlVisualizationPropertiesView::GetSizeFlags(bool width)
00348 {
00349   if(!width)
00350   {
00351     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
00352   }
00353   else
00354   {
00355     return 0;
00356   }
00357 }
00358 
00359 int QmitkControlVisualizationPropertiesView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
00360 {
00361   if(width==false)
00362   {
00363     return m_FoundSingleOdfImage ? 120 : 80;
00364   }
00365   else
00366   {
00367     return preferredResult;
00368   }
00369 }
00370 
00371 mitk::DataStorage::SetOfObjects::Pointer
00372     QmitkControlVisualizationPropertiesView::ActiveSet(std::string classname)
00373 {
00374   if (m_CurrentSelection)
00375   {
00376     mitk::DataStorage::SetOfObjects::Pointer set =
00377         mitk::DataStorage::SetOfObjects::New();
00378 
00379     int at = 0;
00380     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin(); 
00381     i != m_CurrentSelection->End();
00382     ++i)
00383     {
00384 
00385       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
00386       {
00387         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00388         if(QString(classname.c_str()).compare(node->GetData()->GetNameOfClass())==0)
00389         {
00390           set->InsertElement(at++, node);
00391         }
00392       }
00393     }
00394 
00395     return set;
00396   }
00397 
00398   return 0;
00399 }
00400 
00401 void QmitkControlVisualizationPropertiesView::SetBoolProp(
00402     mitk::DataStorage::SetOfObjects::Pointer set,
00403     std::string name, bool value)
00404 {
00405   if(set.IsNotNull())
00406   {
00407 
00408     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00409     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00410     while ( itemiter != itemiterend )
00411     {
00412       (*itemiter)->SetBoolProperty(name.c_str(), value);
00413       ++itemiter;
00414     }
00415   }
00416 }
00417 
00418 void QmitkControlVisualizationPropertiesView::SetIntProp(
00419     mitk::DataStorage::SetOfObjects::Pointer set,
00420     std::string name, int value)
00421 {
00422   if(set.IsNotNull())
00423   {
00424 
00425     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00426     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00427     while ( itemiter != itemiterend )
00428     {
00429       (*itemiter)->SetIntProperty(name.c_str(), value);
00430       ++itemiter;
00431     }
00432   }
00433 }
00434 
00435 void QmitkControlVisualizationPropertiesView::SetFloatProp(
00436     mitk::DataStorage::SetOfObjects::Pointer set,
00437     std::string name, float value)
00438 {
00439   if(set.IsNotNull())
00440   {
00441 
00442     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00443     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00444     while ( itemiter != itemiterend )
00445     {
00446       (*itemiter)->SetFloatProperty(name.c_str(), value);
00447       ++itemiter;
00448     }
00449   }
00450 }
00451 
00452 void QmitkControlVisualizationPropertiesView::SetLevelWindowProp(
00453     mitk::DataStorage::SetOfObjects::Pointer set,
00454     std::string name, mitk::LevelWindow value)
00455 {
00456   if(set.IsNotNull())
00457   {
00458 
00459     mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(value);
00460 
00461     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00462     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00463     while ( itemiter != itemiterend )
00464     {
00465       (*itemiter)->SetProperty(name.c_str(), prop);
00466       ++itemiter;
00467     }
00468   }
00469 }
00470 
00471 void QmitkControlVisualizationPropertiesView::SetEnumProp(
00472     mitk::DataStorage::SetOfObjects::Pointer set,
00473     std::string name, mitk::EnumerationProperty::Pointer value)
00474 {
00475   if(set.IsNotNull())
00476   {
00477     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00478     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00479     while ( itemiter != itemiterend )
00480     {
00481       (*itemiter)->SetProperty(name.c_str(), value);
00482       ++itemiter;
00483     }
00484   }
00485 }
00486 
00487 void QmitkControlVisualizationPropertiesView::DisplayIndexChanged(int dispIndex)
00488 {
00489   mitk::DataStorage::SetOfObjects::Pointer set =
00490       ActiveSet("DiffusionImage");
00491 
00492   if(set.IsNotNull())
00493   {
00494 
00495     mitk::DataStorage::SetOfObjects::const_iterator itemiter( set->begin() );
00496     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( set->end() );
00497     while ( itemiter != itemiterend )
00498     {
00499       (*itemiter)->SetIntProperty("DisplayChannel", dispIndex);
00500       ++itemiter;
00501     }
00502 
00503     //m_MultiWidget->RequestUpdate();
00504     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00505   }
00506 }
00507 
00508 void QmitkControlVisualizationPropertiesView::Reinit()
00509 {
00510   if (m_CurrentSelection)
00511   {
00512     mitk::DataNodeObject::Pointer nodeObj = 
00513         m_CurrentSelection->Begin()->Cast<mitk::DataNodeObject>();
00514     mitk::DataNode::Pointer node = nodeObj->GetDataNode();
00515     mitk::BaseData::Pointer basedata = node->GetData();
00516     if (basedata.IsNotNull())
00517     {
00518       mitk::RenderingManager::GetInstance()->InitializeViews(
00519           basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
00520       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
00521     }
00522   }
00523 }
00524 
00525 void QmitkControlVisualizationPropertiesView::TextIntON()
00526 {
00527   if(m_TexIsOn)
00528   {
00529     m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
00530   }
00531   else
00532   {
00533     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
00534   }
00535 
00536   mitk::DataStorage::SetOfObjects::Pointer set =
00537       ActiveSet("DiffusionImage");
00538   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
00539 
00540   set = ActiveSet("TensorImage");
00541   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
00542 
00543   set = ActiveSet("QBallImage");
00544   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
00545 
00546   set = ActiveSet("Image");
00547   SetBoolProp(set,"texture interpolation", !m_TexIsOn);
00548 
00549   m_TexIsOn = !m_TexIsOn;
00550 
00551   if(m_MultiWidget)
00552     m_MultiWidget->RequestUpdate();
00553 
00554 }
00555 
00556 
00557 void QmitkControlVisualizationPropertiesView::VisibleOdfsON()
00558 {
00559   if(m_GlyIsOn)
00560   {
00561     m_Controls->m_VisibleOdfsON->setIcon(*m_IconGlyOFF);
00562   }
00563   else
00564   {
00565     m_Controls->m_VisibleOdfsON->setIcon(*m_IconGlyON);
00566   }
00567 
00568   mitk::DataStorage::SetOfObjects::Pointer set =
00569       ActiveSet("QBallImage");
00570   SetBoolProp(set,"VisibleOdfs", !m_GlyIsOn);
00571 
00572   set = ActiveSet("TensorImage");
00573   SetBoolProp(set,"VisibleOdfs", !m_GlyIsOn);
00574 
00575   m_GlyIsOn = !m_GlyIsOn;
00576 
00577   if(m_MultiWidget)
00578     m_MultiWidget->RequestUpdate();
00579 
00580 }
00581 
00582 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
00583 {
00584   int maxNr = m_Controls->m_ShowMaxNumber->value();
00585   if ( maxNr < 1 )
00586   {
00587     m_Controls->m_ShowMaxNumber->setValue( 1 );
00588     maxNr = 1;
00589   }
00590 
00591   mitk::DataStorage::SetOfObjects::Pointer set =
00592       ActiveSet("QBallImage");
00593   SetIntProp(set,"ShowMaxNumber", maxNr);
00594 
00595   set = ActiveSet("TensorImage");
00596   SetIntProp(set,"ShowMaxNumber", maxNr);
00597 
00598   if(m_MultiWidget)
00599     m_MultiWidget->RequestUpdate();
00600 
00601 }
00602 
00603 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
00604 {
00605   typedef mitk::OdfNormalizationMethodProperty PropType;
00606   PropType::Pointer normMeth = PropType::New();
00607 
00608   switch(normDropdown)
00609   {
00610   case 0:
00611     normMeth->SetNormalizationToMinMax();
00612     break;
00613   case 1:
00614     normMeth->SetNormalizationToMax();
00615     break;
00616   case 2:
00617     normMeth->SetNormalizationToNone();
00618     break;
00619   case 3:
00620     normMeth->SetNormalizationToGlobalMax();
00621     break;
00622   default:
00623     normMeth->SetNormalizationToMinMax();
00624   }
00625 
00626   mitk::DataStorage::SetOfObjects::Pointer set =
00627       ActiveSet("QBallImage");
00628   SetEnumProp(set,"Normalization", normMeth.GetPointer());
00629 
00630   set = ActiveSet("TensorImage");
00631   SetEnumProp(set,"Normalization", normMeth.GetPointer());
00632 
00633   if(m_MultiWidget)
00634     m_MultiWidget->RequestUpdate();
00635 
00636 }
00637 
00638 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
00639 {
00640 
00641   mitk::DataStorage::SetOfObjects::Pointer set =
00642       ActiveSet("QBallImage");
00643   SetFloatProp(set,"Scaling", scalingFactor);
00644 
00645   set = ActiveSet("TensorImage");
00646   SetFloatProp(set,"Scaling", scalingFactor);
00647 
00648   if(m_MultiWidget)
00649     m_MultiWidget->RequestUpdate();
00650 
00651 }
00652 
00653 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
00654 {
00655 
00656   typedef mitk::OdfScaleByProperty PropType;
00657   PropType::Pointer scaleBy = PropType::New();
00658 
00659   switch(additionalScaling)
00660   {
00661   case 0:
00662     scaleBy->SetScaleByNothing();
00663     break;
00664   case 1:
00665     scaleBy->SetScaleByGFA();
00666     //m_Controls->params_frame->setVisible(true);
00667     break;
00668 #ifdef DIFFUSION_IMAGING_EXTENDED
00669   case 2:
00670     scaleBy->SetScaleByPrincipalCurvature();
00671     // commented in for SPIE paper, Principle curvature scaling
00672     //m_Controls->params_frame->setVisible(true);
00673     break;
00674 #endif
00675   default:
00676     scaleBy->SetScaleByNothing();
00677   }
00678 
00679   mitk::DataStorage::SetOfObjects::Pointer set =
00680       ActiveSet("QBallImage");
00681   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
00682 
00683   set = ActiveSet("TensorImage");
00684   SetEnumProp(set,"ScaleBy", scaleBy.GetPointer());
00685 
00686   if(m_MultiWidget)
00687     m_MultiWidget->RequestUpdate();
00688 
00689 }
00690 
00691 void QmitkControlVisualizationPropertiesView::IndexParam1Changed(double param1)
00692 {
00693   mitk::DataStorage::SetOfObjects::Pointer set =
00694       ActiveSet("QBallImage");
00695   SetFloatProp(set,"IndexParam1", param1);
00696 
00697   set = ActiveSet("TensorImage");
00698   SetFloatProp(set,"IndexParam1", param1);
00699 
00700   if(m_MultiWidget)
00701     m_MultiWidget->RequestUpdate();
00702 }
00703 
00704 void QmitkControlVisualizationPropertiesView::IndexParam2Changed(double param2)
00705 {
00706   mitk::DataStorage::SetOfObjects::Pointer set =
00707       ActiveSet("QBallImage");
00708   SetFloatProp(set,"IndexParam2", param2);
00709 
00710   set = ActiveSet("TensorImage");
00711   SetFloatProp(set,"IndexParam2", param2);
00712 
00713   if(m_MultiWidget)
00714     m_MultiWidget->RequestUpdate();
00715 }
00716 
00717 void QmitkControlVisualizationPropertiesView::OpacityMinFaChanged(int v)
00718 {
00719   mitk::LevelWindow olw;
00720   olw.SetRangeMinMax(v*2.55, m_Controls->m_OpacityMaxFa->value()*2.55);
00721 
00722   mitk::DataStorage::SetOfObjects::Pointer set =
00723       ActiveSet("QBallImage");
00724   SetLevelWindowProp(set,"opaclevelwindow", olw);
00725 
00726   set = ActiveSet("TensorImage");
00727   SetLevelWindowProp(set,"opaclevelwindow", olw);
00728 
00729   m_Controls->m_OpacityMinFaLabel->setText(QString::number(v/100.0));
00730 
00731   if(m_MultiWidget)
00732     m_MultiWidget->RequestUpdate();
00733 }
00734 
00735 void QmitkControlVisualizationPropertiesView::OpacityMaxFaChanged(int v)
00736 {
00737   mitk::LevelWindow olw;
00738   olw.SetRangeMinMax(m_Controls->m_OpacityMinFa->value()*2.55, v*2.55);
00739 
00740   mitk::DataStorage::SetOfObjects::Pointer set =
00741       ActiveSet("QBallImage");
00742   SetLevelWindowProp(set,"opaclevelwindow", olw);
00743 
00744   set = ActiveSet("TensorImage");
00745   SetLevelWindowProp(set,"opaclevelwindow", olw);
00746 
00747   m_Controls->m_OpacityMaxFaLabel->setText(QString::number(v/100.0));
00748 
00749   if(m_MultiWidget)
00750     m_MultiWidget->RequestUpdate();
00751 }