mitk: mitkDiffusionImagingObjectFactory.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002  
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date: 2009-06-18 15:59:04 +0200 (Do, 18 Jun 2009) $
00006 Version:   $Revision: 16916 $
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 "mitkDiffusionImagingObjectFactory.h"
00019 
00020 #include "mitkProperties.h"
00021 #include "mitkBaseRenderer.h"
00022 #include "mitkDataNode.h"
00023 
00024 #include "mitkNrrdDiffusionImageIOFactory.h"
00025 #include "mitkNrrdDiffusionImageWriterFactory.h"
00026 #include "mitkNrrdDiffusionImageWriter.h"
00027 #include "mitkDiffusionImage.h"
00028 
00029 #include "mitkNrrdQBallImageIOFactory.h"
00030 #include "mitkNrrdQBallImageWriterFactory.h"
00031 #include "mitkNrrdQBallImageWriter.h"
00032 
00033 #include "mitkNrrdTensorImageIOFactory.h"
00034 #include "mitkNrrdTensorImageWriterFactory.h"
00035 #include "mitkNrrdTensorImageWriter.h"
00036 
00037 #include "mitkCompositeMapper.h"
00038 #include "mitkDiffusionImageMapper.h"
00039 
00040 typedef short DiffusionPixelType;
00041 typedef mitk::DiffusionImage<DiffusionPixelType> DiffusionImageShort;
00042 typedef std::multimap<std::string, std::string> MultimapType;
00043 
00044 mitk::DiffusionImagingObjectFactory::DiffusionImagingObjectFactory(bool /*registerSelf*/)
00045 :CoreObjectFactoryBase()
00046 {
00047 
00048   static bool alreadyDone = false;
00049   if (!alreadyDone)
00050   {
00051     MITK_INFO << "DiffusionImagingObjectFactory c'tor" << std::endl;
00052     RegisterIOFactories();
00053 
00054     itk::ObjectFactoryBase::RegisterFactory( NrrdDiffusionImageIOFactory::New() );
00055     itk::ObjectFactoryBase::RegisterFactory( NrrdQBallImageIOFactory::New() );
00056     itk::ObjectFactoryBase::RegisterFactory( NrrdTensorImageIOFactory::New() );
00057 
00058     mitk::NrrdDiffusionImageWriterFactory::RegisterOneFactory();
00059     mitk::NrrdQBallImageWriterFactory::RegisterOneFactory();
00060     mitk::NrrdTensorImageWriterFactory::RegisterOneFactory();
00061 
00062     m_FileWriters.push_back( NrrdDiffusionImageWriter<DiffusionPixelType>::New().GetPointer() );
00063     m_FileWriters.push_back( NrrdQBallImageWriter::New().GetPointer() );
00064     m_FileWriters.push_back( NrrdTensorImageWriter::New().GetPointer() );
00065 
00066     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(this);
00067     
00068     CreateFileExtensionsMap();
00069 
00070     alreadyDone = true;
00071   }
00072 
00073 }
00074 
00075 mitk::Mapper::Pointer mitk::DiffusionImagingObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id) 
00076 {
00077   mitk::Mapper::Pointer newMapper=NULL;
00078 
00079   if ( id == mitk::BaseRenderer::Standard2D )
00080   {
00081     std::string classname("QBallImage");
00082     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00083     {
00084       newMapper = mitk::CompositeMapper::New();
00085       newMapper->SetDataNode(node);
00086     }
00087     classname = "TensorImage";
00088     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00089     {
00090       newMapper = mitk::CompositeMapper::New();
00091       newMapper->SetDataNode(node);
00092     }
00093     classname = "DiffusionImage";
00094     if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00095     {
00096       newMapper = mitk::DiffusionImageMapper<short>::New();
00097       newMapper->SetDataNode(node);
00098     }
00099   }
00100   else if ( id == mitk::BaseRenderer::Standard3D )
00101   {
00102     // do nothing
00103   }
00104 
00105   return newMapper;
00106 }
00107 
00108 void mitk::DiffusionImagingObjectFactory::SetDefaultProperties(mitk::DataNode* node)
00109 {
00110   std::string classname = "QBallImage";
00111   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00112   {
00113     mitk::CompositeMapper::SetDefaultProperties(node);
00114   }
00115 
00116   classname = "TensorImage";
00117   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00118   {
00119     mitk::CompositeMapper::SetDefaultProperties(node);
00120   }
00121 
00122   classname = "DiffusionImage";
00123   if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
00124   {
00125     mitk::DiffusionImageMapper<short>::SetDefaultProperties(node);
00126   }
00127 }
00128 
00129 const char* mitk::DiffusionImagingObjectFactory::GetFileExtensions() 
00130 {
00131   std::string fileExtension;
00132   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
00133   return fileExtension.c_str();
00134 };
00135 
00136 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetFileExtensionsMap()
00137 {
00138   return m_FileExtensionsMap;
00139 }
00140 
00141 const char* mitk::DiffusionImagingObjectFactory::GetSaveFileExtensions() 
00142 { 
00143   std::string fileExtension;
00144   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
00145   return fileExtension.c_str();
00146 };
00147 
00148 mitk::CoreObjectFactoryBase::MultimapType mitk::DiffusionImagingObjectFactory::GetSaveFileExtensionsMap()
00149 {
00150   return m_SaveFileExtensionsMap;
00151 }
00152 
00153 void mitk::DiffusionImagingObjectFactory::CreateFileExtensionsMap()
00154 {
00155   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
00156   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
00157   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
00158   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
00159   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
00160   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
00161 
00162   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
00163   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
00164   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
00165   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
00166   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dti", "Tensor Images"));
00167   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdti", "Tensor Images"));
00168 }
00169 
00170 void mitk::DiffusionImagingObjectFactory::RegisterIOFactories() 
00171 {
00172 }
00173 
00174 void RegisterDiffusionImagingObjectFactory() 
00175 {
00176   static bool oneDiffusionImagingObjectFactoryRegistered = false;
00177   if ( ! oneDiffusionImagingObjectFactoryRegistered ) {
00178     MITK_INFO << "Registering DiffusionImagingObjectFactory..." << std::endl;
00179     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(mitk::DiffusionImagingObjectFactory::New());
00180 
00181     oneDiffusionImagingObjectFactoryRegistered = true;
00182   }
00183 }