analyze_data_io.cpp

Go to the documentation of this file.

//--------------------------------------------------
//---------------------------------------------------


#include "analyze_data_io.h"
#include "../global/global_definitions.h"

#include "one_byte_image_pixel_dataset.h"
#include "two_byte_image_pixel_dataset.h"
#include "four_byte_image_pixel_dataset.h"
#include "one_byte_volume_pixel_dataset.h"
#include "two_byte_volume_pixel_dataset.h"
#include "four_byte_volume_pixel_dataset.h"

#include <typeinfo>
#include <itkAnalyzeImageIO.h>

namespace imedgine 
{
  AnalyzeDataIO::AnalyzeDataIO()
  {
  }
  
  //---------------------------------------------------
  
  AnalyzeDataIO::~AnalyzeDataIO()
  {
  }
  
  //---------------------------------------------------
  
  std::pair<dataset_pointer_type, dataset_type> 
      AnalyzeDataIO::loadDataset(std::string filename, dataset_key_type dataset_key)  
  {
    itk::AnalyzeImageIO::Pointer dataset_info = itk::AnalyzeImageIO::New();
    dataset_info->SetFileName(filename.c_str());
    dataset_info->ReadImageInformation();
    
#ifdef DEBUG
      std::cout << "Num bytes per pixel: " << dataset_info->GetPixelStride() << std::endl
                << "Num dimensions: " << dataset_info->GetNumberOfDimensions() << std::endl;
#endif 
    
    // TODO: check if file is readable and throw exception if not
    
    pixel_dataset_pointer_type pixel_dataset;
    dataset_type type = UNDEF_DATASET;
 
     
    switch (dataset_info->GetPixelStride())
    {
      case 1 :
      {
        switch (dataset_info->GetNumberOfDimensions())
        {
          case 2 :
          {  
            pixel_dataset = 
                this->read<OneByteImagePixelDataset>(filename, dataset_key);
            type = ONE_BYTE_IMAGE_PIXEL_DATASET;
            break;
          }
          case 3 :
          { 
            pixel_dataset = 
                this->read<OneByteVolumePixelDataset>(filename, dataset_key);
            type = ONE_BYTE_VOLUME_PIXEL_DATASET;
            break;
          }
        }
        break;
      }
      case 2 :
      {
        switch (dataset_info->GetNumberOfDimensions())
        {
          case 2 :
          {
            pixel_dataset = 
                this->read<TwoByteImagePixelDataset>(filename, dataset_key);
            break;
            type = TWO_BYTE_IMAGE_PIXEL_DATASET;
          }
          case 3 :
          { 
            pixel_dataset = 
                this->read<TwoByteVolumePixelDataset>(filename, dataset_key);
            type = TWO_BYTE_VOLUME_PIXEL_DATASET;
            break;
          }
        }
        break;
      }
      case 4 :
      {
        switch (dataset_info->GetNumberOfDimensions())
        {
          case 2 :
          {
            pixel_dataset = 
                this->read<FourByteImagePixelDataset>(filename, dataset_key);
            type = FOUR_BYTE_IMAGE_PIXEL_DATASET;
            break;
          }
          case 3 :
          { 
            pixel_dataset = 
                this->read<FourByteVolumePixelDataset>(filename, dataset_key);
            type = FOUR_BYTE_VOLUME_PIXEL_DATASET;
            break;
          }
        }
        break;
      }
    }
    
    for (unsigned char dim_index = 0; 
         dim_index < dataset_info->GetNumberOfDimensions(); ++dim_index)
    {
      // set initial focus point positionController    
      pixel_dataset->setFocusPointAt(
          dim_index, static_cast<index_type>(
          static_cast<double>(pixel_dataset->getSize()[dim_index]) / 2.0)); 
    
#ifdef DEBUG
      std::cout << "Dataset size dimension " << dim_index << " : " << 
          static_cast<index_type>(
            static_cast<double>(pixel_dataset->getSize()[X_DIMENSION]) / 2.0) << std::endl;
#endif
    }

    return(std::make_pair(
        dataset_pointer_type(pixel_dataset), type));
  }
  
  //---------------------------------------------------
  
  void AnalyzeDataIO::writeDataset(dataset_pointer_type dataset, std::string filename)
      throw(InvalidCastException)
  {
    pixel_dataset_pointer_type pixel_dataset(
        dataset, boost::detail::dynamic_cast_tag());
    
    if (pixel_dataset.get() == 0)
    {
      throw(InvalidCastException("AnalyzeDataIO::writeDataset", "dataset_pointer_type", 
            "pixel_dataset_pointer_type"));
    }
    
    switch (pixel_dataset->getNumBytesPerPixel())
    {
      case 1 :
      {
        switch (pixel_dataset->getNumDimensions())
        {
          case 2 :
          {
            one_byte_image_pixel_dataset_pointer_type one_byte_image(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (one_byte_image.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "one_byte_image_pixel_dataset_pointer_type"));
            }
            this->write(one_byte_image, filename);
            break;
          }
          case 3 :
          {
            one_byte_volume_pixel_dataset_pointer_type one_byte_volume(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (one_byte_volume.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "one_byte_volume_pixel_dataset_pointer_type"));
            }
            this->write(one_byte_volume, filename);
            break;
          }
        }
        break;
      }
      case 2 :
      {
        switch (pixel_dataset->getNumDimensions())
        {
          case 2 :
          {
            two_byte_image_pixel_dataset_pointer_type two_byte_image(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (two_byte_image.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "two_byte_image_pixel_dataset_pointer_type"));
            }
            this->write(two_byte_image, filename);
            break;
          }
          case 3 :
          {
            two_byte_volume_pixel_dataset_pointer_type two_byte_volume(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (two_byte_volume.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "two_byte_volume_pixel_dataset_pointer_type"));
            }
            this->write(two_byte_volume, filename);
            break;
          }
        }
        break;
      }
      case 4 :
      {
        switch (pixel_dataset->getNumDimensions())
        {
          case 2 :
          {
            four_byte_image_pixel_dataset_pointer_type four_byte_image(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (four_byte_image.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "four_byte_image_pixel_dataset_pointer_type"));
            }
            this->write(four_byte_image, filename);
            break;
          }
          case 3 :
          {
            four_byte_volume_pixel_dataset_pointer_type four_byte_volume(
                pixel_dataset, boost::detail::dynamic_cast_tag());
            if (four_byte_volume.get() == 0)
            {
              throw(InvalidCastException("AnalyzeDataIO::writeDataset", "pixel_dataset_pointer_type", 
                    "four_byte_volume_pixel_dataset_pointer_type"));
            }
            this->write(four_byte_volume, filename);
            break;
          }
        }
        break;
      }
    }
    

  }
}

---