two_byte_image_pixel_dataset.cpp

Go to the documentation of this file.

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

#include "two_byte_image_pixel_dataset.h"

#include <limits>

namespace imedgine 
{
  //---------------------------------------------------
  
  TwoByteImagePixelDataset::TwoByteImagePixelDataset(
      dataset_key_type dataset_key, image_pointer_type image)
  : ImagePixelDataset(TWO_BYTE_IMAGE_PIXEL_DATASET, dataset_key, 2),
    image_intensity_filter_(image_intensity_filter_type::New())
  {
    if (image.IsNull() == false)
    {
      this->setDatasetInternal(image);
    }
  }
  
  //---------------------------------------------------
  
  TwoByteImagePixelDataset::TwoByteImagePixelDataset(TwoByteImagePixelDataset const& src)
  : ImagePixelDataset(src),
    image_intensity_filter_(image_intensity_filter_type::New())
  {
  }
  
  //---------------------------------------------------
  
  TwoByteImagePixelDataset::~TwoByteImagePixelDataset()
  {
  }

  //---------------------------------------------------
  
  external_data_pointer_type TwoByteImagePixelDataset::getData() const
      throw(NullPointerException)
  {
    if (dataset_.IsNull())
    {
      throw(NullPointerException("TwoByteImagePixelDataset::getData()"));
    }
 
    image_intensity_filter_->UpdateLargestPossibleRegion();
    
    external_image_type::Pointer image = image_intensity_filter_->GetOutput();
    image->DisconnectPipeline();
    image->GetPixelContainer()->ContainerManageMemoryOff();
    
    return(external_data_pointer_type(image->GetBufferPointer()));
  }

  //--------------------------------------------------
  
  TwoByteImagePixelDataset::image_pointer_type 
      TwoByteImagePixelDataset::getDataset()
  {
    return(dataset_);
  }
  
  //--------------------------------------------------
  
  TwoByteImagePixelDataset::const_image_pointer_type 
      TwoByteImagePixelDataset::getDataset() const
  {
    return(dataset_);
  }
  
  //--------------------------------------------------
  
  void TwoByteImagePixelDataset::setDataset(image_pointer_type dataset)
  {
    setDatasetInternal(dataset);
    is_dirty_ = true;
  }
  
  //--------------------------------------------------
  
  void TwoByteImagePixelDataset::setDatasetInternal(image_pointer_type dataset)
  {
    dataset_ = dataset;
    is_data_set_ = true;
    
    const_image_iterator_type image_iter(
        dataset_, dataset_->GetLargestPossibleRegion());
    for (image_iter.GoToBegin(); !image_iter.IsAtEnd(); ++image_iter)
    {
      if (image_iter.Value() > max_pixel_value_)
      {
        max_pixel_value_ = image_iter.Value();
      }  
      if (image_iter.Value() < min_pixel_value_)
      {
        min_pixel_value_ = image_iter.Value();
      }
    }
    
    region_type image_region = dataset_->GetLargestPossibleRegion();
    region_size_type image_size = image_region.GetSize();
    dataset_size_[X_DIMENSION] = image_size[X_DIMENSION];
    dataset_size_[Y_DIMENSION] = image_size[Y_DIMENSION];
    
    image_intensity_filter_->SetInput(dataset_);
    
    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());
  }
    
  //--------------------------------------------------
 
  void TwoByteImagePixelDataset::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));
  }
  
  //--------------------------------------------------
  
  double TwoByteImagePixelDataset::getIntensityWindow() const
    throw(NullPointerException)
  {
    if (image_intensity_filter_.IsNull())
    {
      throw(NullPointerException("OneByteVolumePixelDataset::getIntensityWindow()"));
    }
    return(static_cast<double>(image_intensity_filter_->GetWindow()));
  }

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

  double TwoByteImagePixelDataset::getIntensityLevel() const
      throw(NullPointerException)
  {
    if (image_intensity_filter_.IsNull())
    {
      throw(NullPointerException("OneByteVolumePixelDataset::getIntensityLevel()"));
    }
    return(static_cast<double>(image_intensity_filter_->GetLevel()));
  }

} // namespace imedgine

---