itkSCIFIOImageIO.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkSCIFIOImageIO_h
#define itkSCIFIOImageIO_h

#include "SCIFIOExport.h"
#include "itkStreamingImageIOBase.h"

#include "itksys/Process.h"
#include "itksys/SystemTools.hxx"

#include <sstream>

namespace itk
{
class SCIFIO_EXPORT SCIFIOImageIO : public StreamingImageIOBase
{
public:
  typedef SCIFIOImageIO               Self;
  typedef ImageIOBase                 Superclass;
  typedef SmartPointer<Self>          Pointer;
  typedef SmartPointer<const Self>    ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(SCIFIOImageIO, Superclass);

  virtual bool SupportsDimension( unsigned long dim ) ITK_OVERRIDE;

  virtual bool CanReadFile(const char* FileNameToRead) ITK_OVERRIDE;

  /* Sets the series to read in a multi-series dataset */
  virtual bool SetSeries(int series);

  /* Sets the series to read in a multi-series dataset */
  virtual int GetSeriesCount();

  /* Set the spacing and dimension information for the set file name */
  virtual void ReadImageInformation() ITK_OVERRIDE;

  /* Read the data from the disk into provided memory buffer */
  virtual void Read(void* buffer) ITK_OVERRIDE;

  virtual bool CanWriteFile(const char* FileNameToWrite) ITK_OVERRIDE;

  /* Set the spacing and dimension information for the set file name */
  virtual void WriteImageInformation() ITK_OVERRIDE;

  /* Write the data to the disk from the provided memory buffer */
  virtual void Write(const void* buffer) ITK_OVERRIDE;

protected:
  SCIFIOImageIO();
  ~SCIFIOImageIO();

  virtual SizeType GetHeaderSize() const ITK_OVERRIDE { return 0; }

private:
  void CreateJavaProcess();
  void DestroyJavaProcess();
  std::string FindDimensionOrder(const ImageIORegion & region );
  std::string WaitForNewLines(int pipedatalength);
  void CheckError(std::string message);
  bool CheckJavaPath(std::string javaHome, std::string &javaCmd);
  std::string RemoveFinalSlash(std::string path) const;

  char ** toCArray( std::vector< std::string > & args )
    {
    char **argv = new char *[args.size() + 1];
    for( int i = 0; i < static_cast< int >( args.size() ); i++ )
      {
      itkDebugMacro( "SCIFIOImageIO::toCArray::args["<<i<<"] = " << args[i]);
      argv[i] = (char*)args[i].c_str();
      }
    argv[args.size()] = NULL;
    return argv;
    }

  ImageIOBase::IOComponentType scifioToITKComponentType( int pixelType )
    {
    switch ( pixelType )
      {
      case 0:
        return CHAR;
      case 1:
        return UCHAR;
      case 2:
        return SHORT;
      case 3:
        return USHORT;
      case 4:
        return INT;
      case 5:
         return UINT;
      case 6:
        return FLOAT;
      default:
        return DOUBLE;
      }
    }

  int itkToSCIFIOPixelType( ImageIOBase::IOComponentType cmp )
  {
    switch ( cmp )
    {
    case CHAR:
      return 0;
    case UCHAR:
      return 1;
    case SHORT:
      return 2;
    case USHORT:
      return 3;
    case INT:
      return 4;
    case UINT:
      return 5;
    case FLOAT:
      return 6;
    case LONG:
    case ULONG:
    case DOUBLE:
    default:
      return 7;
    }
  }

  MetaDataDictionary           m_MetaDataDictionary;
  std::vector< std::string >   m_Args;
  char **                      m_Argv;
  itksysProcess_Pipe_Handle    m_Pipe[2];
  itksysProcess *              m_Process;
};
} // end namespace itk

#endif // itkSCIFIOImageIO_h