mitk: mitkImageWriter.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkImageWriter.h"
00019 
00020 #include "mitkItkPictureWrite.h"
00021 #include "mitkImage.h"
00022 #include "mitkImageTimeSelector.h"
00023 #include "mitkPicFileWriter.h"
00024 #include "mitkImageAccessByItk.h"
00025 
00026 #include <itkImageIOBase.h>
00027 #include <itkImageIOFactory.h>
00028 
00029 
00030 mitk::ImageWriter::ImageWriter()
00031 {
00032   this->SetNumberOfRequiredInputs( 1 );
00033   m_MimeType = "";
00034   SetDefaultExtension();
00035 }
00036 
00037 mitk::ImageWriter::~ImageWriter()
00038 {
00039 }
00040 
00041 void mitk::ImageWriter::SetDefaultExtension()
00042 {
00043   m_Extension = ".mhd";
00044 }
00045 
00046 #include <vtkConfigure.h>
00047 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION==4) && (VTK_MINOR_VERSION>=4) ))
00048 #include <vtkImageData.h>
00049 #include <vtkXMLImageDataWriter.h>
00050 static void writeVti(const char * filename, mitk::Image* image, int t=0)
00051 {
00052   vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
00053   vtkwriter->SetFileName( filename );
00054   vtkwriter->SetInput(image->GetVtkImageData(t));
00055   vtkwriter->Write();
00056   vtkwriter->Delete();
00057 }
00058 #endif
00059 
00060 void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
00061 {
00062   // Pictures and picture series like .png are written via a different mechanism then volume images.
00063   // So, they are still multiplexed and thus not support vector images.
00064   if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos)
00065   {
00066     AccessByItk_1( image, _mitkItkPictureWrite, fileName );
00067     return;
00068   }
00069 
00070   // Implementation of writer using itkImageIO directly. This skips the use
00071   // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
00072 
00073   unsigned int dimension = image->GetDimension();
00074   unsigned int* dimensions = image->GetDimensions();
00075   mitk::PixelType pixelType = image->GetPixelType();
00076   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
00077   mitk::Point3D origin = image->GetGeometry()->GetOrigin();
00078 
00079   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( fileName.c_str(), 
00080     itk::ImageIOFactory::WriteMode );
00081 
00082   if(imageIO.IsNull())
00083   {
00084     itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
00085   }
00086 
00087   // Set the necessary information for imageIO
00088   imageIO->SetNumberOfDimensions(dimension);
00089   imageIO->SetPixelTypeInfo( *(pixelType.GetItkTypeId()) );
00090 
00091   if(pixelType.GetNumberOfComponents() > 1)
00092     imageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
00093 
00094   itk::ImageIORegion ioRegion( dimension );
00095 
00096   for(unsigned int i=0; i<dimension; i++)
00097   {
00098     imageIO->SetDimensions(i,dimensions[i]);
00099     imageIO->SetSpacing(i,spacing[i]);
00100     imageIO->SetOrigin(i,origin[i]);
00101 
00102     mitk::Vector3D direction = image->GetGeometry()->GetAxisVector(i);
00103     vnl_vector< double > axisDirection(dimension);
00104     for(unsigned int j=0; j<dimension; j++)
00105     {
00106       axisDirection[j] = direction[j];
00107     }
00108     imageIO->SetDirection( i, axisDirection );
00109 
00110     ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i) );
00111     ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i) );
00112   }
00113 
00114   imageIO->SetIORegion(ioRegion);
00115   imageIO->SetFileName(fileName);
00116 
00117   const void * data = image->GetData();
00118   imageIO->Write(data);
00119 }
00120 
00121 void mitk::ImageWriter::GenerateData()
00122 {
00123   if ( m_FileName == "" )
00124   {
00125     itkWarningMacro( << "Sorry, filename has not been set!" );
00126     return ;
00127   }
00128 
00129   FILE* tempFile = fopen(m_FileName.c_str(),"w");
00130   if (tempFile==NULL)
00131   {
00132     itkExceptionMacro(<<"File location not writeable");
00133     return;
00134   }
00135   fclose(tempFile);
00136   remove(m_FileName.c_str());
00137 
00138   mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput());
00139 
00140 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION==4) && (VTK_MINOR_VERSION>=4) ))
00141   bool vti = (m_Extension.find(".vti") != std::string::npos);
00142 #endif
00143 
00144   if ( m_Extension.find(".pic") == std::string::npos )
00145   {
00146     if(input->GetDimension() > 3)
00147     {
00148       int t, timesteps;
00149 
00150       timesteps = input->GetDimension(3);
00151       ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
00152       timeSelector->SetInput(input);
00153       mitk::Image::Pointer image = timeSelector->GetOutput();
00154       for(t = 0; t < timesteps; ++t)
00155       {
00156         ::itk::OStringStream filename;
00157         timeSelector->SetTimeNr(t);
00158         timeSelector->Update();
00159         if(input->GetTimeSlicedGeometry()->IsValidTime(t))
00160         {
00161           const mitk::TimeBounds& timebounds = input->GetTimeSlicedGeometry()->GetGeometry3D(t)->GetTimeBounds();
00162           filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
00163         }
00164         else
00165         {
00166           itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of image " << filename << ".");
00167           filename <<  m_FileName.c_str() << "_T" << t << m_Extension;
00168         }
00169 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION==4) && (VTK_MINOR_VERSION>=4) ))
00170         if ( vti )
00171         {
00172           writeVti(filename.str().c_str(), input, t);
00173         }
00174         else
00175 #endif
00176         {        
00177           WriteByITK(input, filename.str());
00178         }
00179       }
00180     }
00181 #if ((VTK_MAJOR_VERSION > 4) || ((VTK_MAJOR_VERSION==4) && (VTK_MINOR_VERSION>=4) ))
00182     else if ( vti )
00183     {
00184       ::itk::OStringStream filename;
00185       filename <<  m_FileName.c_str() << m_Extension;
00186       writeVti(filename.str().c_str(), input);
00187     }
00188 #endif
00189     else
00190     {
00191       ::itk::OStringStream filename;
00192       filename <<  m_FileName.c_str() << m_Extension;
00193       WriteByITK(input, filename.str());
00194     }
00195   }
00196   else
00197   {
00198     PicFileWriter::Pointer picWriter = PicFileWriter::New();
00199     size_t found;
00200     found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
00201     if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
00202     {
00203       //if Extension not in Filename
00204       ::itk::OStringStream filename;
00205       filename <<  m_FileName.c_str() << m_Extension;
00206       m_FileName = filename.str().c_str();
00207     }
00208     picWriter->SetFileName( m_FileName.c_str() );
00209     picWriter->SetInput( input );
00210     picWriter->Write();
00211   }
00212   m_MimeType = "application/MITK.Pic";
00213 }
00214 
00215 bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
00216 {
00217   if ( input )
00218   {
00219     mitk::BaseData* data = input->GetData();
00220     if ( data )
00221     {
00222        mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( data );
00223        if( image.IsNotNull() )
00224        {
00225          //"SetDefaultExtension()" set m_Extension to ".mhd" ?????
00226          m_Extension = ".pic";
00227          return true;
00228        }
00229     }
00230   }
00231   return false;
00232 }
00233 
00234 void mitk::ImageWriter::SetInput( DataNode* input )
00235 {
00236   if( input && CanWriteDataType( input ) )
00237     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
00238 }
00239 
00240 std::string mitk::ImageWriter::GetWritenMIMEType()
00241 {
00242   return m_MimeType;
00243 }
00244 
00245 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
00246 {
00247   std::vector<std::string> possibleFileExtensions;
00248   possibleFileExtensions.push_back(".pic");
00249   possibleFileExtensions.push_back(".bmp");
00250   possibleFileExtensions.push_back(".dcm");
00251   possibleFileExtensions.push_back(".DCM");
00252   possibleFileExtensions.push_back(".dicom");
00253   possibleFileExtensions.push_back(".DICOM");
00254   possibleFileExtensions.push_back(".gipl");
00255   possibleFileExtensions.push_back(".gipl.gz");
00256   possibleFileExtensions.push_back(".mha");
00257   possibleFileExtensions.push_back(".nii");
00258   possibleFileExtensions.push_back(".nrrd");
00259   possibleFileExtensions.push_back(".nhdr");
00260   possibleFileExtensions.push_back(".png");
00261   possibleFileExtensions.push_back(".PNG");
00262   possibleFileExtensions.push_back(".spr");
00263   possibleFileExtensions.push_back(".mhd");
00264   possibleFileExtensions.push_back(".vtk");
00265   possibleFileExtensions.push_back(".vti");
00266   possibleFileExtensions.push_back(".hdr");
00267   possibleFileExtensions.push_back(".png");
00268   possibleFileExtensions.push_back(".tif");
00269   possibleFileExtensions.push_back(".jpg");
00270   return possibleFileExtensions;
00271 }
00272 
00273 std::string mitk::ImageWriter::GetFileExtension()
00274 {
00275   return m_Extension;
00276 }
00277 
00278 void mitk::ImageWriter::SetInput( mitk::Image* image )
00279 {
00280   this->ProcessObject::SetNthInput( 0, image );
00281 }
00282 
00283 const mitk::Image* mitk::ImageWriter::GetInput()
00284 {
00285   if ( this->GetNumberOfInputs() < 1 )
00286   {
00287     return NULL;
00288   }
00289   else
00290   {
00291     return static_cast< const mitk::Image * >( this->ProcessObject::GetInput( 0 ) );
00292   }
00293 }