PixelBuffer.h

/*
 * #%L
 * OME-FILES C++ library for image IO.
 * Copyright © 2006 - 2015 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_FILES_PIXELBUFFER_H
#define OME_FILES_PIXELBUFFER_H

#include <array>
#include <cstdint>
#include <istream>
#include <limits>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>

// Disable expensive bounds checking
#define BOOST_DISABLE_ASSERTS 1
#include <boost/multi_array.hpp>

#include <ome/files/PixelProperties.h>

#include <ome/common/variant.h>

#include <ome/xml/model/enums/DimensionOrder.h>

namespace ome
{
  namespace files
  {

    enum Dimensions
      {
        DIM_SPATIAL_X  = 0, 
        DIM_SPATIAL_Y  = 1, 
        DIM_SPATIAL_Z  = 2, 
        DIM_TEMPORAL_T = 3, 
        DIM_CHANNEL    = 4, 
        DIM_SUBCHANNEL = 5, 
        DIM_MODULO_Z   = 6, 
        DIM_MODULO_T   = 7, 
        DIM_MODULO_C   = 8  
      };

    class PixelBufferBase
    {
    public:
      static const uint16_t dimensions = 9;

      typedef boost::multi_array_types::size_type size_type;

      typedef boost::multi_array_types::index index;

      typedef std::array<boost::multi_array_types::index,
                                 PixelBufferBase::dimensions> indices_type;

      typedef boost::general_storage_order<dimensions> storage_order_type;

      typedef boost::detail::multi_array::extent_gen<dimensions> range_type;

    protected:
      PixelBufferBase(::ome::xml::model::enums::PixelType pixeltype,
                      EndianType                          endiantype):
        pixeltype(pixeltype),
        endiantype(endiantype)
      {}

    public:
      virtual ~PixelBufferBase()
      {}

      ::ome::xml::model::enums::PixelType
      pixelType() const
      {
        return pixeltype;
      }

      EndianType
      endianType() const
      {
        return endiantype;
      }

      static storage_order_type
      make_storage_order(ome::xml::model::enums::DimensionOrder order,
                         bool                                   interleaved);

      static storage_order_type
      default_storage_order();

    private:
      const ::ome::xml::model::enums::PixelType pixeltype;

      const EndianType endiantype;
    };

    template<typename T>
    class PixelBuffer : public PixelBufferBase
    {
    public:
      typedef T value_type;

      typedef boost::multi_array_ref<value_type, dimensions> array_ref_type;

      typedef boost::multi_array<value_type, dimensions> array_type;

      explicit PixelBuffer():
        PixelBufferBase(::ome::xml::model::enums::PixelType::UINT8, ENDIAN_NATIVE),
        multiarray(std::shared_ptr<array_type>(new array_type(boost::extents[1][1][1][1][1][1][1][1][1],
                                                              PixelBufferBase::default_storage_order())))
      {}

      template<class ExtentList>
      explicit
      PixelBuffer(const ExtentList&                   extents,
                  ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                  EndianType                          endiantype = ENDIAN_NATIVE,
                  const storage_order_type&           storage = PixelBufferBase::default_storage_order()):
        PixelBufferBase(pixeltype, endiantype),
        multiarray(std::shared_ptr<array_type>(new array_type(extents, storage)))
      {}

      template<class ExtentList>
      explicit
      PixelBuffer(value_type                          *pixeldata,
                  const ExtentList&                    extents,
                  ::ome::xml::model::enums::PixelType  pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                  EndianType                           endiantype = ENDIAN_NATIVE,
                  const storage_order_type&            storage = PixelBufferBase::default_storage_order()):
        PixelBufferBase(pixeltype, endiantype),
        multiarray(std::shared_ptr<array_ref_type>(new array_ref_type(pixeldata, extents, storage)))
      {}

      explicit
      PixelBuffer(const range_type&                   range,
                  ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                  EndianType                          endiantype = ENDIAN_NATIVE,
                  const storage_order_type&           storage = PixelBufferBase::default_storage_order()):
        PixelBufferBase(pixeltype, endiantype),
        multiarray(std::shared_ptr<array_type>(new array_type(range, storage)))
      {}

      explicit
      PixelBuffer(value_type                          *pixeldata,
                  const range_type&                    range,
                  ::ome::xml::model::enums::PixelType  pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                  EndianType                           endiantype = ENDIAN_NATIVE,
                  const storage_order_type&            storage = PixelBufferBase::default_storage_order()):
        PixelBufferBase(pixeltype, endiantype),
        multiarray(std::shared_ptr<array_ref_type>(new array_ref_type(pixeldata, range, storage)))
      {}

      explicit
      PixelBuffer(const PixelBuffer& buffer):
        PixelBufferBase(buffer),
        multiarray(buffer.multiarray)
      {}

      virtual ~PixelBuffer()
      {}

      array_ref_type&
      array();

      const array_ref_type&
      array() const;

      value_type *
      data()
      {
        return array().data();
      }

      const value_type *
      data() const
      {
        return array().data();
      }

      bool
      valid() const
      {
        bool is_valid = true;

        try
          {
            array();
          }
        catch (const std::runtime_error&)
          {
            is_valid = false;
          }

        return is_valid;
      }

      bool
      managed() const
      {
        return (boost::get<std::shared_ptr<array_type>>(&multiarray) != nullptr);
      }

      size_type
      num_elements() const
      {
        return array().num_elements();
      }

      size_type
      num_dimensions() const
      {
        return array().num_dimensions();
      }

      const size_type *
      shape() const
      {
        return array().shape();
      }

      const boost::multi_array_types::index *
      strides() const
      {
        return array().strides();
      }

      const boost::multi_array_types::index *
      index_bases() const
      {
        return array().index_bases();
      }

      const value_type *
      origin() const
      {
        return array().origin();
      }

      const storage_order_type&
      storage_order() const
      {
        return array().storage_order();
      }

      PixelBuffer&
      operator = (const PixelBuffer& rhs)
      {
        array() = rhs.array();
        return *this;
      }

      PixelBuffer&
      operator = (const array_ref_type& rhs)
      {
        array() = rhs;
        return *this;
      }

      bool
      operator == (const PixelBuffer& rhs) const
      {
        return array() == rhs.array();
      }

      bool
      operator == (const array_ref_type& rhs) const
      {
        return array() == rhs;
      }

      bool
      operator != (const PixelBuffer& rhs) const
      {
        return array() != rhs.array();
      }

      bool
      operator != (const array_ref_type& rhs) const
      {
        return array() != rhs;
      }

      bool
      operator < (const PixelBuffer& rhs) const
      {
        return array() < rhs.array();
      }

      bool
      operator < (const array_ref_type& rhs) const
      {
        return array() < rhs;
      }

      bool
      operator <= (const PixelBuffer& rhs) const
      {
        return array() <= rhs.array();
      }

      bool
      operator <= (const array_ref_type& rhs) const
      {
        return array() <= rhs;
      }

      bool
      operator > (const PixelBuffer& rhs) const
      {
        return array() > rhs.array();
      }

      bool
      operator > (const array_ref_type& rhs) const
      {
        return array() > rhs;
      }

      bool
      operator >= (const PixelBuffer& rhs) const
      {
        return array() >= rhs.array();
      }

      bool
      operator >= (const array_ref_type& rhs) const
      {
        return array() >= rhs;
      }

      template <typename InputIterator>
      void
      assign(InputIterator begin,
             InputIterator end)
      {
        array().assign(begin, end);
      }

      value_type&
      at(const indices_type& indices)
      {
        return array()(indices);
      }

      const value_type&
      at(const indices_type& indices) const
      {
        return array()(indices);
      }

      template<class charT, class traits>
      inline void
      read(std::basic_istream<charT,traits>& stream)
      {
        stream.read(reinterpret_cast<char *>(data()),
                    static_cast<std::streamsize>(num_elements() * sizeof(value_type)));
      }

      template<class charT, class traits>
      inline void
      write(std::basic_ostream<charT,traits>& stream) const
      {
        stream.write(reinterpret_cast<const char *>(data()),
                     static_cast<std::streamsize>(num_elements() * sizeof(value_type)));
      }

    private:
      boost::variant<std::shared_ptr<array_type>,
                     std::shared_ptr<array_ref_type>> multiarray;
    };

    namespace detail
    {

      template<typename T>
      struct PixelBufferArrayVisitor : public boost::static_visitor<typename PixelBuffer<T>::array_ref_type *>
      {
        template <typename U>
        typename PixelBuffer<T>::array_ref_type *
        operator() (U& v) const
        {
          if (!v)
            throw std::runtime_error("Null array type");
          return v.get();
        }
      };

      template<typename T>
      struct PixelBufferConstArrayVisitor : public boost::static_visitor<const typename PixelBuffer<T>::array_ref_type *>
      {
        template <typename U>
        const typename PixelBuffer<T>::array_ref_type *
        operator() (U& v) const
        {
          if (!v)
            throw std::runtime_error("Null array type");
          return v.get();
        }
      };

    }

    template<typename T>
    typename PixelBuffer<T>::array_ref_type&
    PixelBuffer<T>::array()
    {
      detail::PixelBufferArrayVisitor<T> v;
      return *(boost::apply_visitor(v, multiarray));
    }

    template<typename T>
    const typename PixelBuffer<T>::array_ref_type&
    PixelBuffer<T>::array() const
    {
      detail::PixelBufferConstArrayVisitor<T> v;
      return *(boost::apply_visitor(v, multiarray));
    }

  }
}

namespace std
{

  template<typename T, class charT, class traits>
  inline std::basic_istream<charT,traits>&
  operator>> (std::basic_istream<charT,traits>& is,
              ::ome::files::PixelBuffer<T>& buf)
  {
    buf.read(is);
    return is;
  }

  template<typename T, class charT, class traits>
  inline std::basic_ostream<charT,traits>&
  operator<< (std::basic_ostream<charT,traits>& os,
              const ::ome::files::PixelBuffer<T>& buf)
  {
    buf.write(os);
    return os;
  }

}

#endif // OME_FILES_PIXELBUFFER_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */