167 lines
6.9 KiB
C++
167 lines
6.9 KiB
C++
/*
|
|
Copyright 2005-2007 Adobe Systems Incorporated
|
|
|
|
Use, modification and distribution are subject to the Boost Software License,
|
|
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt).
|
|
|
|
See http://stlab.adobe.com/gil for most recent version including documentation.
|
|
*/
|
|
|
|
/*************************************************************************************************/
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
/// \file
|
|
/// \brief Example on how to create a new model of a pixel reference
|
|
/// \author Lubomir Bourdev and Hailin Jin \n
|
|
/// Adobe Systems Incorporated
|
|
/// \date 2005-2007 \n Last updated on February 26, 2007
|
|
//////
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef GIL_INTERLEAVED_REF_HPP
|
|
#define GIL_INTERLEAVED_REF_HPP
|
|
|
|
#include <boost/mpl/range_c.hpp>
|
|
#include <boost/mpl/vector_c.hpp>
|
|
#include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
|
|
|
|
namespace boost { namespace gil {
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
///
|
|
/// A model of an interleaved pixel reference. Holds a pointer to the first channel
|
|
/// MODELS:
|
|
/// MutableHomogeneousPixelConcept
|
|
/// MutableHomogeneousColorBaseConcept
|
|
/// MutableColorBaseConcept
|
|
/// HomogeneousColorBaseConcept
|
|
/// ColorBaseConcept
|
|
/// HomogeneousPixelBasedConcept
|
|
/// PixelBasedConcept
|
|
///
|
|
/// For planar reference proxies to work properly, all of their methods must be const-qualified
|
|
/// and their iterator's reference type must be const-qualified.
|
|
/// Mutability of the reference proxy is part of its type (in this case, depends on the mutability of ChannelReference)
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
template <typename ChannelReference, // Models ChannelConcept. A channel reference, unsigned char& or const unsigned char&
|
|
typename Layout> // A layout (includes the color space and channel ordering)
|
|
struct interleaved_ref {
|
|
private:
|
|
typedef typename channel_traits<ChannelReference>::value_type channel_t;
|
|
typedef typename channel_traits<ChannelReference>::reference channel_reference_t;
|
|
typedef typename channel_traits<ChannelReference>::const_reference channel_const_reference_t;
|
|
typedef typename channel_traits<ChannelReference>::pointer channel_pointer_t;
|
|
public:
|
|
// Required by ColorBaseConcept
|
|
typedef Layout layout_t;
|
|
|
|
// Copy construction from a compatible type. The copy constructor of references is shallow. The channels themselves are not copied.
|
|
interleaved_ref(const interleaved_ref& p) : _channels(p._channels) {}
|
|
template <typename P> interleaved_ref(const P& p) : _channels(p._channels) { check_compatible<P>(); }
|
|
|
|
template <typename P> bool operator==(const P& p) const { check_compatible<P>(); return static_equal(*this,p); }
|
|
template <typename P> bool operator!=(const P& p) const { return !(*this==p); }
|
|
|
|
// Required by MutableColorBaseConcept
|
|
|
|
// Assignment from a compatible type
|
|
const interleaved_ref& operator=(const interleaved_ref& p) const { static_copy(p,*this); return *this; }
|
|
template <typename P> const interleaved_ref& operator=(const P& p) const { check_compatible<P>(); static_copy(p,*this); return *this; }
|
|
|
|
// Required by PixelConcept
|
|
typedef pixel<channel_t, layout_t> value_type;
|
|
typedef interleaved_ref reference;
|
|
typedef interleaved_ref<channel_const_reference_t, layout_t> const_reference;
|
|
static const bool is_mutable = channel_traits<ChannelReference>::is_mutable;
|
|
|
|
// Required by HomogeneousPixelConcept
|
|
ChannelReference operator[](std::size_t i) const { return _channels[i]; }
|
|
|
|
// Custom constructor (not part of any concept)
|
|
explicit interleaved_ref(channel_pointer_t channels) : _channels(channels) {}
|
|
// This is needed for the reference proxy to work properly
|
|
const interleaved_ref* operator->() const { return this; }
|
|
private:
|
|
channel_pointer_t _channels;
|
|
|
|
template <typename Pixel> static void check_compatible() { gil_function_requires<PixelsCompatibleConcept<Pixel,interleaved_ref> >(); }
|
|
};
|
|
|
|
// Required by ColorBaseConcept
|
|
template <typename ChannelReference, typename Layout, int K>
|
|
struct kth_element_type<interleaved_ref<ChannelReference,Layout>,K> {
|
|
typedef ChannelReference type;
|
|
};
|
|
|
|
template <typename ChannelReference, typename Layout, int K>
|
|
struct kth_element_reference_type<interleaved_ref<ChannelReference,Layout>,K> {
|
|
typedef ChannelReference type;
|
|
};
|
|
|
|
template <typename ChannelReference, typename Layout, int K>
|
|
struct kth_element_const_reference_type<interleaved_ref<ChannelReference,Layout>,K> {
|
|
typedef ChannelReference type;
|
|
// typedef typename channel_traits<ChannelReference>::const_reference type;
|
|
};
|
|
|
|
|
|
// Required by ColorBaseConcept
|
|
template <int K, typename ChannelReference, typename Layout>
|
|
typename element_reference_type<interleaved_ref<ChannelReference,Layout> >::type
|
|
at_c(const interleaved_ref<ChannelReference,Layout>& p) { return p[K]; };
|
|
|
|
// Required by HomogeneousColorBaseConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
typename element_reference_type<interleaved_ref<ChannelReference,Layout> >::type
|
|
dynamic_at_c(const interleaved_ref<ChannelReference,Layout>& p, std::size_t n) { return p[n]; };
|
|
|
|
namespace detail {
|
|
struct swap_fn_t {
|
|
template <typename T> void operator()(T& x, T& y) const {
|
|
using std::swap;
|
|
swap(x,y);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Required by MutableColorBaseConcept. The default std::swap does not do the right thing for proxy references - it swaps the references, not the values
|
|
template <typename ChannelReference, typename Layout>
|
|
void swap(const interleaved_ref<ChannelReference,Layout>& x, const interleaved_ref<ChannelReference,Layout>& y) {
|
|
static_for_each(x,y,detail::swap_fn_t());
|
|
};
|
|
|
|
// Required by PixelConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
struct is_pixel<interleaved_ref<ChannelReference,Layout> > : public boost::mpl::true_ {};
|
|
|
|
|
|
// Required by PixelBasedConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
struct color_space_type<interleaved_ref<ChannelReference,Layout> > {
|
|
typedef typename Layout::color_space_t type;
|
|
};
|
|
|
|
// Required by PixelBasedConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
struct channel_mapping_type<interleaved_ref<ChannelReference,Layout> > {
|
|
typedef typename Layout::channel_mapping_t type;
|
|
};
|
|
|
|
// Required by PixelBasedConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
struct is_planar<interleaved_ref<ChannelReference,Layout> > : mpl::false_ {};
|
|
|
|
// Required by HomogeneousPixelBasedConcept
|
|
template <typename ChannelReference, typename Layout>
|
|
struct channel_type<interleaved_ref<ChannelReference,Layout> > {
|
|
typedef typename channel_traits<ChannelReference>::value_type type;
|
|
};
|
|
|
|
} } // namespace boost::gil
|
|
|
|
#endif
|