two_byte_volume_pixel_dataset.cpp

Go to the documentation of this file.

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

#include "two_byte_volume_pixel_dataset.h"
#include "two_byte_image_pixel_dataset.h"

#include <limits>

namespace imedgine 
{
  //---------------------------------------------------
  
  TwoByteVolumePixelDataset::TwoByteVolumePixelDataset(dataset_key_type dataset_key,
      volume_pointer_type volume)
  : VolumePixelDataset(TWO_BYTE_VOLUME_PIXEL_DATASET, dataset_key, 2),
    resampling_filter_(resampling_filter_type::New()),
    slice_extractor_(slice_extractor_type::New()),
    image_extractor_(image_extractor_type::New()),
    volume_intensity_filter_(volume_intensity_filter_type::New()),
    image_intensity_filter_(image_intensity_filter_type::New())
  {
    resampling_filter_->SetTransform(transform_);
    resampling_filter_->SetDefaultPixelValue(std::numeric_limits<pixel_type>::min());
    
    if (volume.IsNull() == false)
    {
      this->setDatasetInternal(volume);
    } 
  }
  
  //---------------------------------------------------
  
  TwoByteVolumePixelDataset::TwoByteVolumePixelDataset(TwoByteVolumePixelDataset const& src) 
  : VolumePixelDataset(src),
    resampling_filter_(resampling_filter_type::New()),
    slice_extractor_(slice_extractor_type::New()),
    image_extractor_(image_extractor_type::New()),
    volume_intensity_filter_(volume_intensity_filter_type::New()),
    image_intensity_filter_(image_intensity_filter_type::New())
  {
    resampling_filter_->SetTransform(transform_);
    resampling_filter_->SetDefaultPixelValue(std::numeric_limits<pixel_type>::min());
  }
  
  //---------------------------------------------------
  
  TwoByteVolumePixelDataset::~TwoByteVolumePixelDataset()
  {
  }
  
  //---------------------------------------------------
  
  external_data_pointer_type TwoByteVolumePixelDataset::getData() const
      throw(NullPointerException)
  {
    if (dataset_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getData()"));
    }
    
    volume_intensity_filter_->UpdateLargestPossibleRegion();
    
    external_volume_pointer_type volume = volume_intensity_filter_->GetOutput();
    volume->DisconnectPipeline();
    volume->GetPixelContainer()->ContainerManageMemoryOff();
    
    return(volume->GetBufferPointer());
  }
  
  //--------------------------------------------------
  
  void TwoByteVolumePixelDataset::setDataset(volume_pointer_type dataset)
  {
    setDatasetInternal(dataset);
    is_dirty_ = true;
  }
  
  //--------------------------------------------------
  
  void TwoByteVolumePixelDataset::setDatasetInternal(volume_pointer_type dataset)
  {  
    dataset_ = dataset;
    is_data_set_ = true;

    min_pixel_value_ = std::numeric_limits<pixel_type>::max();
    max_pixel_value_ = 0;
    
    const_volume_iterator_type vol_iter(
        dataset_, dataset_->GetLargestPossibleRegion());
    for (vol_iter.GoToBegin(); !vol_iter.IsAtEnd(); ++vol_iter)
    {
      if (vol_iter.Value() > max_pixel_value_)
      {
        max_pixel_value_ = vol_iter.Value();
      }  
      if (vol_iter.Value() < min_pixel_value_)
      {
        min_pixel_value_ = vol_iter.Value();
      }
    }
    
    region_type volume_region = dataset_->GetLargestPossibleRegion();
    region_size_type volume_size = volume_region.GetSize();
    dataset_size_[X_DIMENSION] = volume_size[X_DIMENSION];
    dataset_size_[Y_DIMENSION] = volume_size[Y_DIMENSION];
    dataset_size_[Z_DIMENSION] = volume_size[Z_DIMENSION];

    region_size_type region_size = volume_size;
    region_size[Z_DIMENSION] = 0;
    xy_region_to_extract_.SetSize(region_size);
    
    region_size = volume_size;
    region_size[Y_DIMENSION] = 0;
    xz_region_to_extract_.SetSize(region_size);
    
    region_size = volume_size;
    region_size[X_DIMENSION] = 0;
    yz_region_to_extract_.SetSize(region_size);
    
    xy_region_to_extract_.SetIndex(volume_region.GetIndex());
    xz_region_to_extract_.SetIndex(volume_region.GetIndex());
    yz_region_to_extract_.SetIndex(volume_region.GetIndex()); 
     
    transform_->SetIdentity(); 
    resampling_filter_->SetOutputSpacing(dataset_->GetSpacing());
    resampling_filter_->SetOutputOrigin(dataset_->GetOrigin());
    resampling_filter_->SetSize(dataset_->GetLargestPossibleRegion().GetSize());

    
    image_extractor_->SetInput(dataset_);
    
    resampling_filter_->SetInput(dataset_);    
    slice_extractor_->SetInput(resampling_filter_->GetOutput());
    image_intensity_filter_->SetInput(slice_extractor_->GetOutput());
    
    image_intensity_filter_->SetWindowMinimum(static_cast<pixel_type>(min_pixel_value_));
    image_intensity_filter_->SetWindowMaximum(static_cast<pixel_type>(max_pixel_value_));
    image_intensity_filter_->SetOutputMinimum(0);
    image_intensity_filter_->SetOutputMaximum(
        std::numeric_limits<external_pixel_type>::max());
    
    volume_intensity_filter_->SetInput(dataset_);
    volume_intensity_filter_->SetWindowMinimum(static_cast<pixel_type>(min_pixel_value_));
    volume_intensity_filter_->SetWindowMaximum(static_cast<pixel_type>(max_pixel_value_));
    volume_intensity_filter_->SetOutputMinimum(0);
    volume_intensity_filter_->SetOutputMaximum(
        std::numeric_limits<external_pixel_type>::max());
        
    xy_slice_rois_.resize(dataset_size_[Z_DIMENSION]);
    xz_slice_rois_.resize(dataset_size_[Y_DIMENSION]);
    yz_slice_rois_.resize(dataset_size_[X_DIMENSION]);
  }
  
  //--------------------------------------------------
  
  TwoByteVolumePixelDataset::const_volume_pointer_type 
      TwoByteVolumePixelDataset::getDataset() const
  {
    return(dataset_);
  }
  
  //--------------------------------------------------
 
  TwoByteVolumePixelDataset::volume_pointer_type
      TwoByteVolumePixelDataset::getDataset()
  {
    return(dataset_);
  }
  
  
  //--------------------------------------------------
 
  void TwoByteVolumePixelDataset::setIntensity(double window, double level)
  {
    if (level > max_pixel_value_)
    {
      level = max_pixel_value_;
    }
    else if (level < min_pixel_value_)
    {
      level = min_pixel_value_;
    }
    
    double new_window_min = level - static_cast<int>(window / 2.0);
    double new_window_max = level + static_cast<int>(window / 2.0);
    

    if (new_window_min < std::numeric_limits<pixel_type>::min())
    {
      new_window_min = std::numeric_limits<pixel_type>::min();
    }
    else if (new_window_max > std::numeric_limits<pixel_type>::max())
    {
      new_window_max = std::numeric_limits<pixel_type>::max();
    }
    
    image_intensity_filter_->SetWindowMinimum(
        static_cast<pixel_type>(new_window_min));
    
    image_intensity_filter_->SetWindowMaximum(
        static_cast<pixel_type>(new_window_max));
    
    volume_intensity_filter_->SetWindowMinimum(
        static_cast<pixel_type>(new_window_min));
    
    volume_intensity_filter_->SetWindowMaximum(
        static_cast<pixel_type>(new_window_max));
  }
  
  //--------------------------------------------------
  
  double TwoByteVolumePixelDataset::getIntensityWindow() const
  throw(NullPointerException)
  {
    if (image_intensity_filter_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getIntensityWindow()"));
    }
    return(static_cast<double>(image_intensity_filter_->GetWindow()));
  }

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

  double TwoByteVolumePixelDataset::getIntensityLevel() const
  throw(NullPointerException)
  {
    if (image_intensity_filter_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getIntensityLevel()"));
    }
    return(static_cast<double>(image_intensity_filter_->GetLevel()));
  }
  
  //--------------------------------------------------
    
  external_data_pointer_type TwoByteVolumePixelDataset::getSliceXY(
    index_type z_index)
      throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || slice_extractor_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getSliceXY"));
    }
    if (z_index >= dataset_size_[Z_DIMENSION])
    {
      throw(IndexOutOfBoundsException("TwoByteVolumePixelDataset::getSliceXY"));
    }
    
    xy_region_to_extract_.SetIndex(Z_DIMENSION, z_index);
    slice_extractor_->SetExtractionRegion(xy_region_to_extract_);
    
    image_intensity_filter_->UpdateLargestPossibleRegion();
    
    external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
    slice->DisconnectPipeline();
    slice->GetPixelContainer()->ContainerManageMemoryOff();
    
    return(slice->GetBufferPointer());
  }
  
  //--------------------------------------------------
    
  external_data_pointer_type TwoByteVolumePixelDataset::getSliceXZ(
    index_type y_index)
      throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || slice_extractor_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getSliceXZ"));
    }
    if (y_index >= dataset_size_[Y_DIMENSION])
    {
      throw(IndexOutOfBoundsException("TwoByteVolumePixelDataset::getSliceXZ"));
    }
   
    xz_region_to_extract_.SetIndex(Y_DIMENSION, y_index);
    slice_extractor_->SetExtractionRegion(xz_region_to_extract_);
    image_intensity_filter_->UpdateLargestPossibleRegion();
    
    external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
    slice->DisconnectPipeline();
    slice->GetPixelContainer()->ContainerManageMemoryOff();
    
    return(slice->GetBufferPointer());
  }
  
  //--------------------------------------------------
    
  external_data_pointer_type TwoByteVolumePixelDataset::getSliceYZ(
    index_type x_index)
      throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || slice_extractor_.IsNull())
    {
      throw(NullPointerException("TwoByteVolumePixelDataset::getSliceYZ"));
    }
    if (x_index >= dataset_size_[X_DIMENSION])
    {
      throw(IndexOutOfBoundsException("TwoByteVolumePixelDataset::getSliceYZ"));
    }
    
    yz_region_to_extract_.SetIndex(X_DIMENSION, x_index); 
    slice_extractor_->SetExtractionRegion(yz_region_to_extract_);
    image_intensity_filter_->UpdateLargestPossibleRegion();
    
    external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
    slice->DisconnectPipeline();
    slice->GetPixelContainer()->ContainerManageMemoryOff();

    return(slice->GetBufferPointer());
  }
  
    //--------------------------------------------------
    
  dataset_pointer_type TwoByteVolumePixelDataset::getImageXY(
    index_type z_index, dataset_key_type image_key)
      throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || image_extractor_.IsNull())
    {
      throw(NullPointerException("OneByteVolumePixelDataset::getSliceXY"));
    }
    if (z_index >= dataset_size_[Z_DIMENSION])
    {
      throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceXY"));
    }

    xy_region_to_extract_.SetIndex(Z_DIMENSION, z_index);
    image_extractor_->SetExtractionRegion(xy_region_to_extract_);
    
    image_extractor_->UpdateLargestPossibleRegion();
    
    image_type::Pointer image = image_extractor_->GetOutput();
    image->DisconnectPipeline();
    image->GetPixelContainer()->ContainerManageMemoryOff();

    TwoByteImagePixelDataset* image_dataset(new TwoByteImagePixelDataset(image_key, image));

    image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceXY(z_index));
    image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());

    return(dataset_pointer_type(image_dataset));
  }
    
 //--------------------------------------------------
      
  dataset_pointer_type TwoByteVolumePixelDataset::getImageXZ(
    index_type y_index, dataset_key_type image_key)
    throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || image_extractor_.IsNull())
    {
      throw(NullPointerException("OneByteVolumePixelDataset::getSliceXZ"));
    }
    if (y_index >= dataset_size_[Y_DIMENSION])
    {
      throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceXZ"));
    }

    xz_region_to_extract_.SetIndex(Y_DIMENSION, y_index);
    image_extractor_->SetExtractionRegion(xz_region_to_extract_);
    
    image_extractor_->UpdateLargestPossibleRegion();
    
    image_type::Pointer image = image_extractor_->GetOutput();
    image->DisconnectPipeline();
    image->GetPixelContainer()->ContainerManageMemoryOff();

    TwoByteImagePixelDataset* image_dataset(new TwoByteImagePixelDataset(image_key, image));

    image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceXZ(y_index));
    image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());

    return(dataset_pointer_type(image_dataset));
  }
    
  //-------------------------------------------------
      
  dataset_pointer_type TwoByteVolumePixelDataset::getImageYZ(
      index_type x_index, dataset_key_type image_key)
      throw(NullPointerException, IndexOutOfBoundsException)
  {
    if (dataset_.IsNull() || image_extractor_.IsNull())
    {
      throw(NullPointerException("OneByteVolumePixelDataset::getSliceYZ"));
    }
    if (x_index >= dataset_size_[X_DIMENSION])
    {
      throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceYZ"));
    }

    yz_region_to_extract_.SetIndex(X_DIMENSION, x_index); 
    image_extractor_->SetExtractionRegion(yz_region_to_extract_);
    
    image_extractor_->UpdateLargestPossibleRegion();
    
    image_type::Pointer image = image_extractor_->GetOutput();
    image->DisconnectPipeline();
    image->GetPixelContainer()->ContainerManageMemoryOff();

    TwoByteImagePixelDataset* image_dataset(new TwoByteImagePixelDataset(image_key, image));

    image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceYZ(x_index));
    image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());

    return(dataset_pointer_type(image_dataset));
  }
    
} // namespace imedgine

---