pixel_dataset.cpp

Go to the documentation of this file.

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

#include "pixel_dataset.h"
#include "pixel_metadata.h"

#include <limits>

namespace imedgine
{
  
  //--------------------------------------------------
  
  bool operator == (matrix_type matrix, identity_matrix_type identity_matrix)
  {
    if ((matrix.size1() == identity_matrix.size1()) && 
         (matrix.size2() == identity_matrix.size2()))
    {
      matrix_type::const_iterator1 m_iter = matrix.begin1();
      identity_matrix_type::const_iterator1 im_iter = identity_matrix.begin1();
      for ( ; m_iter != matrix.end1(); ++m_iter, ++im_iter)
      {
        if (*m_iter != *im_iter)
        {
          return(false);
        }
      }
      return(true);
    }
    return(false);
  }
  
  //--------------------------------------------------
  
  bool operator != (matrix_type matrix, identity_matrix_type identity_matrix)
  {
    return((matrix == identity_matrix) == false);
  }
  
  
  //--------------------------------------------------
  
  PixelDataset::PixelDataset(dataset_type type, dataset_key_type dataset_key,
                             unsigned char num_dimensions, 
                             unsigned char num_bytes_per_pixel)
  : Dataset(type, dataset_key),
    num_dimensions_(num_dimensions),
    num_bytes_per_pixel_(num_bytes_per_pixel),
    dataset_size_(num_dimensions_),
    current_focus_point_(num_dimensions_),
    spacings_(num_dimensions_),
    min_pixel_value_(0.0),
    max_pixel_value_(0.0),
    transformation_matrix_(identity_matrix_type(
        num_dimensions_, num_dimensions_)),
    offset_vector_(num_dimensions_, 0)
  {
  }
  
  //--------------------------------------------------
  
  PixelDataset::PixelDataset(PixelDataset const& src)
  : Dataset(src)
  {
  }
  
  //--------------------------------------------------
  
  PixelDataset::~PixelDataset() 
  {
  }
  
  //--------------------------------------------------
  
  metadata_pointer_type PixelDataset::getMetadata() const
  {
    return(metadata_pointer_type(new PixelMetadata(
        num_dimensions_, dataset_size_, spacings_, num_bytes_per_pixel_)));
  }
  
  //--------------------------------------------------
  
  size_type PixelDataset::getNumElements() const
  {
    size_type num_elements = 1;
    
    for (unsigned char dim = 0; dim < num_dimensions_; ++dim)
    {
      num_elements *= dataset_size_[dim];
    }
    return(num_elements);
  }
  
  //--------------------------------------------------
  
  unsigned char PixelDataset::getNumDimensions() const
  {
    return(num_dimensions_);
  }
  
  //--------------------------------------------------
  
  unsigned char PixelDataset::getNumBytesPerPixel() const
  {
    return(num_bytes_per_pixel_);
  }
    
  //--------------------------------------------------
  
  dataset_position_type const& PixelDataset::getSize() const
  {
    return(dataset_size_);
  }
  
  //--------------------------------------------------
  
  void PixelDataset::setFocusPoint(
      dataset_position_type const& focus_point)
  {
    current_focus_point_ = focus_point;
  }
    
  //--------------------------------------------------
  
  void PixelDataset::setFocusPointAt(unsigned char dimension, index_type index)
      throw(IndexOutOfBoundsException)
  {
    try
    {
      if (index >= dataset_size_.at(dimension))
      {
        throw(IndexOutOfBoundsException("PixelDataset::setFocusPointAt"));
      }
      current_focus_point_.at(dimension) = index; 
    }
    catch (std::out_of_range const&)
    {}
  }
  
  //--------------------------------------------------

  dataset_position_type const& PixelDataset::getFocusPoint() const
  {
    return(current_focus_point_);
  }
  
  //--------------------------------------------------
  
  void PixelDataset::setSpacings(std::vector<double> spacings)
  {
    try
    {
      for (unsigned char dim_index = 0; dim_index < num_dimensions_; ++dim_index)
      {
        spacings_.at(dim_index) = spacings.at(dim_index);
      }
    }
    catch (...)
    {}
  }

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

  double PixelDataset::getMinPixelValue() const
  {
    return(min_pixel_value_);
  }

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

  double PixelDataset::getMaxPixelValue() const
  {
    return(max_pixel_value_);
  }
  
  //----------------------------------------------------
    
  void PixelDataset::setTransformationMatrix(matrix_type const& matrix)
  {
    transformation_matrix_ = matrix;
  }
    
 //----------------------------------------------------
    
  matrix_type const& PixelDataset::getTransformationMatrix() const
  {
    return(transformation_matrix_);
  }
    
  //----------------------------------------------------
    
  void PixelDataset::setOffsetVector(offset_vector_type const& offset)
  {
    offset_vector_ = offset;
  }
    
  //----------------------------------------------------
    
  offset_vector_type const& PixelDataset::getOffsetVector() const
  {
    return(offset_vector_);
  }
  
}

---