diff --git a/Core/Code/Common/mitkCoreObjectFactory.cpp b/Core/Code/Common/mitkCoreObjectFactory.cpp
index 17c3d5e9c1..efd1d7169a 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Common/mitkCoreObjectFactory.cpp
@@ -1,412 +1,453 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConfig.h"
#include "mitkCoreObjectFactory.h"
#include "mitkAffineInteractor.h"
#include "mitkColorProperty.h"
#include "mitkDataNode.h"
#include "mitkEnumerationProperty.h"
#include "mitkPlaneGeometryData.h"
#include "mitkPlaneGeometryDataMapper2D.h"
#include "mitkPlaneGeometryDataVtkMapper3D.h"
#include "mitkGeometry3D.h"
#include "mitkGeometryData.h"
#include "mitkImage.h"
#include <mitkImageVtkMapper2D.h>
#include "mitkLevelWindowProperty.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkPlaneGeometry.h"
#include "mitkPointSet.h"
#include "mitkPointSetVtkMapper2D.h"
#include "mitkPointSetVtkMapper3D.h"
#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkSmartPointerProperty.h"
#include "mitkStringProperty.h"
#include "mitkSurface.h"
#include "mitkSurface.h"
#include "mitkSurfaceGLMapper2D.h"
#include "mitkSurfaceVtkMapper3D.h"
#include "mitkTimeGeometry.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkVolumeDataVtkMapper3D.h"
#include "mitkVtkInterpolationProperty.h"
#include "mitkVtkRepresentationProperty.h"
#include "mitkVtkResliceInterpolationProperty.h"
// Legacy Support:
#include <mitkCoreServices.h>
#include <Internal/mitkLegacyFileReaderService.h>
#include <Internal/mitkLegacyFileWriterService.h>
void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase* factory) {
MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
// Register Legacy Reader and Writer
this->RegisterLegacyReaders(factory);
this->RegisterLegacyWriters(factory);
}
void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
{
MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
+ this->UnRegisterLegacyWriters(factory);
+ this->UnRegisterLegacyReaders(factory);
try
{
m_ExtraFactories.erase(factory);
}
catch( std::exception const& e)
{
MITK_ERROR << "Caugt exception while unregistering: " << e.what();
}
}
mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance() {
static mitk::CoreObjectFactory::Pointer instance;
if (instance.IsNull())
{
instance = mitk::CoreObjectFactory::New();
}
return instance;
}
mitk::CoreObjectFactory::~CoreObjectFactory()
{
- for (std::list< mitk::LegacyFileReaderService* >::iterator it = m_LegacyReaders.begin();
- it != m_LegacyReaders.end(); ++it)
+ for (std::map<mitk::CoreObjectFactoryBase*, std::list< mitk::LegacyFileReaderService* > >::iterator iter = m_LegacyReaders.begin();
+ iter != m_LegacyReaders.end(); ++iter)
{
- delete *it;
+ for (std::list<mitk::LegacyFileReaderService*>::iterator readerIter = iter->second.begin(),
+ readerIterEnd = iter->second.end(); readerIter != readerIterEnd; ++readerIter)
+ {
+ delete *readerIter;
+ }
}
- for (std::list< mitk::LegacyFileWriterService* >::iterator it = m_LegacyWriters.begin();
- it != m_LegacyWriters.end(); ++it)
+ for (std::map<mitk::CoreObjectFactoryBase*, std::list< mitk::LegacyFileWriterService* > >::iterator iter = m_LegacyWriters.begin();
+ iter != m_LegacyWriters.end(); ++iter)
{
- delete *it;
+ for (std::list<mitk::LegacyFileWriterService*>::iterator writerIter = iter->second.begin(),
+ writerIterEnd = iter->second.end(); writerIter != writerIterEnd; ++writerIter)
+ {
+ delete *writerIter;
+ }
}
}
void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{
if(node==NULL)
return;
mitk::DataNode::Pointer nodePointer = node;
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
if(image.IsNotNull() && image->IsInitialized())
{
mitk::ImageVtkMapper2D::SetDefaultProperties(node);
mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
}
mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
if(surface.IsNotNull())
{
mitk::SurfaceGLMapper2D::SetDefaultProperties(node);
mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
}
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if(pointSet.IsNotNull())
{
mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
}
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
(*it)->SetDefaultProperties(node);
}
}
mitk::CoreObjectFactory::CoreObjectFactory()
{
static bool alreadyDone = false;
if (!alreadyDone)
{
CreateFileExtensionsMap();
//RegisterLegacyReaders(this);
//RegisterLegacyWriters(this);
alreadyDone = true;
}
}
mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
mitk::Mapper::Pointer newMapper = NULL;
mitk::Mapper::Pointer tmpMapper = NULL;
// check whether extra factories provide mapper
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
tmpMapper = (*it)->CreateMapper(node,id);
if(tmpMapper.IsNotNull())
newMapper = tmpMapper;
}
if (newMapper.IsNull())
{
mitk::BaseData *data = node->GetData();
if ( id == mitk::BaseRenderer::Standard2D )
{
if((dynamic_cast<Image*>(data)!=NULL))
{
newMapper = mitk::ImageVtkMapper2D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<PlaneGeometryData*>(data)!=NULL))
{
newMapper = mitk::PlaneGeometryDataMapper2D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Surface*>(data)!=NULL))
{
newMapper = mitk::SurfaceGLMapper2D::New();
// cast because SetDataNode is not virtual
mitk::SurfaceGLMapper2D *castedMapper = dynamic_cast<mitk::SurfaceGLMapper2D*>(newMapper.GetPointer());
castedMapper->SetDataNode(node);
}
else if((dynamic_cast<PointSet*>(data)!=NULL))
{
newMapper = mitk::PointSetVtkMapper2D::New();
newMapper->SetDataNode(node);
}
}
else if ( id == mitk::BaseRenderer::Standard3D )
{
if((dynamic_cast<Image*>(data) != NULL))
{
newMapper = mitk::VolumeDataVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<PlaneGeometryData*>(data)!=NULL))
{
newMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<Surface*>(data)!=NULL))
{
newMapper = mitk::SurfaceVtkMapper3D::New();
newMapper->SetDataNode(node);
}
else if((dynamic_cast<PointSet*>(data)!=NULL))
{
newMapper = mitk::PointSetVtkMapper3D::New();
newMapper->SetDataNode(node);
}
}
}
return newMapper;
}
const char* mitk::CoreObjectFactory::GetFileExtensions()
{
MultimapType aMap;
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
{
aMap = (*it)->GetFileExtensionsMap();
this->MergeFileExtensions(m_FileExtensionsMap, aMap);
}
this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
return m_FileExtensions.c_str();
}
void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType& fileExtensionsMap, MultimapType inputMap)
{
bool duplicateFound = false;
std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
for (MultimapType::iterator it = inputMap.begin(); it != inputMap.end(); ++it)
{
duplicateFound = false;
pairOfIter = fileExtensionsMap.equal_range((*it).first);
for (MultimapType::iterator it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
{
//cout << " [" << (*it).first << ", " << (*it).second << "]" << endl;
std::string aString = (*it2).second;
if (aString.compare((*it).second) == 0)
{
//cout << " DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
duplicateFound = true;
break;
}
}
if (!duplicateFound)
{
fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
}
}
}
mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
{
return m_FileExtensionsMap;
}
void mitk::CoreObjectFactory::CreateFileExtensionsMap()
{
/*
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
*/
}
const char* mitk::CoreObjectFactory::GetSaveFileExtensions() {
MultimapType aMap;
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
{
aMap = (*it)->GetSaveFileExtensionsMap();
this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
}
this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
return m_SaveFileExtensions.c_str();
}
mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
{
return m_SaveFileExtensionsMap;
}
mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters()
{
FileWriterList allWriters = m_FileWriters;
//sort to merge lists later on
typedef std::set<mitk::FileWriterWithInformation::Pointer> FileWriterSet;
FileWriterSet fileWritersSet;
fileWritersSet.insert(allWriters.begin(), allWriters.end());
//collect all extra factories
for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin();
it != m_ExtraFactories.end(); it++ )
{
FileWriterList list2 = (*it)->GetFileWriters();
//add them to the sorted set
fileWritersSet.insert(list2.begin(), list2.end());
}
//write back to allWriters to return a list
allWriters.clear();
allWriters.insert(allWriters.end(), fileWritersSet.begin(), fileWritersSet.end());
return allWriters;
}
void mitk::CoreObjectFactory::MapEvent(const mitk::Event*, const int)
{
}
std::string mitk::CoreObjectFactory::GetDescriptionForExtension(const std::string& extension)
{
std::multimap<std::string, std::string> fileExtensionMap = GetSaveFileExtensionsMap();
for(std::multimap<std::string, std::string>::iterator it = fileExtensionMap.begin(); it != fileExtensionMap.end(); it++)
if (it->first == extension) return it->second;
return ""; // If no matching extension was found, return emtpy string
}
void mitk::CoreObjectFactory::RegisterLegacyReaders(mitk::CoreObjectFactoryBase* factory)
{
// We are not really interested in the string, just call the method since
// many readers initialize the map the first time when this method is called
factory->GetFileExtensions();
std::map<std::string, std::vector<std::string> > extensionsByCategories;
std::multimap<std::string, std::string> fileExtensionMap = factory->GetFileExtensionsMap();
for(std::multimap<std::string, std::string>::iterator it = fileExtensionMap.begin(); it != fileExtensionMap.end(); it++)
{
std::string extension = it->first;
// remove "*."
extension = extension.erase(0,2);
extensionsByCategories[it->second].push_back(extension);
}
for(std::map<std::string, std::vector<std::string> >::iterator iter = extensionsByCategories.begin(),
endIter = extensionsByCategories.end(); iter != endIter; ++iter)
{
- m_LegacyReaders.push_back(new mitk::LegacyFileReaderService(iter->second, iter->first));
+ m_LegacyReaders[factory].push_back(new mitk::LegacyFileReaderService(iter->second, iter->first));
+ }
+}
+
+void mitk::CoreObjectFactory::UnRegisterLegacyReaders(mitk::CoreObjectFactoryBase* factory)
+{
+ std::map<mitk::CoreObjectFactoryBase*, std::list<mitk::LegacyFileReaderService*> >::iterator iter = m_LegacyReaders.find(factory);
+ if (iter != m_LegacyReaders.end())
+ {
+ for (std::list<mitk::LegacyFileReaderService*>::iterator readerIter = iter->second.begin(),
+ readerIterEnd = iter->second.end(); readerIter != readerIterEnd; ++readerIter)
+ {
+ delete *readerIter;
+ }
+
+ m_LegacyReaders.erase(iter);
}
}
void mitk::CoreObjectFactory::RegisterLegacyWriters(mitk::CoreObjectFactoryBase* factory)
{
// Get all external Writers
mitk::CoreObjectFactory::FileWriterList writers = factory->GetFileWriters();
// We are not really interested in the string, just call the method since
// many writers initialize the map the first time when this method is called
factory->GetSaveFileExtensions();
MultimapType fileExtensionMap = factory->GetSaveFileExtensionsMap();
for(mitk::CoreObjectFactory::FileWriterList::iterator it = writers.begin(); it != writers.end(); it++)
{
std::vector<std::string> extensions = (*it)->GetPossibleFileExtensions();
if (extensions.empty()) continue;
std::string description;
for(std::vector<std::string>::iterator ext = extensions.begin(); ext != extensions.end(); ext++)
{
if (ext->empty()) continue;
std::string extension = *ext;
std::string extensionWithStar = extension;
if (extension.find_first_of('*') == 0)
{
// remove "*."
extension = extension.substr(0, extension.size()-2);
}
else
{
extensionWithStar.insert(extensionWithStar.begin(), '*');
}
for(MultimapType::iterator fileExtensionIter = fileExtensionMap.begin();
fileExtensionIter != fileExtensionMap.end(); fileExtensionIter++)
{
if (fileExtensionIter->first == extensionWithStar)
{
description = fileExtensionIter->second;
break;
}
}
if (!description.empty()) break;
}
if (description.empty())
{
description = std::string("Legacy ") + (*it)->GetNameOfClass() + " Reader";
}
mitk::FileWriter::Pointer fileWriter(it->GetPointer());
mitk::LegacyFileWriterService* lfws = new mitk::LegacyFileWriterService(fileWriter, description);
- m_LegacyWriters.push_back(lfws);
+ m_LegacyWriters[factory].push_back(lfws);
}
}
+
+void mitk::CoreObjectFactory::UnRegisterLegacyWriters(mitk::CoreObjectFactoryBase* factory)
+{
+ std::map<mitk::CoreObjectFactoryBase*, std::list<mitk::LegacyFileWriterService*> >::iterator iter = m_LegacyWriters.find(factory);
+ if (iter != m_LegacyWriters.end())
+ {
+ for (std::list<mitk::LegacyFileWriterService*>::iterator writerIter = iter->second.begin(),
+ writerIterEnd = iter->second.end(); writerIter != writerIterEnd; ++writerIter)
+ {
+ delete *writerIter;
+ }
+
+ m_LegacyWriters.erase(iter);
+ }
+}
+
diff --git a/Core/Code/Common/mitkCoreObjectFactory.h b/Core/Code/Common/mitkCoreObjectFactory.h
index e3a98cf9fd..a2f51f04cc 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.h
+++ b/Core/Code/Common/mitkCoreObjectFactory.h
@@ -1,145 +1,148 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef COREOBJECTFACTORY_H_INCLUDED
#define COREOBJECTFACTORY_H_INCLUDED
#include <set>
#include <MitkCoreExports.h>
#include "mitkCoreObjectFactoryBase.h"
#include "mitkFileWriterWithInformation.h"
namespace mitk {
class Event;
class LegacyFileReaderService;
class LegacyFileWriterService;
class LegacyImageWriterService;
class MITK_CORE_EXPORT CoreObjectFactory : public CoreObjectFactoryBase
{
public:
mitkClassMacro(CoreObjectFactory,CoreObjectFactoryBase)
itkFactorylessNewMacro(CoreObjectFactory)
virtual Mapper::Pointer CreateMapper(mitk::DataNode* node, MapperSlotId slotId);
virtual void SetDefaultProperties(mitk::DataNode* node);
virtual void MapEvent(const mitk::Event* event, const int eventID);
virtual void RegisterExtraFactory(CoreObjectFactoryBase* factory);
virtual void UnRegisterExtraFactory(CoreObjectFactoryBase* factory);
static Pointer GetInstance();
~CoreObjectFactory();
/**
* @brief This method gets the supported (open) file extensions as string.
*
* This string can then used by the Qt QFileDialog widget.
*
* @return The c-string that contains the file extensions
* @deprecatedSince{2014_03} See mitk::FileReaderRegistry and QmitkIOUtil
*/
DEPRECATED(virtual const char* GetFileExtensions());
/**
* @brief get the defined (open) file extension map
*
* @return the defined (open) file extension map
* @deprecatedSince{2014_03} See mitk::FileReaderRegistry and QmitkIOUtil
*/
DEPRECATED(virtual MultimapType GetFileExtensionsMap());
/**
* @brief This method gets the supported (save) file extensions as string.
*
* This string can then used by the Qt QFileDialog widget.
*
* @return The c-string that contains the (save) file extensions
* @deprecatedSince{2014_03} See mitk::FileWriterRegistry and QmitkIOUtil
*/
DEPRECATED(virtual const char* GetSaveFileExtensions());
/**
* @brief get the defined (save) file extension map
*
* @return the defined (save) file extension map
* @deprecatedSince{2014_03} See mitk::FileWriterRegistry and QmitkIOUtil
*/
virtual MultimapType GetSaveFileExtensionsMap();
/**
* @deprecatedSince{2014_03} See mitk::FileWriterRegistry
*/
DEPRECATED(virtual FileWriterList GetFileWriters());
/**
* @deprecatedSince{2014_03} See mitk::FileWriterRegistry and QmitkIOUtil
*/
DEPRECATED(std::string GetDescriptionForExtension(const std::string& extension));
protected:
CoreObjectFactory();
/**
* @brief Merge the input map into the fileExtensionsMap. Duplicate entries are removed
*
* @param fileExtensionsMap the existing map, it contains value pairs like
* ("*.dcm", "DICOM files"),("*.dc3", "DICOM files").
* This map is extented/merged with the values from the input map.
* @param inputMap the input map, it contains value pairs like ("*.dcm",
* "DICOM files"),("*.dc3", "DICOM files") returned by the extra factories.
* @deprecatedSince{2014_03}
*/
void MergeFileExtensions(MultimapType& fileExtensionsMap, MultimapType inputMap);
/**
* @brief initialize the file extension entries for open and save
* @deprecatedSince{2014_03}
*/
void CreateFileExtensionsMap();
/**
* @deprecatedSince{2014_03}
*/
DEPRECATED(void CreateSaveFileExtensions());
typedef std::set<mitk::CoreObjectFactoryBase::Pointer> ExtraFactoriesContainer;
ExtraFactoriesContainer m_ExtraFactories;
FileWriterList m_FileWriters;
std::string m_FileExtensions;
MultimapType m_FileExtensionsMap;
std::string m_SaveFileExtensions;
MultimapType m_SaveFileExtensionsMap;
private:
void RegisterLegacyReaders(mitk::CoreObjectFactoryBase* factory);
void RegisterLegacyWriters(mitk::CoreObjectFactoryBase* factory);
- std::list< mitk::LegacyFileReaderService* > m_LegacyReaders;
- std::list< mitk::LegacyFileWriterService* > m_LegacyWriters;
+ void UnRegisterLegacyReaders(mitk::CoreObjectFactoryBase* factory);
+ void UnRegisterLegacyWriters(mitk::CoreObjectFactoryBase* factory);
+
+ std::map<mitk::CoreObjectFactoryBase*, std::list<mitk::LegacyFileReaderService*> > m_LegacyReaders;
+ std::map<mitk::CoreObjectFactoryBase*, std::list<mitk::LegacyFileWriterService*> > m_LegacyWriters;
};
} // namespace mitk
#endif
diff --git a/Core/Code/Internal/mitkCoreActivator.cpp b/Core/Code/Internal/mitkCoreActivator.cpp
index a030c61ea4..c141081f03 100644
--- a/Core/Code/Internal/mitkCoreActivator.cpp
+++ b/Core/Code/Internal/mitkCoreActivator.cpp
@@ -1,461 +1,461 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCoreActivator.h"
// File IO
#include <mitkIOUtil.h>
#include <mitkIOMimeTypes.h>
#include <Internal/mitkItkImageIO.h>
#include <Internal/mitkMimeTypeProvider.h>
#include <Internal/mitkPointSetReaderService.h>
#include <Internal/mitkPointSetWriterService.h>
#include <Internal/mitkRawImageFileReader.h>
#include <Internal/mitkSurfaceStlIO.h>
#include <Internal/mitkSurfaceVtkLegacyIO.h>
#include <Internal/mitkSurfaceVtkXmlIO.h>
#include <Internal/mitkImageVtkXmlIO.h>
#include <Internal/mitkImageVtkLegacyIO.h>
#include <mitkFileWriter.h>
#include "mitkLegacyFileWriterService.h"
#include "mitkDicomSeriesReaderService.h"
#include <itkNiftiImageIO.h>
#include <itkGDCMImageIO.h>
// Micro Services
#include <usGetModuleContext.h>
#include <usModuleInitialization.h>
#include <usModuleActivator.h>
#include <usModuleContext.h>
#include <usModuleSettings.h>
#include <usModuleEvent.h>
#include <usModule.h>
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
#include <usServiceTracker.h>
void HandleMicroServicesMessages(us::MsgType type, const char* msg)
{
switch (type)
{
case us::DebugMsg:
MITK_DEBUG << msg;
break;
case us::InfoMsg:
MITK_INFO << msg;
break;
case us::WarningMsg:
MITK_WARN << msg;
break;
case us::ErrorMsg:
MITK_ERROR << msg;
break;
}
}
void AddMitkAutoLoadPaths(const std::string& programPath)
{
us::ModuleSettings::AddAutoLoadPath(programPath);
#ifdef __APPLE__
// Walk up three directories since that is where the .dylib files are located
// for build trees.
std::string additionalPath = programPath;
bool addPath = true;
for(int i = 0; i < 3; ++i)
{
std::size_t index = additionalPath.find_last_of('/');
if (index != std::string::npos)
{
additionalPath = additionalPath.substr(0, index);
}
else
{
addPath = false;
break;
}
}
if (addPath)
{
us::ModuleSettings::AddAutoLoadPath(additionalPath);
}
#endif
}
class ShaderRepositoryTracker : public us::ServiceTracker<mitk::IShaderRepository>
{
public:
ShaderRepositoryTracker()
: Superclass(us::GetModuleContext())
{
}
virtual void Close()
{
us::GetModuleContext()->RemoveModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
Superclass::Close();
}
virtual void Open()
{
us::GetModuleContext()->AddModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
Superclass::Open();
}
private:
typedef us::ServiceTracker<mitk::IShaderRepository> Superclass;
TrackedType AddingService(const ServiceReferenceType &reference)
{
mitk::IShaderRepository* shaderRepo = Superclass::AddingService(reference);
if (shaderRepo)
{
// Add all existing shaders from modules to the new shader repository.
// If the shader repository is registered in a modules activator, the
// GetLoadedModules() function call below will also return the module
// which is currently registering the repository. The HandleModuleEvent
// method contains code to avoid double registrations due to a fired
// ModuleEvent::LOADED event after the activators Load() method finished.
std::vector<us::Module*> modules = us::ModuleRegistry::GetLoadedModules();
for (std::vector<us::Module*>::const_iterator iter = modules.begin(),
endIter = modules.end(); iter != endIter; ++iter)
{
this->AddModuleShaderToRepository(*iter, shaderRepo);
}
m_ShaderRepositories.push_back(shaderRepo);
}
return shaderRepo;
}
void RemovedService(const ServiceReferenceType& /*reference*/, TrackedType tracked)
{
m_ShaderRepositories.erase(std::remove(m_ShaderRepositories.begin(), m_ShaderRepositories.end(), tracked),
m_ShaderRepositories.end());
}
void HandleModuleEvent(const us::ModuleEvent moduleEvent)
{
if (moduleEvent.GetType() == us::ModuleEvent::LOADED)
{
std::vector<mitk::IShaderRepository*> shaderRepos;
for (std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > >::const_iterator shaderMapIter = m_ModuleIdToShaderIds.begin(),
shaderMapEndIter = m_ModuleIdToShaderIds.end(); shaderMapIter != shaderMapEndIter; ++shaderMapIter)
{
if (shaderMapIter->second.find(moduleEvent.GetModule()->GetModuleId()) == shaderMapIter->second.end())
{
shaderRepos.push_back(shaderMapIter->first);
}
}
AddModuleShadersToRepositories(moduleEvent.GetModule(), shaderRepos);
}
else if (moduleEvent.GetType() == us::ModuleEvent::UNLOADED)
{
RemoveModuleShadersFromRepositories(moduleEvent.GetModule(), m_ShaderRepositories);
}
}
void AddModuleShadersToRepositories(us::Module* module, const std::vector<mitk::IShaderRepository*>& shaderRepos)
{
// search and load shader files
std::vector<us::ModuleResource> shaderResources = module->FindResources("Shaders", "*.xml", true);
for (std::vector<us::ModuleResource>::iterator i = shaderResources.begin();
i != shaderResources.end(); ++i)
{
if (*i)
{
us::ModuleResourceStream rs(*i);
for (std::vector<mitk::IShaderRepository*>::const_iterator shaderRepoIter = shaderRepos.begin(),
shaderRepoEndIter = shaderRepos.end(); shaderRepoIter != shaderRepoEndIter; ++shaderRepoIter)
{
int id = (*shaderRepoIter)->LoadShader(rs, i->GetBaseName());
if (id >= 0)
{
m_ModuleIdToShaderIds[*shaderRepoIter][module->GetModuleId()].push_back(id);
}
}
rs.seekg(0, std::ios_base::beg);
}
}
}
void AddModuleShaderToRepository(us::Module* module, mitk::IShaderRepository* shaderRepo)
{
std::vector<mitk::IShaderRepository*> shaderRepos;
shaderRepos.push_back(shaderRepo);
this->AddModuleShadersToRepositories(module, shaderRepos);
}
void RemoveModuleShadersFromRepositories(us::Module* module,
const std::vector<mitk::IShaderRepository*>& shaderRepos)
{
for (std::vector<mitk::IShaderRepository*>::const_iterator shaderRepoIter = shaderRepos.begin(),
shaderRepoEndIter = shaderRepos.end(); shaderRepoIter != shaderRepoEndIter; ++shaderRepoIter)
{
std::map<long, std::vector<int> >& moduleIdToShaderIds = m_ModuleIdToShaderIds[*shaderRepoIter];
std::map<long, std::vector<int> >::iterator shaderIdsIter =
moduleIdToShaderIds.find(module->GetModuleId());
if (shaderIdsIter != moduleIdToShaderIds.end())
{
for (std::vector<int>::iterator idIter = shaderIdsIter->second.begin();
idIter != shaderIdsIter->second.end(); ++idIter)
{
(*shaderRepoIter)->UnloadShader(*idIter);
}
moduleIdToShaderIds.erase(shaderIdsIter);
}
}
}
private:
// Maps to each shader repository a map containing module ids and related
// shader registration ids
std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > > m_ModuleIdToShaderIds;
std::vector<mitk::IShaderRepository*> m_ShaderRepositories;
};
class FixedNiftiImageIO : public itk::NiftiImageIO
{
public:
/** Standard class typedefs. */
typedef FixedNiftiImageIO Self;
typedef itk::NiftiImageIO Superclass;
typedef itk::SmartPointer< Self > Pointer;
/** Method for creation through the object factory. */
itkNewMacro(Self)
/** Run-time type information (and related methods). */
itkTypeMacro(FixedNiftiImageIO, Superclass)
virtual bool SupportsDimension(unsigned long dim)
{
return dim > 1 && dim < 5;
}
};
void MitkCoreActivator::Load(us::ModuleContext* context)
{
// Handle messages from CppMicroServices
us::installMsgHandler(HandleMicroServicesMessages);
this->m_Context = context;
// Add the current application directory to the auto-load paths.
// This is useful for third-party executables.
std::string programPath = mitk::IOUtil::GetProgramPath();
if (programPath.empty())
{
MITK_WARN << "Could not get the program path.";
}
else
{
AddMitkAutoLoadPaths(programPath);
}
m_ShaderRepositoryTracker.reset(new ShaderRepositoryTracker);
//m_RenderingManager = mitk::RenderingManager::New();
//context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
m_PropertyAliases.reset(new mitk::PropertyAliases);
context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
m_PropertyExtensions.reset(new mitk::PropertyExtensions);
context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
m_PropertyFilters.reset(new mitk::PropertyFilters);
context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
m_MimeTypeProvider->Start();
m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
this->RegisterDefaultMimeTypes();
this->RegisterItkReaderWriter();
this->RegisterVtkReaderWriter();
// Add custom Reader / Writer Services
m_FileReaders.push_back(new mitk::PointSetReaderService());
m_FileWriters.push_back(new mitk::PointSetWriterService());
m_FileReaders.push_back(new mitk::DicomSeriesReaderService());
m_FileReaders.push_back(new mitk::RawImageFileReaderService());
m_ShaderRepositoryTracker->Open();
/*
There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
This code is left here as a reminder, just in case we might need to do that some time.
vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
vtkObjectFactory::RegisterFactory( textureFactory );
textureFactory->Delete();
*/
this->RegisterLegacyWriter();
}
void MitkCoreActivator::Unload(us::ModuleContext* )
{
for(std::vector<mitk::IFileReader*>::iterator iter = m_FileReaders.begin(),
endIter = m_FileReaders.end(); iter != endIter; ++iter)
{
delete *iter;
}
for(std::vector<mitk::IFileWriter*>::iterator iter = m_FileWriters.begin(),
endIter = m_FileWriters.end(); iter != endIter; ++iter)
{
delete *iter;
}
for(std::vector<mitk::AbstractFileIO*>::iterator iter = m_FileIOs.begin(),
endIter = m_FileIOs.end(); iter != endIter; ++iter)
{
delete *iter;
}
for(std::vector<mitk::IFileWriter*>::iterator iter = m_LegacyWriters.begin(),
endIter = m_LegacyWriters.end(); iter != endIter; ++iter)
{
delete *iter;
}
// The mitk::ModuleContext* argument of the Unload() method
// will always be 0 for the Mitk library. It makes no sense
// to use it at this stage anyway, since all libraries which
// know about the module system have already been unloaded.
// we need to close the internal service tracker of the
// MimeTypeProvider class here. Otherwise it
// would hold on to the ModuleContext longer than it is
// actually valid.
m_MimeTypeProviderReg.Unregister();
m_MimeTypeProvider->Stop();
for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = m_DefaultMimeTypes.begin(),
iterEnd = m_DefaultMimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
{
delete *mimeTypeIter;
}
m_ShaderRepositoryTracker->Close();
}
void MitkCoreActivator::RegisterDefaultMimeTypes()
{
// Register some default mime-types
std::vector<mitk::CustomMimeType*> mimeTypes = mitk::IOMimeTypes::Get();
for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = mimeTypes.begin(),
iterEnd = mimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
{
m_DefaultMimeTypes.push_back(*mimeTypeIter);
m_Context->RegisterService(m_DefaultMimeTypes.back());
}
}
void MitkCoreActivator::RegisterItkReaderWriter()
{
std::list<itk::LightObject::Pointer> allobjects =
itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
for (std::list<itk::LightObject::Pointer >::iterator i = allobjects.begin(),
endIter = allobjects.end(); i != endIter; ++i)
{
itk::ImageIOBase* io = dynamic_cast<itk::ImageIOBase*>(i->GetPointer());
// NiftiImageIO does not provide a correct "SupportsDimension()" methods
// and the supported read/write extensions are not ordered correctly
if (dynamic_cast<itk::NiftiImageIO*>(io)) continue;
// Use a custom mime-type for GDCMImageIO below
if (dynamic_cast<itk::GDCMImageIO*>(i->GetPointer()))
{
// MITK provides its own DICOM reader (which internally uses GDCMImageIO).
continue;
}
if (io)
{
m_FileIOs.push_back(new mitk::ItkImageIO(io));
}
else
{
MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: "
<< ( *i )->GetNameOfClass();
}
}
FixedNiftiImageIO::Pointer itkNiftiIO = FixedNiftiImageIO::New();
mitk::ItkImageIO* niftiIO = new mitk::ItkImageIO(mitk::CustomMimeType(mitk::IOMimeTypes::NIFTI_MIMETYPE_NAME()),
itkNiftiIO.GetPointer(), 0);
m_FileIOs.push_back(niftiIO);
}
void MitkCoreActivator::RegisterVtkReaderWriter()
{
m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
m_FileIOs.push_back(new mitk::SurfaceStlIO());
m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
}
void MitkCoreActivator::RegisterLegacyWriter()
{
std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
for( std::list<itk::LightObject::Pointer>::iterator i = allobjects.begin();
i != allobjects.end(); ++i)
{
mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter*>(i->GetPointer());
if(io)
{
- std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Reader";
+ std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Writer";
mitk::IFileWriter* writer = new mitk::LegacyFileWriterService(io, description);
m_LegacyWriters.push_back(writer);
}
else
{
MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: "
<< (*i)->GetNameOfClass()
<< std::endl;
}
}
}
US_EXPORT_MODULE_ACTIVATOR(MitkCoreActivator)
// Call CppMicroservices initialization code at the end of the file.
// This especially ensures that VTK object factories have already
// been registered (VTK initialization code is injected by implicitly
// include VTK header files at the top of this file).
US_INITIALIZE_MODULE