boost/gil/image.hpp
// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2021 Pranam Lashkari <plashkari628@gmail.com> // // Distributed under 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 // #ifndef BOOST_GIL_IMAGE_HPP #define BOOST_GIL_IMAGE_HPP #include <boost/gil/algorithm.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/assert.hpp> #include <boost/core/exchange.hpp> #include <cstddef> #include <memory> #include <utility> #include <type_traits> namespace boost { namespace gil { //////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ImageModel PixelBasedModel /// \brief container interface over image view. Models ImageConcept, PixelBasedConcept /// /// A 2D container whose elements are pixels. It is templated over the pixel type, a boolean /// indicating whether it should be planar, and an optional allocator. /// /// Note that its element type does not have to be a pixel. \p image can be instantiated with any Regular element, /// in which case it models the weaker RandomAccess2DImageConcept and does not model PixelBasedConcept /// /// When recreating an image of the same or smaller size the memory will be reused if possible. /// //////////////////////////////////////////////////////////////////////////////////////// template< typename Pixel, bool IsPlanar, typename Alloc> class image { public: #if defined(BOOST_NO_CXX11_ALLOCATOR) using allocator_type = typename Alloc::template rebind<unsigned char>::other; #else using allocator_type = typename std::allocator_traits<Alloc>::template rebind_alloc<unsigned char>; #endif using view_t = typename view_type_from_pixel<Pixel, IsPlanar>::type; using const_view_t = typename view_t::const_t; using point_t = typename view_t::point_t; using coord_t = typename view_t::coord_t; using value_type = typename view_t::value_type; using x_coord_t = coord_t; using y_coord_t = coord_t; point_t const& dimensions() const { return _view.dimensions(); } x_coord_t width() const { return _view.width(); } y_coord_t height() const { return _view.height(); } explicit image(std::size_t alignment=0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in), _allocated_bytes( 0 ) {} // Create with dimensions and optional initial value and alignment image(point_t const& dimensions, std::size_t alignment=0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in) , _allocated_bytes( 0 ) { allocate_and_default_construct(dimensions); } image(x_coord_t width, y_coord_t height, std::size_t alignment=0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in) , _allocated_bytes( 0 ) { allocate_and_default_construct(point_t(width,height)); } image(point_t const& dimensions, const Pixel& p_in, std::size_t alignment = 0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in) , _allocated_bytes( 0 ) { allocate_and_fill(dimensions, p_in); } image(x_coord_t width, y_coord_t height, const Pixel& p_in, std::size_t alignment = 0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in) , _allocated_bytes ( 0 ) { allocate_and_fill(point_t(width,height),p_in); } image(const image& img) : _memory(nullptr), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) , _allocated_bytes( img._allocated_bytes ) { allocate_and_copy(img.dimensions(),img._view); } template <typename P2, bool IP2, typename Alloc2> image(const image<P2,IP2,Alloc2>& img) : _memory(nullptr), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) , _allocated_bytes( img._allocated_bytes ) { allocate_and_copy(img.dimensions(),img._view); } template <typename Loc, typename std::enable_if<pixels_are_compatible<typename Loc::value_type, Pixel>::value, int>::type = 0> image(const image_view<Loc>& view, std::size_t alignment = 0, const Alloc alloc_in = Alloc()) : _memory(nullptr), _align_in_bytes(alignment), _alloc(alloc_in) , _allocated_bytes( 0 ) { allocate_and_copy(view.dimensions(),view); } // TODO Optimization: use noexcept (requires _view to be nothrow copy constructible) image(image&& img) : _view(img._view), _memory(img._memory), _align_in_bytes(img._align_in_bytes), _alloc(std::move(img._alloc)), _allocated_bytes(img._allocated_bytes) { img._view = view_t(); img._memory = nullptr; img._align_in_bytes = 0; img._allocated_bytes = 0; } image& operator=(const image& img) { if (dimensions() == img.dimensions()) copy_pixels(img._view,_view); else { image tmp(img); swap(tmp); } return *this; } template <typename Img> image& operator=(const Img& img) { if (dimensions() == img.dimensions()) copy_pixels(img._view,_view); else { image tmp(img); swap(tmp); } return *this; } private: using propagate_allocators = std::true_type; using no_propagate_allocators = std::false_type; template <class Alloc2> using choose_pocma = typename std::conditional< // TODO: Use std::allocator_traits<Allocator>::is_always_equal if available std::is_empty<Alloc2>::value, std::true_type, typename std::allocator_traits<Alloc2>::propagate_on_container_move_assignment::type >::type; static void exchange_memory(image& lhs, image& rhs) { lhs._memory = boost::exchange(rhs._memory, nullptr); lhs._align_in_bytes = boost::exchange(rhs._align_in_bytes, 0); lhs._allocated_bytes = boost::exchange(rhs._allocated_bytes, 0); lhs._view = boost::exchange(rhs._view, image::view_t{}); }; void move_assign(image& img, propagate_allocators) noexcept { // non-sticky allocator, can adopt the memory, fast destruct_pixels(_view); this->deallocate(); this->_alloc = img._alloc; exchange_memory(*this, img); } void move_assign(image& img, no_propagate_allocators) { if (_alloc == img._alloc) { // allocator stuck to the rhs, but it's equivalent of ours, we can still adopt the memory destruct_pixels(_view); this->deallocate(); exchange_memory(*this, img); } else { // cannot propagate the allocator and cannot adopt the memory if (img._memory) { allocate_and_copy(img.dimensions(), img._view); destruct_pixels(img._view); img.deallocate(); img._view = image::view_t{}; } else { destruct_pixels(this->_view); this->deallocate(); this->_view = view_t{}; } } } public: // TODO: Use noexcept(noexcept(move_assign(img, choose_pocma<allocator_type>{}))) // But https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52869 prevents it (fixed in GCC > 9) image& operator=(image&& img) { if (this != std::addressof(img)) // Use rebinded alloc to choose pocma move_assign(img, choose_pocma<allocator_type>{}); return *this; } ~image() { destruct_pixels(_view); deallocate(); } Alloc& allocator() { return _alloc; } Alloc const& allocator() const { return _alloc; } void swap(image& img) // required by MutableContainerConcept { using std::swap; swap(_align_in_bytes, img._align_in_bytes); swap(_memory, img._memory); swap(_view, img._view); #ifdef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE swap(_alloc, img._alloc); #else if constexpr (std::allocator_traits<Alloc>::propagate_on_container_swap::value) swap(_alloc, img._alloc); else BOOST_ASSERT(_alloc == img._alloc); #endif swap(_allocated_bytes, img._allocated_bytes ); } ///////////////////// // recreate ///////////////////// // without Allocator void recreate(point_t const& dims, std::size_t alignment = 0) { if (dims == _view.dimensions() && _align_in_bytes == alignment) return; _align_in_bytes = alignment; if (_allocated_bytes >= total_allocated_size_in_bytes(dims)) { destruct_pixels(_view); create_view(dims, std::integral_constant<bool, IsPlanar>()); default_construct_pixels(_view); } else { image tmp(dims, alignment); swap(tmp); } } void recreate(x_coord_t width, y_coord_t height, std::size_t alignment = 0) { recreate(point_t(width, height), alignment); } void recreate(point_t const& dims, const Pixel& p_in, std::size_t alignment = 0) { if (dims == _view.dimensions() && _align_in_bytes == alignment) return; _align_in_bytes = alignment; if (_allocated_bytes >= total_allocated_size_in_bytes(dims)) { destruct_pixels(_view); create_view(dims, typename std::integral_constant<bool, IsPlanar>()); uninitialized_fill_pixels(_view, p_in); } else { image tmp(dims, p_in, alignment); swap(tmp); } } void recreate( x_coord_t width, y_coord_t height, const Pixel& p_in, std::size_t alignment = 0 ) { recreate( point_t( width, height ), p_in, alignment ); } // with Allocator void recreate(point_t const& dims, std::size_t alignment, const Alloc alloc_in) { if (dims == _view.dimensions() && _align_in_bytes == alignment && alloc_in == _alloc) return; _align_in_bytes = alignment; if (_allocated_bytes >= total_allocated_size_in_bytes(dims)) { destruct_pixels(_view); create_view(dims, std::integral_constant<bool, IsPlanar>()); default_construct_pixels(_view); } else { image tmp(dims, alignment, alloc_in); swap(tmp); } } void recreate(x_coord_t width, y_coord_t height, std::size_t alignment, const Alloc alloc_in) { recreate(point_t(width, height), alignment, alloc_in); } void recreate(point_t const& dims, const Pixel& p_in, std::size_t alignment, const Alloc alloc_in) { if (dims == _view.dimensions() && _align_in_bytes == alignment && alloc_in == _alloc) return; _align_in_bytes = alignment; if (_allocated_bytes >= total_allocated_size_in_bytes(dims)) { destruct_pixels(_view); create_view(dims, std::integral_constant<bool, IsPlanar>()); uninitialized_fill_pixels(_view, p_in); } else { image tmp(dims, p_in, alignment, alloc_in); swap(tmp); } } void recreate(x_coord_t width, y_coord_t height, const Pixel& p_in, std::size_t alignment, const Alloc alloc_in ) { recreate(point_t(width, height), p_in, alignment, alloc_in); } view_t _view; // contains pointer to the pixels, the image size and ways to navigate pixels // for construction from other type template <typename P2, bool IP2, typename Alloc2> friend class image; private: unsigned char* _memory; std::size_t _align_in_bytes; allocator_type _alloc; std::size_t _allocated_bytes; void allocate_and_default_construct(point_t const& dimensions) { try { allocate_(dimensions, std::integral_constant<bool, IsPlanar>()); default_construct_pixels(_view); } catch (...) { deallocate(); throw; } } void allocate_and_fill(point_t const& dimensions, Pixel const& p_in) { try { allocate_(dimensions, std::integral_constant<bool, IsPlanar>()); uninitialized_fill_pixels(_view, p_in); } catch(...) { deallocate(); throw; } } template <typename View> void allocate_and_copy(point_t const& dimensions, View const& v) { try { allocate_(dimensions, std::integral_constant<bool, IsPlanar>()); uninitialized_copy_pixels(v, _view); } catch(...) { deallocate(); throw; } } void deallocate() { if (_memory && _allocated_bytes > 0) _alloc.deallocate(_memory, _allocated_bytes); } std::size_t is_planar_impl( std::size_t const size_in_units, std::size_t const channels_in_image, std::true_type) const { return size_in_units * channels_in_image; } std::size_t is_planar_impl( std::size_t const size_in_units, std::size_t const, std::false_type) const { return size_in_units; } std::size_t total_allocated_size_in_bytes(point_t const& dimensions) const { using x_iterator = typename view_t::x_iterator; // when value_type is a non-pixel, like int or float, num_channels< ... > doesn't work. constexpr std::size_t _channels_in_image = std::conditional < is_pixel<value_type>::value, num_channels<view_t>, std::integral_constant<std::size_t, 1> >::type::value; std::size_t size_in_units = is_planar_impl( get_row_size_in_memunits(dimensions.x) * dimensions.y, _channels_in_image, std::integral_constant<bool, IsPlanar>()); // return the size rounded up to the nearest byte return ( size_in_units + byte_to_memunit< x_iterator >::value - 1 ) / byte_to_memunit<x_iterator>::value + ( _align_in_bytes > 0 ? _align_in_bytes - 1 : 0 ); // add extra padding in case we need to align the first image pixel } std::size_t get_row_size_in_memunits(x_coord_t width) const { // number of units per row std::size_t size_in_memunits = width*memunit_step(typename view_t::x_iterator()); if (_align_in_bytes>0) { std::size_t alignment_in_memunits=_align_in_bytes*byte_to_memunit<typename view_t::x_iterator>::value; return align(size_in_memunits, alignment_in_memunits); } return size_in_memunits; } void allocate_(point_t const& dimensions, std::false_type) { // if it throws and _memory!=0 the client must deallocate _memory _allocated_bytes = total_allocated_size_in_bytes(dimensions); if (_allocated_bytes == 0) { return; } _memory=_alloc.allocate( _allocated_bytes ); unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory; _view=view_t(dimensions,typename view_t::locator(typename view_t::x_iterator(tmp), get_row_size_in_memunits(dimensions.x))); BOOST_ASSERT(_view.width() == dimensions.x); BOOST_ASSERT(_view.height() == dimensions.y); } void allocate_(point_t const& dimensions, std::true_type) { // if it throws and _memory!=0 the client must deallocate _memory std::size_t row_size=get_row_size_in_memunits(dimensions.x); std::size_t plane_size=row_size*dimensions.y; _allocated_bytes = total_allocated_size_in_bytes( dimensions ); if (_allocated_bytes == 0) { return; } _memory = _alloc.allocate( _allocated_bytes ); unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory; typename view_t::x_iterator first; for (std::size_t i = 0; i < num_channels<view_t>::value; ++i) { dynamic_at_c(first, i) = (typename channel_type<view_t>::type*)tmp; memunit_advance(dynamic_at_c(first, i), static_cast<std::ptrdiff_t>(plane_size * i)); } _view=view_t(dimensions, typename view_t::locator(first, row_size)); BOOST_ASSERT(_view.width() == dimensions.x); BOOST_ASSERT(_view.height() == dimensions.y); } void create_view(point_t const& dims, std::true_type) // is planar { std::size_t row_size=get_row_size_in_memunits(dims.x); std::size_t plane_size=row_size*dims.y; unsigned char* tmp = ( _align_in_bytes > 0 ) ? (unsigned char*) align( (std::size_t) _memory ,_align_in_bytes ) : _memory; typename view_t::x_iterator first; for (std::size_t i = 0; i < num_channels<view_t>::value; ++i) { dynamic_at_c(first, i) = (typename channel_type<view_t>::type*)tmp; memunit_advance(dynamic_at_c(first, i), static_cast<std::ptrdiff_t>(plane_size * i)); } _view = view_t(dims, typename view_t::locator(first, row_size)); BOOST_ASSERT(_view.width() == dims.x); BOOST_ASSERT(_view.height() == dims.y); } void create_view(point_t const& dims, std::false_type) // is planar { unsigned char* tmp = ( _align_in_bytes > 0 ) ? ( unsigned char* ) align( (std::size_t) _memory , _align_in_bytes ) : _memory; _view = view_t( dims , typename view_t::locator( typename view_t::x_iterator( tmp ) , get_row_size_in_memunits( dims.x ) ) ); BOOST_ASSERT(_view.width() == dims.x); BOOST_ASSERT(_view.height() == dims.y); } }; template <typename Pixel, bool IsPlanar, typename Alloc> void swap(image<Pixel, IsPlanar, Alloc>& im1,image<Pixel, IsPlanar, Alloc>& im2) { im1.swap(im2); } template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2> bool operator==(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) { if ((void*)(&im1)==(void*)(&im2)) return true; if (const_view(im1).dimensions()!=const_view(im2).dimensions()) return false; return equal_pixels(const_view(im1),const_view(im2)); } template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2> bool operator!=(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) {return !(im1==im2);} ///@{ /// \name view, const_view /// \brief Get an image view from an image /// \ingroup ImageModel /// \brief Returns the non-constant-pixel view of an image template <typename Pixel, bool IsPlanar, typename Alloc> inline auto view(image<Pixel,IsPlanar,Alloc>& img) -> typename image<Pixel,IsPlanar,Alloc>::view_t const& { return img._view; } /// \brief Returns the constant-pixel view of an image template <typename Pixel, bool IsPlanar, typename Alloc> inline auto const_view(const image<Pixel,IsPlanar,Alloc>& img) -> typename image<Pixel,IsPlanar,Alloc>::const_view_t const { return static_cast<const typename image<Pixel,IsPlanar,Alloc>::const_view_t>(img._view); } ///@} ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename Pixel, bool IsPlanar, typename Alloc> struct channel_type<image<Pixel, IsPlanar, Alloc>> : channel_type<Pixel> {}; template <typename Pixel, bool IsPlanar, typename Alloc> struct color_space_type<image<Pixel, IsPlanar, Alloc>> : color_space_type<Pixel> {}; template <typename Pixel, bool IsPlanar, typename Alloc> struct channel_mapping_type<image<Pixel, IsPlanar, Alloc>> : channel_mapping_type<Pixel> {}; template <typename Pixel, bool IsPlanar, typename Alloc> struct is_planar<image<Pixel, IsPlanar, Alloc>> : std::integral_constant<bool, IsPlanar> {}; }} // namespace boost::gil #endif