VariantPixelBuffer.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_VARIANTPIXELBUFFER_H
#define OME_FILES_VARIANTPIXELBUFFER_H

#include <ome/files/PixelBuffer.h>
#include <ome/files/PixelProperties.h>

#include <ome/common/variant.h>

#include <ome/compat/memory.h>

namespace ome
{
  namespace files
  {

    class VariantPixelBuffer
    {
    private:
      /*
       * The following series of typedefs may appear a little
       * complicated, and perhaps unnecessary, but they do have a
       * purpose.  They exist to work around pre-C++11 compiler
       * limitations (lack of variadic templates), primarily a limit
       * to the maximum number of types which may be used with
       * boost::variant.  To exceed this limit (minimum guaranteed is
       * 10), boost::mpl sequences are used to define the variant
       * types.  These also have length limits, so the type list is
       * built up by defining separate type sequences, then
       * concatenating them, and transforming them to provide list
       * variants.  Note that none of this is code per se; it's all
       * compile-time template expansion which evaluates to a list of
       * permitted types.
       */

      typedef boost::mpl::vector<PixelProperties< ::ome::xml::model::enums::PixelType::INT8>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::INT16>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::INT32>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::UINT8>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::UINT16>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::UINT32>,
                                 PixelProperties< ::ome::xml::model::enums::PixelType::BIT> > integer_pixel_types;

      typedef boost::mpl::vector< PixelProperties< ::ome::xml::model::enums::PixelType::FLOAT>,
                                  PixelProperties< ::ome::xml::model::enums::PixelType::DOUBLE>,
                                  PixelProperties< ::ome::xml::model::enums::PixelType::COMPLEX>,
                                  PixelProperties< ::ome::xml::model::enums::PixelType::DOUBLECOMPLEX> > float_pixel_types;

      typedef boost::mpl::joint_view<integer_pixel_types,
                                     float_pixel_types>::type basic_pixel_types_view;

      template<typename T>
      struct make_buffer
      {
        typedef ome::compat::shared_ptr<PixelBuffer<typename T::std_type> > type;
      };

      typedef boost::mpl::transform_view<basic_pixel_types_view, make_buffer<boost::mpl::_1> >::type pixel_buffer_types_view;

      typedef boost::mpl::vector<> empty_types;

      typedef boost::mpl::insert_range<empty_types, boost::mpl::end<empty_types>::type, pixel_buffer_types_view>::type pixel_buffer_types;

    public:
      typedef boost::make_variant_over<pixel_buffer_types>::type variant_buffer_type;

      typedef PixelProperties< ::ome::xml::model::enums::PixelType::UINT8>::std_type raw_type;

      typedef boost::multi_array_types::size_type size_type;

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

      typedef PixelBufferBase::storage_order_type storage_order_type;

      typedef PixelBufferBase::range_type range_type;

    public:
      explicit
      VariantPixelBuffer():
        buffer(createBuffer(boost::extents[1][1][1][1][1][1][1][1][1]))
      {
      }

      template<class ExtentList>
      explicit
      VariantPixelBuffer(const ExtentList&                   extents,
                         ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                         const storage_order_type&           storage = PixelBufferBase::default_storage_order()):
        buffer(createBuffer(extents, pixeltype, storage))
      {
      }

      explicit
      VariantPixelBuffer(const range_type&                   range,
                         ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                         const storage_order_type&           storage = PixelBufferBase::default_storage_order()):
        buffer(createBuffer(range, pixeltype, storage))
      {
      }

      explicit
      VariantPixelBuffer(const VariantPixelBuffer& buffer);

      template<typename T>
      explicit
      VariantPixelBuffer(ome::compat::shared_ptr<PixelBuffer<T> >& buffer):
        buffer(buffer)
      {
      }

      virtual
      ~VariantPixelBuffer()
      {}

      variant_buffer_type&
      vbuffer()
      {
        return buffer;
      }

      const variant_buffer_type&
      vbuffer() const
      {
        return buffer;
      }

    protected:
      template<class T, class ExtentList>
      static variant_buffer_type
      makeBuffer(const ExtentList&                   extents,
                 const storage_order_type&           storage,
                 ::ome::xml::model::enums::PixelType pixeltype)
      {
        return variant_buffer_type(ome::compat::shared_ptr<PixelBuffer<T> >(new PixelBuffer<T>(extents, pixeltype, ENDIAN_NATIVE, storage)));
      }

      template<class T>
      static variant_buffer_type
      makeBuffer(const range_type&                   range,
                 const storage_order_type&           storage,
                 ::ome::xml::model::enums::PixelType pixeltype)
      {
        return variant_buffer_type(ome::compat::shared_ptr<PixelBuffer<T> >(new PixelBuffer<T>(range, pixeltype, ENDIAN_NATIVE, storage)));
      }

      // No switch default to avoid -Wunreachable-code errors.
      // However, this then makes -Wswitch-default complain.  Disable
      // temporarily.
#ifdef __GNUC__
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wswitch-default"
#endif

#define OME_FILES_VARIANTPIXELBUFFER_CREATEEXTENTS_CASE(maR, maProperty, maType) \
          case ::ome::xml::model::enums::PixelType::maType:                      \
            buf = makeBuffer<PixelProperties< ::ome::xml::model::enums::PixelType::maType>::std_type>(extents, storage, pixeltype); \
            break;

      template<class ExtentList>
      static variant_buffer_type
      createBuffer(const ExtentList&                   extents,
                   ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                   const storage_order_type&           storage = PixelBufferBase::default_storage_order())
      {
        variant_buffer_type buf;

        switch(pixeltype)
          {
            BOOST_PP_SEQ_FOR_EACH(OME_FILES_VARIANTPIXELBUFFER_CREATEEXTENTS_CASE, size, OME_XML_MODEL_ENUMS_PIXELTYPE_VALUES);
          }

        return buf;
      }

#undef OME_FILES_VARIANTPIXELBUFFER_CREATEEXTENTS_CASE

#define OME_FILES_VARIANTPIXELBUFFER_CREATERANGE_CASE(maR, maProperty, maType) \
          case ::ome::xml::model::enums::PixelType::maType:                    \
            buf = makeBuffer<PixelProperties< ::ome::xml::model::enums::PixelType::maType>::std_type>(range, storage, pixeltype); \
            break;

      static variant_buffer_type
      createBuffer(const range_type&                   range,
                   ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                   const storage_order_type&           storage = PixelBufferBase::default_storage_order())
      {
        variant_buffer_type buf;

        switch(pixeltype)
          {
            BOOST_PP_SEQ_FOR_EACH(OME_FILES_VARIANTPIXELBUFFER_CREATERANGE_CASE, size, OME_XML_MODEL_ENUMS_PIXELTYPE_VALUES);
          }

        return buf;
      }

#undef OME_FILES_VARIANTPIXELBUFFER_CREATERANGE_CASE

#ifdef __GNUC__
#  pragma GCC diagnostic pop
#endif

    public:
      template<class ExtentList>
      void
      setBuffer(const ExtentList&                   extents,
                ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                const storage_order_type&           storage = PixelBufferBase::default_storage_order())
      {
        buffer = createBuffer(extents, pixeltype, storage);
      }

      void
      setBuffer(const range_type&                   range,
                ::ome::xml::model::enums::PixelType pixeltype = ::ome::xml::model::enums::PixelType::UINT8,
                const storage_order_type&           storage = PixelBufferBase::default_storage_order())
      {
        buffer = createBuffer(range, pixeltype, storage);
      }

      bool
      managed() const;

      size_type
      num_elements() const;

      size_type
      num_dimensions() const;

      const size_type *
      shape() const;

      const boost::multi_array_types::index *
      strides() const;

      const boost::multi_array_types::index *
      index_bases() const;

      template <typename T>
      const T *
      origin() const;

      const storage_order_type&
      storage_order() const;

      ::ome::xml::model::enums::PixelType
      pixelType() const;

      EndianType
      endianType() const;

      template<typename T>
      typename PixelBuffer<T>::array_ref_type&
      array();

      template<typename T>
      const typename PixelBuffer<T>::array_ref_type&
      array() const;

      raw_type *
      data();

      const raw_type *
      data() const;

      template<typename T>
      T *
      data();

      template<typename T>
      const T *
      data() const;

      bool
      valid() const;

      VariantPixelBuffer&
      operator = (const VariantPixelBuffer& rhs);

      bool
      operator == (const VariantPixelBuffer& rhs) const;

      bool
      operator != (const VariantPixelBuffer& rhs) const;

      template <typename InputIterator>
      void
      assign(InputIterator begin,
             InputIterator end);

      template<class charT, class traits>
      inline void
      read(std::basic_istream<charT,traits>& stream);

      template<class charT, class traits>
      inline void
      write(std::basic_ostream<charT,traits>& stream) const;

    protected:
      variant_buffer_type buffer;
    };

    namespace detail
    {

      template<typename T>
      struct VariantPixelBufferVisitor : public boost::static_visitor<PixelBuffer<T>&>
      {
        PixelBuffer<T>&
        operator() (ome::compat::shared_ptr<PixelBuffer<T> >& v) const
        {
          if (!v)
            throw std::runtime_error("Null pixel type");
          return *v;
        }

        template <typename U>
        PixelBuffer<T>&
        operator() (U& /* v */) const
        {
          throw std::runtime_error("Unsupported pixel type conversion for buffer");
        }
      };

      template<typename T>
      struct VariantPixelBufferConstVisitor : public boost::static_visitor<const PixelBuffer<T>&>
      {
        const PixelBuffer<T>&
        operator() (const ome::compat::shared_ptr<PixelBuffer<T> >& v) const
        {
          if (!v)
            throw std::runtime_error("Null pixel type");
          return *v;
        }

        template <typename U>
        const PixelBuffer<T>&
        operator() (U& /* v */) const
        {
          throw std::runtime_error("Unsupported pixel type conversion for buffer");
        }
      };

      template <typename InputIterator>
      struct VariantPixelBufferAssignVisitor : public boost::static_visitor<>
      {
        InputIterator begin;
        InputIterator end;

        VariantPixelBufferAssignVisitor(InputIterator begin, InputIterator end):
          begin(begin), end(end)
        {}

        void
        operator() (ome::compat::shared_ptr<PixelBuffer<typename std::iterator_traits<InputIterator>::value_type> >& v) const
        {
          if (!v)
            throw std::runtime_error("Null pixel type");
          v->array().assign(begin, end);
        }

        template <typename T>
        void
        operator() (T& /* v */) const
        {
          throw std::runtime_error("Unsupported pixel type conversion for assignment");
        }
      };

      template<class charT, class traits>
      struct VariantPixelBufferReadVisitor : public boost::static_visitor<>
      {
        std::basic_istream<charT,traits>& stream;

        VariantPixelBufferReadVisitor(std::basic_istream<charT,traits>& stream):
          stream(stream)
        {}

        template <typename T>
        void
        operator() (T& v) const
        {
          if (!v)
            throw std::runtime_error("Null pixel type");
          v->read(stream);
        }
      };

      template<class charT, class traits>
      struct VariantPixelBufferWriteVisitor : public boost::static_visitor<>
      {
        std::basic_ostream<charT,traits>& stream;

        VariantPixelBufferWriteVisitor(std::basic_ostream<charT,traits>& stream):
          stream(stream)
        {}

        template <typename T>
        void
        operator() (const T& v) const
        {
          if (!v)
            throw std::runtime_error("Null pixel type");
          v->write(stream);
        }
      };

      struct CopySubchannelVisitor : public boost::static_visitor<>
      {
        VariantPixelBuffer& dest;
        dimension_size_type subC;

        CopySubchannelVisitor(VariantPixelBuffer& dest,
                              dimension_size_type subC):
          dest(dest),
          subC(subC)
        {}

        template<typename T>
        void
        operator()(const T& v)
        {
          // Shape is the same as the source buffer, but with one subchannel.
          ome::compat::array<VariantPixelBuffer::size_type, 9> dest_shape;
          const VariantPixelBuffer::size_type *shape_ptr(v->shape());
          std::copy(shape_ptr, shape_ptr + PixelBufferBase::dimensions,
                    dest_shape.begin());
          dest_shape[DIM_SUBCHANNEL] = 1;

          // Default to planar ordering; since openByes/saveBytes
          // don't use ZTC the DimensionOrder doesn't matter here so
          // long as it matches what the TIFF reader/writer uses.
          PixelBufferBase::storage_order_type order(PixelBufferBase::make_storage_order(ome::xml::model::enums::DimensionOrder::XYZTC, false));

          dest.setBuffer(dest_shape, v->pixelType(), order);

          T& destbuf = boost::get<T>(dest.vbuffer());

          typename boost::multi_array_types::index_gen indices;
          typedef boost::multi_array_types::index_range range;
          destbuf->array() = v->array()[boost::indices[range()][range()][range()][range()][range()][range(subC,subC+1)][range()][range()][range()]];
        }
      };

      struct MergeSubchannelVisitor : public boost::static_visitor<>
      {
        VariantPixelBuffer& dest;
        dimension_size_type subC;

        MergeSubchannelVisitor(VariantPixelBuffer& dest,
                               dimension_size_type subC):
          dest(dest),
          subC(subC)
        {}

        template<typename T>
        void
        operator()(const T& v)
        {
          T& destbuf = boost::get<T>(dest.vbuffer());

          typename boost::multi_array_types::index_gen indices;
          typedef boost::multi_array_types::index_range range;
          destbuf->array()[boost::indices[range()][range()][range()][range()][range()][range(subC,subC+1)][range()][range()][range()]] = v->array();
        }
      };

    }

    template<typename T>
    inline typename PixelBuffer<T>::array_ref_type&
    VariantPixelBuffer::array()
    {
      detail::VariantPixelBufferVisitor<T> v;
      return boost::apply_visitor(v, buffer).array();
    }

    template<typename T>
    inline const typename PixelBuffer<T>::array_ref_type&
    VariantPixelBuffer::array() const
    {
      detail::VariantPixelBufferConstVisitor<T> v;
      return boost::apply_visitor(v, buffer).array();
    }

    template<typename T>
    inline T *
    VariantPixelBuffer::data()
    {
      detail::VariantPixelBufferVisitor<T> v;
      return boost::apply_visitor(v, buffer).data();
    }

    template<typename T>
    inline const T *
    VariantPixelBuffer::data() const
    {
      detail::VariantPixelBufferConstVisitor<T> v;
      return boost::apply_visitor(v, buffer).data();
    }

    template<typename T>
    inline const T *
    VariantPixelBuffer::origin() const
    {
      detail::VariantPixelBufferConstVisitor<T> v;
      return boost::apply_visitor(v, buffer).origin();
    }

    template <typename InputIterator>
    inline void
    VariantPixelBuffer::assign(InputIterator begin,
                               InputIterator end)
    {
      detail::VariantPixelBufferAssignVisitor<InputIterator> v(begin, end);
      boost::apply_visitor(v, buffer);
    }

    template<class charT, class traits>
    inline void
    VariantPixelBuffer::read(std::basic_istream<charT,traits>& stream)
    {
      detail::VariantPixelBufferReadVisitor<charT, traits> v(stream);
      boost::apply_visitor(v, buffer);
    }

    template<class charT, class traits>
    inline void
    VariantPixelBuffer::write(std::basic_ostream<charT,traits>& stream) const
    {
      detail::VariantPixelBufferWriteVisitor<charT, traits> v(stream);
      boost::apply_visitor(v, buffer);
    }

  }
}

namespace std
{

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

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

}

#endif // OME_FILES_VARIANTPIXELBUFFER_H

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