?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/gil.zip

???????
PK��p�[�]P ��virtual_locator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_VIRTUAL_LOCATOR_HPP #define BOOST_GIL_VIRTUAL_LOCATOR_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/position_iterator.hpp> #include <boost/assert.hpp> #include <boost/iterator/iterator_facade.hpp> namespace boost { namespace gil { /// \ingroup PixelLocatorModel PixelBasedModel /// \brief A 2D locator over a virtual image /// Upon dereferencing, invokes a given function object passing it its coordinates. /// Models: /// PixelLocatorConcept, /// HasDynamicXStepTypeConcept, /// HasDynamicYStepTypeConcept, /// HasTransposedTypeConcept /// /// \tparam DerefFn Function object that given a point returns a reference. /// Models PixelDereferenceAdaptorConcept. /// \tparam IsTransposed Indicates if locator should navigate in transposed mode. template <typename DerefFn, bool IsTransposed> class virtual_2d_locator : public pixel_2d_locator_base < virtual_2d_locator<DerefFn, IsTransposed>, position_iterator<DerefFn, IsTransposed>, position_iterator<DerefFn, 1-IsTransposed> > { using this_t = virtual_2d_locator<DerefFn, IsTransposed>; public: using parent_t = pixel_2d_locator_base < virtual_2d_locator<DerefFn, IsTransposed>, position_iterator<DerefFn, IsTransposed>, position_iterator<DerefFn, 1-IsTransposed> >; using const_t = virtual_2d_locator<typename DerefFn::const_t, IsTransposed>; using deref_fn_t = DerefFn; using point_t = typename parent_t::point_t; using coord_t = typename parent_t::coord_t; using x_coord_t = typename parent_t::x_coord_t; using y_coord_t = typename parent_t::y_coord_t; using x_iterator = typename parent_t::x_iterator; using y_iterator = typename parent_t::y_iterator; template <typename NewDerefFn> struct add_deref { using type = virtual_2d_locator<deref_compose<NewDerefFn, DerefFn>, IsTransposed>; static type make(this_t const& loc, NewDerefFn const& new_deref_fn) { return type(loc.pos(), loc.step(), deref_compose<NewDerefFn, DerefFn>(new_deref_fn, loc.deref_fn())); } }; virtual_2d_locator( point_t const& p = {0, 0}, point_t const& step = {1, 1}, deref_fn_t const& deref_fn = deref_fn_t()) : y_pos_(p, step, deref_fn) {} template <typename D, bool TR> virtual_2d_locator(virtual_2d_locator<D, TR> const &loc, coord_t y_step) : y_pos_(loc.pos(), point_t(loc.step().x, loc.step().y * y_step), loc.deref_fn()) {} template <typename D, bool TR> virtual_2d_locator(virtual_2d_locator<D, TR> const& loc, coord_t x_step, coord_t y_step, bool transpose = false) : y_pos_(loc.pos() , transpose ? point_t(loc.step().x * y_step, loc.step().y * x_step) : point_t(loc.step().x * x_step, loc.step().y * y_step) , loc.deref_fn()) { BOOST_ASSERT(transpose == (IsTransposed != TR)); } template <typename D, bool TR> virtual_2d_locator(virtual_2d_locator<D, TR> const& other) : y_pos_(other.y_pos_) {} virtual_2d_locator(virtual_2d_locator const& other) : y_pos_(other.y_pos_) {} virtual_2d_locator& operator=(virtual_2d_locator const& other) = default; bool operator==(const this_t& p) const { return y_pos_ == p.y_pos_; } auto x() -> x_iterator& { return gil_reinterpret_cast<x_iterator>(this); } auto x() const -> x_iterator const& { return gil_reinterpret_cast_c<x_iterator const>(this); } auto y() -> y_iterator& { return y_pos_; } auto y() const -> y_iterator const& { return y_pos_; } /// Returns the y distance between two x_iterators given the difference of their x positions auto y_distance_to(this_t const& it2, x_coord_t) const -> y_coord_t { return (it2.pos()[1 - IsTransposed] - pos()[1 - IsTransposed]) / step()[1 - IsTransposed]; } /// \todo TODO: is there no gap at the end of each row? /// i.e. can we use x_iterator to visit every pixel instead of nested loops? bool is_1d_traversable(x_coord_t) const { return false; } // Methods specific for virtual 2D locator auto pos() const -> point_t const& { return y_pos_.pos(); } auto step() const -> point_t const& { return y_pos_.step(); } auto deref_fn() const -> deref_fn_t const& { return y_pos_.deref_fn(); } private: template <typename D, bool TR> friend class virtual_2d_locator; y_iterator y_pos_; // current position, the step and the dereference object }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename D, bool TR> struct channel_type<virtual_2d_locator<D, TR>> : channel_type<typename virtual_2d_locator<D, TR>::parent_t> { }; template <typename D, bool TR> struct color_space_type<virtual_2d_locator<D, TR>> : color_space_type<typename virtual_2d_locator<D, TR>::parent_t> { }; template <typename D, bool TR> struct channel_mapping_type<virtual_2d_locator<D, TR>> : channel_mapping_type<typename virtual_2d_locator<D, TR>::parent_t> { }; template <typename D, bool TR> struct is_planar<virtual_2d_locator<D, TR>> : is_planar<typename virtual_2d_locator<D, TR>::parent_t> { }; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename D, bool TR> struct dynamic_x_step_type<virtual_2d_locator<D,TR>> { using type = virtual_2d_locator<D,TR>; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template <typename D, bool TR> struct dynamic_y_step_type<virtual_2d_locator<D,TR>> { using type = virtual_2d_locator<D,TR>; }; ///////////////////////////// // HasTransposedTypeConcept ///////////////////////////// template <typename D, bool IsTransposed> struct transposed_type<virtual_2d_locator<D,IsTransposed>> { using type = virtual_2d_locator<D,1-IsTransposed>; }; }} // namespace boost::gil #endif PK��p�[�[ bI��bI��locator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_LOCATOR_HPP #define BOOST_GIL_LOCATOR_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/gil/point.hpp> #include <boost/assert.hpp> #include <cstddef> namespace boost { namespace gil { /// Pixel 2D locator //forward declarations template <typename P> std::ptrdiff_t memunit_step(const P); template <typename P> P memunit_advanced(const P* p, std::ptrdiff_t diff); template <typename P> P& memunit_advanced_ref(P* p, std::ptrdiff_t diff); template <typename Iterator, typename D> struct iterator_add_deref; template <typename T> class point; namespace detail { // helper class specialized for each axis of pixel_2d_locator template <std::size_t D, typename Loc> class locator_axis; } template <typename T> struct channel_type; template <typename T> struct color_space_type; template <typename T> struct channel_mapping_type; template <typename T> struct is_planar; template <typename T> struct num_channels; /// Base template for types that model HasTransposedTypeConcept. /// The type of a locator or a view that has X and Y swapped. /// By default it is the same. template <typename LocatorOrView> struct transposed_type { using type = LocatorOrView; }; /// \class pixel_2d_locator_base /// \brief base class for models of PixelLocatorConcept /// \ingroup PixelLocatorModel PixelBasedModel /// /// Pixel locator is similar to a pixel iterator, but allows for 2D navigation of pixels within an image view. /// It has a 2D difference_type and supports random access operations like: /// \code /// difference_type offset2(2,3); /// locator+=offset2; /// locator[offset2]=my_pixel; /// \endcode /// /// In addition, each coordinate acts as a random-access iterator that can be modified separately: /// "++locator.x()" or "locator.y()+=10" thereby moving the locator horizontally or vertically. /// /// It is called a locator because it doesn't implement the complete interface of a random access iterator. /// For example, increment and decrement operations don't make sense (no way to specify dimension). /// Also 2D difference between two locators cannot be computed without knowledge of the X position within the image. /// /// This base class provides most of the methods and type aliases needed to create a model of a locator. GIL provides two /// locator models as subclasses of \p pixel_2d_locator_base. A memory-based locator, \p memory_based_2d_locator and a virtual /// locator, \p virtual_2d_locator. /// The minimum functionality a subclass must provide is this: /// \code /// class my_locator : public pixel_2d_locator_base<my_locator, ..., ...> { // supply the types for x-iterator and y-iterator /// using const_t = ...; // read-only locator /// /// template <typename Deref> struct add_deref { /// using type = ...; // locator that invokes the Deref dereference object upon pixel access /// static type make(const my_locator& loc, const Deref& d); /// }; /// /// my_locator(); /// my_locator(const my_locator& pl); /// /// // constructors with dynamic step in y (and x). Only valid for locators with dynamic steps /// my_locator(const my_locator& loc, coord_t y_step); /// my_locator(const my_locator& loc, coord_t x_step, coord_t y_step, bool transpose); /// /// bool operator==(const my_locator& p) const; /// /// // return _references_ to horizontal/vertical iterators. Advancing them moves this locator /// x_iterator& x(); /// y_iterator& y(); /// x_iterator const& x() const; /// y_iterator const& y() const; /// /// // return the vertical distance to another locator. Some models need the horizontal distance to compute it /// y_coord_t y_distance_to(const my_locator& loc2, x_coord_t xDiff) const; /// /// // return true iff incrementing an x-iterator located at the last column will position it at the first /// // column of the next row. Some models need the image width to determine that. /// bool is_1d_traversable(x_coord_t width) const; /// }; /// \endcode /// /// Models may choose to override some of the functions in the base class with more efficient versions. /// template <typename Loc, typename XIterator, typename YIterator> // The concrete subclass, the X-iterator and the Y-iterator class pixel_2d_locator_base { public: using x_iterator = XIterator; using y_iterator = YIterator; // aliasesrequired by ConstRandomAccessNDLocatorConcept static const std::size_t num_dimensions=2; using value_type = typename std::iterator_traits<x_iterator>::value_type; using reference = typename std::iterator_traits<x_iterator>::reference; // result of dereferencing using coord_t = typename std::iterator_traits<x_iterator>::difference_type; // 1D difference type (same for all dimensions) using difference_type = point<coord_t>; // result of operator-(locator,locator) using point_t = difference_type; template <std::size_t D> struct axis { using coord_t = typename detail::locator_axis<D,Loc>::coord_t; using iterator = typename detail::locator_axis<D,Loc>::iterator; }; // aliases required by ConstRandomAccess2DLocatorConcept using x_coord_t = typename point_t::template axis<0>::coord_t; using y_coord_t = typename point_t::template axis<1>::coord_t; bool operator!=(const Loc& p) const { return !(concrete()==p); } x_iterator x_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.x(); } x_iterator x_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp.x(); } y_iterator y_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.y(); } y_iterator y_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp.y(); } Loc xy_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp; } Loc xy_at(const difference_type& d) const { Loc tmp=concrete(); tmp+=d; return tmp; } template <std::size_t D> typename axis<D>::iterator& axis_iterator() { return detail::locator_axis<D,Loc>()(concrete()); } template <std::size_t D> typename axis<D>::iterator const& axis_iterator() const { return detail::locator_axis<D,Loc>()(concrete()); } template <std::size_t D> typename axis<D>::iterator axis_iterator(const point_t& p) const { return detail::locator_axis<D,Loc>()(concrete(),p); } reference operator()(x_coord_t dx, y_coord_t dy) const { return x_at(dx,dy); } reference operator[](const difference_type& d) const { return x_at(d.x,d.y); } reference operator() const { return concrete().x(); } Loc& operator+=(const difference_type& d) { concrete().x()+=d.x; concrete().y()+=d.y; return concrete(); } Loc& operator-=(const difference_type& d) { concrete().x()-=d.x; concrete().y()-=d.y; return concrete(); } Loc operator+(const difference_type& d) const { return xy_at(d); } Loc operator-(const difference_type& d) const { return xy_at(-d); } // Some locators can cache 2D coordinates for faster subsequent access. By default there is no caching using cached_location_t = difference_type; cached_location_t cache_location(const difference_type& d) const { return d; } cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return difference_type(dx,dy); } private: Loc& concrete() { return (Loc&)this; } const Loc& concrete() const { return (const Loc&)this; } template <typename X> friend class pixel_2d_locator; }; // helper classes for each axis of pixel_2d_locator_base namespace detail { template <typename Loc> class locator_axis<0,Loc> { using point_t = typename Loc::point_t; public: using coord_t = typename point_t::template axis<0>::coord_t; using iterator = typename Loc::x_iterator; inline iterator& operator()( Loc& loc) const { return loc.x(); } inline iterator const& operator()(const Loc& loc) const { return loc.x(); } inline iterator operator()( Loc& loc, const point_t& d) const { return loc.x_at(d); } inline iterator operator()(const Loc& loc, const point_t& d) const { return loc.x_at(d); } }; template <typename Loc> class locator_axis<1,Loc> { using point_t = typename Loc::point_t; public: using coord_t = typename point_t::template axis<1>::coord_t; using iterator = typename Loc::y_iterator; inline iterator& operator()( Loc& loc) const { return loc.y(); } inline iterator const& operator()(const Loc& loc) const { return loc.y(); } inline iterator operator()( Loc& loc, const point_t& d) const { return loc.y_at(d); } inline iterator operator()(const Loc& loc, const point_t& d) const { return loc.y_at(d); } }; } template <typename Loc, typename XIt, typename YIt> struct channel_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct color_space_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public color_space_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct channel_mapping_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_mapping_type<XIt> {}; template <typename Loc, typename XIt, typename YIt> struct is_planar<pixel_2d_locator_base<Loc,XIt,YIt> > : public is_planar<XIt> {}; /// \class memory_based_2d_locator /// \brief Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept /// \ingroup PixelLocatorModel PixelBasedModel /// /// The class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis /// while its base iterator provides horizontal navigation. /// /// Each instantiation is optimal in terms of size and efficiency. /// For example, xy locator over interleaved rgb image results in a step iterator consisting of /// one std::ptrdiff_t for the row size and one native pointer (8 bytes total). ++locator.x() resolves to pointer /// increment. At the other extreme, a 2D navigation of the even pixels of a planar CMYK image results in a step /// iterator consisting of one std::ptrdiff_t for the doubled row size, and one step iterator consisting of /// one std::ptrdiff_t for the horizontal step of two and a CMYK planar_pixel_iterator consisting of 4 pointers (24 bytes). /// In this case ++locator.x() results in four native pointer additions. /// /// Note also that \p memory_based_2d_locator does not require that its element type be a pixel. It could be /// instantiated with an iterator whose \p value_type models only \p Regular. In this case the locator /// models the weaker RandomAccess2DLocatorConcept, and does not model PixelBasedConcept. /// Many generic algorithms don't require the elements to be pixels. //////////////////////////////////////////////////////////////////////////////////////// template <typename StepIterator> class memory_based_2d_locator : public pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> { using this_t = memory_based_2d_locator<StepIterator>; BOOST_GIL_CLASS_REQUIRE(StepIterator, boost::gil, StepIteratorConcept) public: using parent_t = pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator>; using const_t = memory_based_2d_locator<typename const_iterator_type<StepIterator>::type>; // same as this type, but over const values using coord_t = typename parent_t::coord_t; using x_coord_t = typename parent_t::x_coord_t; using y_coord_t = typename parent_t::y_coord_t; using x_iterator = typename parent_t::x_iterator; using y_iterator = typename parent_t::y_iterator; using difference_type = typename parent_t::difference_type; using reference = typename parent_t::reference; template <typename Deref> struct add_deref { using type = memory_based_2d_locator<typename iterator_add_deref<StepIterator,Deref>::type>; static type make(const memory_based_2d_locator<StepIterator>& loc, const Deref& nderef) { return type(iterator_add_deref<StepIterator,Deref>::make(loc.y(),nderef)); } }; memory_based_2d_locator() {} memory_based_2d_locator(const StepIterator& yit) : _p(yit) {} template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t y_step) : _p(loc.x(), loc.row_size()y_step) {} template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t x_step, coord_t y_step, bool transpose=false) : _p(make_step_iterator(loc.x(),(transpose ? loc.row_size() : loc.pixel_size())x_step), (transpose ? loc.pixel_size() : loc.row_size())y_step ) {} memory_based_2d_locator(x_iterator xit, std::ptrdiff_t row_bytes) : _p(xit,row_bytes) {} template <typename X> memory_based_2d_locator(const memory_based_2d_locator<X>& pl) : _p(pl._p) {} memory_based_2d_locator(const memory_based_2d_locator& pl) : _p(pl._p) {} memory_based_2d_locator& operator=(memory_based_2d_locator const& other) = default; bool operator==(const this_t& p) const { return _p==p._p; } x_iterator const& x() const { return _p.base(); } y_iterator const& y() const { return _p; } x_iterator& x() { return _p.base(); } y_iterator& y() { return _p; } // These are faster versions of functions already provided in the superclass x_iterator x_at (x_coord_t dx, y_coord_t dy) const { return memunit_advanced(x(), offset(dx,dy)); } x_iterator x_at (const difference_type& d) const { return memunit_advanced(x(), offset(d.x,d.y)); } this_t xy_at (x_coord_t dx, y_coord_t dy) const { return this_t(x_at( dx , dy ), row_size()); } this_t xy_at (const difference_type& d) const { return this_t(x_at( d.x, d.y), row_size()); } reference operator()(x_coord_t dx, y_coord_t dy) const { return memunit_advanced_ref(x(),offset(dx,dy)); } reference operator[](const difference_type& d) const { return memunit_advanced_ref(x(),offset(d.x,d.y)); } this_t& operator+=(const difference_type& d) { memunit_advance(x(),offset(d.x,d.y)); return this; } this_t& operator-=(const difference_type& d) { memunit_advance(x(),offset(-d.x,-d.y)); return this; } // Memory-based locators can have 1D caching of 2D relative coordinates using cached_location_t = std::ptrdiff_t; // type used to store relative location (to allow for more efficient repeated access) cached_location_t cache_location(const difference_type& d) const { return offset(d.x,d.y); } cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return offset(dx,dy); } reference operator[](const cached_location_t& loc) const { return memunit_advanced_ref(x(),loc); } // Only make sense for memory-based locators std::ptrdiff_t row_size() const { return memunit_step(y()); } // distance in mem units (bytes or bits) between adjacent rows std::ptrdiff_t pixel_size() const { return memunit_step(x()); } // distance in mem units (bytes or bits) between adjacent pixels on the same row bool is_1d_traversable(x_coord_t width) const { return row_size()-pixel_size()width==0; } // is there no gap at the end of each row? // Returns the vertical distance (it2.y-it1.y) between two x_iterators given the difference of their x positions std::ptrdiff_t y_distance_to(this_t const& p2, x_coord_t xDiff) const { std::ptrdiff_t rowDiff = memunit_distance(x(), p2.x()) - pixel_size() * xDiff; BOOST_ASSERT((rowDiff % row_size()) == 0); return rowDiff / row_size(); } private: template <typename X> friend class memory_based_2d_locator; std::ptrdiff_t offset(x_coord_t x, y_coord_t y) const { return yrow_size() + xpixel_size(); } StepIterator _p; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename SI> struct color_space_type<memory_based_2d_locator<SI> > : public color_space_type<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct channel_mapping_type<memory_based_2d_locator<SI> > : public channel_mapping_type<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct is_planar<memory_based_2d_locator<SI> > : public is_planar<typename memory_based_2d_locator<SI>::parent_t> { }; template <typename SI> struct channel_type<memory_based_2d_locator<SI> > : public channel_type<typename memory_based_2d_locator<SI>::parent_t> { }; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// // Take the base iterator of SI (which is typically a step iterator) and change it to have a step in x template <typename SI> struct dynamic_x_step_type<memory_based_2d_locator<SI> > { private: using base_iterator_t = typename iterator_adaptor_get_base<SI>::type; using base_iterator_step_t = typename dynamic_x_step_type<base_iterator_t>::type; using dynamic_step_base_t = typename iterator_adaptor_rebind<SI, base_iterator_step_t>::type; public: using type = memory_based_2d_locator<dynamic_step_base_t>; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template <typename SI> struct dynamic_y_step_type<memory_based_2d_locator<SI> > { using type = memory_based_2d_locator<SI>; }; } } // namespace boost::gil #endif PK��p�[�f%K'��K'��planar_pixel_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_PLANAR_PIXEL_ITERATOR_HPP #define BOOST_GIL_PLANAR_PIXEL_ITERATOR_HPP #include <boost/gil/pixel.hpp> #include <boost/gil/step_iterator.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/iterator/iterator_facade.hpp> #include <iterator> #include <type_traits> namespace boost { namespace gil { //forward declaration (as this file is included in planar_pixel_reference.hpp) template <typename ChannelReference, typename ColorSpace> struct planar_pixel_reference; /// \defgroup ColorBaseModelPlanarPtr planar_pixel_iterator /// \ingroup ColorBaseModel /// \brief A homogeneous color base whose element is a channel iterator. Models HomogeneousColorBaseValueConcept /// This class is used as an iterator to a planar pixel. /// \defgroup PixelIteratorModelPlanarPtr planar_pixel_iterator /// \ingroup PixelIteratorModel /// \brief An iterator over planar pixels. Models PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept //////////////////////////////////////////////////////////////////////////////////////// /// \brief An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept /// /// Planar pixels have channel data that is not consecutive in memory. /// To abstract this we use classes to represent references and pointers to planar pixels. /// /// \ingroup PixelIteratorModelPlanarPtr ColorBaseModelPlanarPtr PixelBasedModel template <typename ChannelPtr, typename ColorSpace> struct planar_pixel_iterator : iterator_facade < planar_pixel_iterator<ChannelPtr, ColorSpace>, pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace>>, std::random_access_iterator_tag, planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference, ColorSpace> const >, detail::homogeneous_color_base < ChannelPtr, layout<ColorSpace>, mp11::mp_size<ColorSpace>::value > { private: using parent_t = iterator_facade < planar_pixel_iterator<ChannelPtr, ColorSpace>, pixel<typename std::iterator_traits<ChannelPtr>::value_type,layout<ColorSpace>>, std::random_access_iterator_tag, planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference, ColorSpace> const >; using color_base_parent_t = detail::homogeneous_color_base < ChannelPtr, layout<ColorSpace>, mp11::mp_size<ColorSpace>::value >; using channel_t = typename std::iterator_traits<ChannelPtr>::value_type; public: using value_type = typename parent_t::value_type; using reference = typename parent_t::reference; using difference_type = typename parent_t::difference_type; planar_pixel_iterator() : color_base_parent_t(0) {} planar_pixel_iterator(bool) {} // constructor that does not fill with zero (for performance) planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1) : color_base_parent_t(v0,v1) {} planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2) : color_base_parent_t(v0,v1,v2) {} planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3) : color_base_parent_t(v0,v1,v2,v3) {} planar_pixel_iterator(const ChannelPtr& v0, const ChannelPtr& v1, const ChannelPtr& v2, const ChannelPtr& v3, const ChannelPtr& v4) : color_base_parent_t(v0,v1,v2,v3,v4) {} template <typename IC1,typename C1> planar_pixel_iterator(const planar_pixel_iterator<IC1,C1>& ptr) : color_base_parent_t(ptr) {} /// Copy constructor and operator= from pointers to compatible planar pixels or planar pixel references. /// That allow constructs like pointer = &value or pointer = &reference /// Since we should not override operator& that's the best we can do. template <typename P> planar_pixel_iterator(P* pix) : color_base_parent_t(pix, true) { function_requires<PixelsCompatibleConcept<P,value_type> >(); } struct address_of { template <typename T> T* operator()(T& t) { return &t; } }; template <typename P> planar_pixel_iterator& operator=(P* pix) { function_requires<PixelsCompatibleConcept<P,value_type> >(); static_transform(pix,this, address_of()); // PERFORMANCE_CHECK: Compare to this: //this->template semantic_at_c<0>()=&pix->template semantic_at_c<0>(); //this->template semantic_at_c<1>()=&pix->template semantic_at_c<1>(); //this->template semantic_at_c<2>()=&pix->template semantic_at_c<2>(); return this; } /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { return memunit_advanced_ref(this,dsizeof(channel_t));} reference operator->() const { return this; } // PERFORMANCE_CHECK: Remove? bool operator< (const planar_pixel_iterator& ptr) const { return gil::at_c<0>(this)< gil::at_c<0>(ptr); } bool operator!=(const planar_pixel_iterator& ptr) const { return gil::at_c<0>(this)!=gil::at_c<0>(ptr); } private: friend class boost::iterator_core_access; void increment() { static_transform(this,this,detail::inc<ChannelPtr>()); } void decrement() { static_transform(this,this,detail::dec<ChannelPtr>()); } void advance(std::ptrdiff_t d){ static_transform(this,this,std::bind(detail::plus_asymmetric<ChannelPtr,std::ptrdiff_t>(),std::placeholders::_1,d)); } reference dereference() const { return this->template deref<reference>(); } std::ptrdiff_t distance_to(const planar_pixel_iterator& it) const { return gil::at_c<0>(it)-gil::at_c<0>(this); } bool equal(const planar_pixel_iterator& it) const { return gil::at_c<0>(this)==gil::at_c<0>(it); } }; namespace detail { template <typename I> struct channel_iterator_is_mutable : std::true_type {}; template <typename I> struct channel_iterator_is_mutable<I const> : std::false_type {}; } // namespace detail template <typename IC, typename C> struct const_iterator_type<planar_pixel_iterator<IC,C> > { private: using channel_t = typename std::iterator_traits<IC>::value_type; public: using type = planar_pixel_iterator<typename channel_traits<channel_t>::const_pointer,C>; }; // The default implementation when the iterator is a C pointer is to use the standard constness semantics template <typename IC, typename C> struct iterator_is_mutable<planar_pixel_iterator<IC,C> > : public detail::channel_iterator_is_mutable<IC> {}; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template <typename IC, typename C, int K> struct kth_element_type<planar_pixel_iterator<IC, C>, K> { using type = IC; }; template <typename IC, typename C, int K> struct kth_element_reference_type<planar_pixel_iterator<IC, C>, K> : std::add_lvalue_reference<IC> {}; template <typename IC, typename C, int K> struct kth_element_const_reference_type<planar_pixel_iterator<IC, C>, K> : std::add_lvalue_reference<typename std::add_const<IC>::type> {}; ///////////////////////////// // HomogeneousPixelBasedConcept ///////////////////////////// template <typename IC, typename C> struct color_space_type<planar_pixel_iterator<IC,C>> { using type = C; }; template <typename IC, typename C> struct channel_mapping_type<planar_pixel_iterator<IC, C>> : channel_mapping_type<typename planar_pixel_iterator<IC,C>::value_type> {}; template <typename IC, typename C> struct is_planar<planar_pixel_iterator<IC, C>> : std::true_type {}; template <typename IC, typename C> struct channel_type<planar_pixel_iterator<IC, C>> { using type = typename std::iterator_traits<IC>::value_type; }; ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template <typename IC, typename C> inline std::ptrdiff_t memunit_step(const planar_pixel_iterator<IC,C>&) { return sizeof(typename std::iterator_traits<IC>::value_type); } template <typename IC, typename C> inline std::ptrdiff_t memunit_distance(const planar_pixel_iterator<IC,C>& p1, const planar_pixel_iterator<IC,C>& p2) { return memunit_distance(gil::at_c<0>(p1),gil::at_c<0>(p2)); } template <typename IC> struct memunit_advance_fn { memunit_advance_fn(std::ptrdiff_t diff) : _diff(diff) {} IC operator()(const IC& p) const { return memunit_advanced(p,_diff); } std::ptrdiff_t _diff; }; template <typename IC, typename C> inline void memunit_advance(planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) { static_transform(p, p, memunit_advance_fn<IC>(diff)); } template <typename IC, typename C> inline planar_pixel_iterator<IC,C> memunit_advanced(const planar_pixel_iterator<IC,C>& p, std::ptrdiff_t diff) { planar_pixel_iterator<IC,C> ret=p; memunit_advance(ret, diff); return ret; } template <typename ChannelPtr, typename ColorSpace> inline planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace> memunit_advanced_ref(const planar_pixel_iterator<ChannelPtr,ColorSpace>& ptr, std::ptrdiff_t diff) { return planar_pixel_reference<typename std::iterator_traits<ChannelPtr>::reference,ColorSpace>(ptr, diff); } ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename IC, typename C> struct dynamic_x_step_type<planar_pixel_iterator<IC,C> > { using type = memory_based_step_iterator<planar_pixel_iterator<IC,C>>; }; } } // namespace boost::gil #endif PK��p�[��g��concepts.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_HPP #define BOOST_GIL_CONCEPTS_HPP // TODO: Remove and prefer individual includes from boost/gil/concepts/.hpp? #include <boost/gil/concepts/channel.hpp> #include <boost/gil/concepts/color.hpp> #include <boost/gil/concepts/color_base.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/image.hpp> #include <boost/gil/concepts/image_view.hpp> #include <boost/gil/concepts/pixel.hpp> #include <boost/gil/concepts/pixel_based.hpp> #include <boost/gil/concepts/pixel_dereference.hpp> #include <boost/gil/concepts/pixel_iterator.hpp> #include <boost/gil/concepts/pixel_locator.hpp> #include <boost/gil/concepts/point.hpp> #endif PK��p�[� �� utilities.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_UTILITIES_HPP #define BOOST_GIL_UTILITIES_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/config.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wconversion" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_facade.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #include <algorithm> #include <cmath> #include <cstddef> #include <functional> #include <iterator> #include <utility> #include <type_traits> namespace boost { namespace gil { /// Various utilities not specific to the image library. /// Some are non-standard STL extensions or generic iterator adaptors //////////////////////////////////////////////////////////////////////////////// /// Rounding of real numbers / points to integers / integer points //////////////////////////////////////////////////////////////////////////////// inline std::ptrdiff_t iround(float x) { return static_cast<std::ptrdiff_t>(x + (x < 0.0f ? -0.5f : 0.5f)); } inline std::ptrdiff_t iround(double x) { return static_cast<std::ptrdiff_t>(x + (x < 0.0 ? -0.5 : 0.5)); } inline std::ptrdiff_t ifloor(float x) { return static_cast<std::ptrdiff_t>(std::floor(x)); } inline std::ptrdiff_t ifloor(double x) { return static_cast<std::ptrdiff_t>(std::floor(x)); } inline std::ptrdiff_t iceil(float x) { return static_cast<std::ptrdiff_t>(std::ceil(x)); } inline std::ptrdiff_t iceil(double x) { return static_cast<std::ptrdiff_t>(std::ceil(x)); } //////////////////////////////////////////////////////////////////////////////// /// computing size with alignment //////////////////////////////////////////////////////////////////////////////// template <typename T> inline T align(T val, std::size_t alignment) { return val+(alignment - val%alignment)%alignment; } /// \brief Helper base class for pixel dereference adaptors. /// \ingroup PixelDereferenceAdaptorModel /// template < typename ConstT, typename Value, typename Reference, typename ConstReference, typename ArgType, typename ResultType, bool IsMutable > struct deref_base { using argument_type = ArgType; using result_type = ResultType; using const_t = ConstT; using value_type = Value; using reference = Reference; using const_reference = ConstReference; static constexpr bool is_mutable = IsMutable; }; /// \brief Composes two dereference function objects. Similar to std::unary_compose but needs to pull some aliases from the component types. Models: PixelDereferenceAdaptorConcept /// \ingroup PixelDereferenceAdaptorModel /// template <typename D1, typename D2> class deref_compose : public deref_base < deref_compose<typename D1::const_t, typename D2::const_t>, typename D1::value_type, typename D1::reference, typename D1::const_reference, typename D2::argument_type, typename D1::result_type, D1::is_mutable && D2::is_mutable > { public: D1 _fn1; D2 _fn2; using argument_type = typename D2::argument_type; using result_type = typename D1::result_type; deref_compose() = default; deref_compose(const D1& x, const D2& y) : _fn1(x), _fn2(y) {} deref_compose(const deref_compose& dc) : _fn1(dc._fn1), _fn2(dc._fn2) {} template <typename _D1, typename _D2> deref_compose(const deref_compose<_D1,_D2>& dc) : _fn1(dc._fn1), _fn2(dc._fn2) {} result_type operator()(argument_type x) const { return _fn1(_fn2(x)); } result_type operator()(argument_type x) { return _fn1(_fn2(x)); } }; // reinterpret_cast is implementation-defined. Static cast is not. template <typename OutPtr, typename In> BOOST_FORCEINLINE OutPtr gil_reinterpret_cast(In p) { return static_cast<OutPtr>(static_cast<void>(p)); } template <typename OutPtr, typename In> BOOST_FORCEINLINE const OutPtr gil_reinterpret_cast_c(const In p) { return static_cast<const OutPtr>(static_cast<const void>(p)); } namespace detail { //////////////////////////////////////////////////////////////////////////////// /// \brief copy_n taken from SGI STL. //////////////////////////////////////////////////////////////////////////////// template <class InputIter, class Size, class OutputIter> std::pair<InputIter, OutputIter> _copy_n(InputIter first, Size count, OutputIter result, std::input_iterator_tag) { for ( ; count > 0; --count) { result = first; ++first; ++result; } return std::pair<InputIter, OutputIter>(first, result); } template <class RAIter, class Size, class OutputIter> inline std::pair<RAIter, OutputIter> _copy_n(RAIter first, Size count, OutputIter result, std::random_access_iterator_tag) { RAIter last = first + count; return std::pair<RAIter, OutputIter>(last, std::copy(first, last, result)); } template <class InputIter, class Size, class OutputIter> inline std::pair<InputIter, OutputIter> _copy_n(InputIter first, Size count, OutputIter result) { return _copy_n(first, count, result, typename std::iterator_traits<InputIter>::iterator_category()); } template <class InputIter, class Size, class OutputIter> inline std::pair<InputIter, OutputIter> copy_n(InputIter first, Size count, OutputIter result) { return detail::_copy_n(first, count, result); } /// \brief identity taken from SGI STL. template <typename T> struct identity { using argument_type = T; using result_type = T; const T& operator()(const T& val) const { return val; } }; /// \brief plus function object whose arguments may be of different type. template <typename T1, typename T2> struct plus_asymmetric { using first_argument_type = T1; using second_argument_type = T2; using result_type = T1; T1 operator()(T1 f1, T2 f2) const { return f1+f2; } }; /// \brief operator++ wrapped in a function object template <typename T> struct inc { using argument_type = T; using result_type = T; T operator()(T x) const { return ++x; } }; /// \brief operator-- wrapped in a function object template <typename T> struct dec { using argument_type = T; using result_type = T; T operator()(T x) const { return --x; } }; /// \brief Returns the index corresponding to the first occurrance of a given given type in // a given Boost.MP11-compatible list (or size if the type is not present) template <typename Types, typename T> struct type_to_index : mp11::mp_find<Types, T> { static_assert(mp11::mp_contains<Types, T>::value, "T should be element of Types"); }; } // namespace detail /// \ingroup ColorSpaceAndLayoutModel /// \brief Represents a color space and ordering of channels in memory template < typename ColorSpace, typename ChannelMapping = mp11::mp_iota < std::integral_constant<int, mp11::mp_size<ColorSpace>::value> > > struct layout { using color_space_t = ColorSpace; using channel_mapping_t = ChannelMapping; static_assert(mp11::mp_size<ColorSpace>::value > 0, "color space should not be empty sequence"); }; /// \brief A version of swap that also works with reference proxy objects /// Where value_type<T1> == value_type<T2> == Value template <typename Value, typename T1, typename T2> void swap_proxy(T1& left, T2& right) { Value tmp = left; left = right; right = tmp; } /// \brief Run-time detection of whether the underlying architecture is little endian BOOST_FORCEINLINE bool little_endian() { short tester = 0x0001; return (char)&tester!=0; } /// \brief Run-time detection of whether the underlying architecture is big endian BOOST_FORCEINLINE bool big_endian() { return !little_endian(); } }} // namespace boost::gil #endif PK��p�[�_��7��7��step_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_STEP_ITERATOR_HPP #define BOOST_GIL_STEP_ITERATOR_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/gil/pixel_iterator_adaptor.hpp> #include <boost/gil/utilities.hpp> #include <boost/iterator/iterator_facade.hpp> #include <cstddef> #include <iterator> #include <type_traits> namespace boost { namespace gil { /// \defgroup PixelIteratorModelStepPtr step iterators /// \ingroup PixelIteratorModel /// \brief Iterators that allow for specifying the step between two adjacent values namespace detail { /// \ingroup PixelIteratorModelStepPtr /// \brief An adaptor over an existing iterator that changes the step unit /// /// (i.e. distance(it,it+1)) by a given predicate. Instead of calling base's /// operators ++, --, +=, -=, etc. the adaptor is using the passed policy object SFn /// for advancing and for computing the distance between iterators. template <typename Derived, // type of the derived class typename Iterator, // Models Iterator typename SFn> // A policy object that can compute the distance between two iterators of type Iterator // and can advance an iterator of type Iterator a given number of Iterator's units class step_iterator_adaptor : public iterator_adaptor<Derived, Iterator, use_default, use_default, use_default, typename SFn::difference_type> { public: using parent_t = iterator_adaptor<Derived, Iterator, use_default, use_default, use_default, typename SFn::difference_type>; using base_difference_type = typename std::iterator_traits<Iterator>::difference_type; using difference_type = typename SFn::difference_type; using reference = typename std::iterator_traits<Iterator>::reference; step_iterator_adaptor() {} step_iterator_adaptor(const Iterator& it, SFn step_fn=SFn()) : parent_t(it), _step_fn(step_fn) {} difference_type step() const { return _step_fn.step(); } protected: SFn _step_fn; private: friend class boost::iterator_core_access; void increment() { _step_fn.advance(this->base_reference(),1); } void decrement() { _step_fn.advance(this->base_reference(),-1); } void advance(base_difference_type d) { _step_fn.advance(this->base_reference(),d); } difference_type distance_to(const step_iterator_adaptor& it) const { return _step_fn.difference(this->base_reference(),it.base_reference()); } }; // although iterator_adaptor defines these, the default implementation computes distance and compares for zero. // it is often faster to just apply the relation operator to the base template <typename D,typename Iterator,typename SFn> inline bool operator>(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.step()>0 ? p1.base()> p2.base() : p1.base()< p2.base(); } template <typename D,typename Iterator,typename SFn> inline bool operator<(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.step()>0 ? p1.base()< p2.base() : p1.base()> p2.base(); } template <typename D,typename Iterator,typename SFn> inline bool operator>=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.step()>0 ? p1.base()>=p2.base() : p1.base()<=p2.base(); } template <typename D,typename Iterator,typename SFn> inline bool operator<=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.step()>0 ? p1.base()<=p2.base() : p1.base()>=p2.base(); } template <typename D,typename Iterator,typename SFn> inline bool operator==(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.base()==p2.base(); } template <typename D,typename Iterator,typename SFn> inline bool operator!=(const step_iterator_adaptor<D,Iterator,SFn>& p1, const step_iterator_adaptor<D,Iterator,SFn>& p2) { return p1.base()!=p2.base(); } } // namespace detail //////////////////////////////////////////////////////////////////////////////////////// /// MEMORY-BASED STEP ITERATOR //////////////////////////////////////////////////////////////////////////////////////// /// \class memory_based_step_iterator /// \ingroup PixelIteratorModelStepPtr PixelBasedModel /// \brief Iterator with dynamically specified step in memory units (bytes or bits). Models StepIteratorConcept, IteratorAdaptorConcept, MemoryBasedIteratorConcept, PixelIteratorConcept, HasDynamicXStepTypeConcept /// /// A refinement of step_iterator_adaptor that uses a dynamic parameter for the step /// which is specified in memory units, such as bytes or bits /// /// Pixel step iterators are used to provide iteration over non-adjacent pixels. /// Common use is a vertical traversal, where the step is the row stride. /// /// Another application is as a sub-channel view. For example, a red intensity image over /// interleaved RGB data would use a step iterator adaptor with step sizeof(channel_t)3 /// In the latter example the step size could be fixed at compile time for efficiency. /// Compile-time fixed step can be implemented by providing a step function object that takes the step as a template //////////////////////////////////////////////////////////////////////////////////////// /// \ingroup PixelIteratorModelStepPtr /// \brief function object that returns the memory unit distance between two iterators and advances a given iterator a given number of mem units (bytes or bits) template <typename Iterator> struct memunit_step_fn { using difference_type = std::ptrdiff_t; memunit_step_fn(difference_type step=memunit_step(Iterator())) : _step(step) {} difference_type difference(const Iterator& it1, const Iterator& it2) const { return memunit_distance(it1,it2)/_step; } void advance(Iterator& it, difference_type d) const { memunit_advance(it,d_step); } difference_type step() const { return _step; } void set_step(std::ptrdiff_t step) { _step=step; } private: BOOST_GIL_CLASS_REQUIRE(Iterator, boost::gil, MemoryBasedIteratorConcept) difference_type _step; }; template <typename Iterator> class memory_based_step_iterator : public detail::step_iterator_adaptor<memory_based_step_iterator<Iterator>, Iterator, memunit_step_fn<Iterator>> { BOOST_GIL_CLASS_REQUIRE(Iterator, boost::gil, MemoryBasedIteratorConcept) public: using parent_t = detail::step_iterator_adaptor<memory_based_step_iterator<Iterator>, Iterator, memunit_step_fn<Iterator>>; using reference = typename parent_t::reference; using difference_type = typename parent_t::difference_type; using x_iterator = Iterator; memory_based_step_iterator() : parent_t(Iterator()) {} memory_based_step_iterator(Iterator it, std::ptrdiff_t memunit_step) : parent_t(it, memunit_step_fn<Iterator>(memunit_step)) {} template <typename I2> memory_based_step_iterator(const memory_based_step_iterator<I2>& it) : parent_t(it.base(), memunit_step_fn<Iterator>(it.step())) {} /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { return (this+d); } void set_step(std::ptrdiff_t memunit_step) { this->_step_fn.set_step(memunit_step); } x_iterator& base() { return parent_t::base_reference(); } x_iterator const& base() const { return parent_t::base_reference(); } }; template <typename Iterator> struct const_iterator_type<memory_based_step_iterator<Iterator>> { using type = memory_based_step_iterator<typename const_iterator_type<Iterator>::type>; }; template <typename Iterator> struct iterator_is_mutable<memory_based_step_iterator<Iterator>> : public iterator_is_mutable<Iterator> {}; ///////////////////////////// // IteratorAdaptorConcept ///////////////////////////// template <typename Iterator> struct is_iterator_adaptor<memory_based_step_iterator<Iterator>> : std::true_type {}; template <typename Iterator> struct iterator_adaptor_get_base<memory_based_step_iterator<Iterator>> { using type = Iterator; }; template <typename Iterator, typename NewBaseIterator> struct iterator_adaptor_rebind<memory_based_step_iterator<Iterator>, NewBaseIterator> { using type = memory_based_step_iterator<NewBaseIterator>; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename Iterator> struct color_space_type<memory_based_step_iterator<Iterator>> : public color_space_type<Iterator> {}; template <typename Iterator> struct channel_mapping_type<memory_based_step_iterator<Iterator>> : public channel_mapping_type<Iterator> {}; template <typename Iterator> struct is_planar<memory_based_step_iterator<Iterator>> : public is_planar<Iterator> {}; template <typename Iterator> struct channel_type<memory_based_step_iterator<Iterator>> : public channel_type<Iterator> {}; ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template <typename Iterator> struct byte_to_memunit<memory_based_step_iterator<Iterator>> : public byte_to_memunit<Iterator> {}; template <typename Iterator> inline std::ptrdiff_t memunit_step(const memory_based_step_iterator<Iterator>& p) { return p.step(); } template <typename Iterator> inline std::ptrdiff_t memunit_distance(const memory_based_step_iterator<Iterator>& p1, const memory_based_step_iterator<Iterator>& p2) { return memunit_distance(p1.base(),p2.base()); } template <typename Iterator> inline void memunit_advance(memory_based_step_iterator<Iterator>& p, std::ptrdiff_t diff) { memunit_advance(p.base(), diff); } template <typename Iterator> inline memory_based_step_iterator<Iterator> memunit_advanced(const memory_based_step_iterator<Iterator>& p, std::ptrdiff_t diff) { return memory_based_step_iterator<Iterator>(memunit_advanced(p.base(), diff),p.step()); } template <typename Iterator> inline typename std::iterator_traits<Iterator>::reference memunit_advanced_ref(const memory_based_step_iterator<Iterator>& p, std::ptrdiff_t diff) { return memunit_advanced_ref(p.base(), diff); } ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename Iterator> struct dynamic_x_step_type<memory_based_step_iterator<Iterator>> { using type = memory_based_step_iterator<Iterator>; }; // For step iterators, pass the function object to the base template <typename Iterator, typename Deref> struct iterator_add_deref<memory_based_step_iterator<Iterator>,Deref> { BOOST_GIL_CLASS_REQUIRE(Deref, boost::gil, PixelDereferenceAdaptorConcept) using type = memory_based_step_iterator<typename iterator_add_deref<Iterator, Deref>::type>; static type make(const memory_based_step_iterator<Iterator>& it, const Deref& d) { return type(iterator_add_deref<Iterator, Deref>::make(it.base(),d),it.step()); } }; //////////////////////////////////////////////////////////////////////////////////////// /// make_step_iterator //////////////////////////////////////////////////////////////////////////////////////// template <typename I> typename dynamic_x_step_type<I>::type make_step_iterator(const I& it, std::ptrdiff_t step); namespace detail { // if the iterator is a plain base iterator (non-adaptor), wraps it in memory_based_step_iterator template <typename I> auto make_step_iterator_impl(I const& it, std::ptrdiff_t step, std::false_type) -> typename dynamic_x_step_type<I>::type { return memory_based_step_iterator<I>(it, step); } // If the iterator is compound, put the step in its base template <typename I> auto make_step_iterator_impl(I const& it, std::ptrdiff_t step, std::true_type) -> typename dynamic_x_step_type<I>::type { return make_step_iterator(it.base(), step); } // If the iterator is memory_based_step_iterator, change the step template <typename BaseIt> auto make_step_iterator_impl( memory_based_step_iterator<BaseIt> const& it, std::ptrdiff_t step, std::true_type) -> memory_based_step_iterator<BaseIt> { return memory_based_step_iterator<BaseIt>(it.base(), step); } } // namespace detail /// \brief Constructs a step iterator from a base iterator and a step. /// /// To construct a step iterator from a given iterator Iterator and a given step, if Iterator does not /// already have a dynamic step, we wrap it in a memory_based_step_iterator. Otherwise we /// do a compile-time traversal of the chain of iterator adaptors to locate the step iterator /// and then set it step to the new one. /// /// The step iterator of Iterator is not always memory_based_step_iterator<Iterator>. For example, Iterator may /// already be a memory_based_step_iterator, in which case it will be inefficient to stack them; /// we can obtain the same result by multiplying their steps. Note that for Iterator to be a /// step iterator it does not necessarily have to have the form memory_based_step_iterator<J>. /// The step iterator can be wrapped inside another iterator. Also, it may not have the /// type memory_based_step_iterator, but it could be a user-provided type. template <typename I> // Models MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept typename dynamic_x_step_type<I>::type make_step_iterator(const I& it, std::ptrdiff_t step) { return detail::make_step_iterator_impl(it, step, typename is_iterator_adaptor<I>::type()); } }} // namespace boost::gil #endif PK��p�[��t��t��color_base_algorithm.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_COLOR_BASE_ALGORITHM_HPP #define BOOST_GIL_COLOR_BASE_ALGORITHM_HPP #include <boost/gil/concepts.hpp> #include <boost/gil/utilities.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/config.hpp> #include <algorithm> #include <type_traits> namespace boost { namespace gil { /////////////////////////////////////// /// size: Semantic channel size /////////////////////////////////////// /* \defgroup ColorBaseAlgorithmSize size \ingroup ColorBaseAlgorithm \brief Returns an integral constant type specifying the number of elements in a color base Example: \code static_assert(size<rgb8_pixel_t>::value == 3, ""); static_assert(size<cmyk8_planar_ptr_t>::value == 4, ""); \endcode / /// \brief Returns an integral constant type specifying the number of elements in a color base /// \ingroup ColorBaseAlgorithmSize template <typename ColorBase> struct size : public mp11::mp_size<typename ColorBase::layout_t::color_space_t> {}; /////////////////////////////////////// /// semantic_at_c: Semantic channel accessors /////////////////////////////////////// /* \defgroup ColorBaseAlgorithmSemanticAtC kth_semantic_element_type, kth_semantic_element_reference_type, kth_semantic_element_const_reference_type, semantic_at_c \ingroup ColorBaseAlgorithm \brief Support for accessing the elements of a color base by semantic index The semantic index of an element is the index of its color in the color space. Semantic indexing allows for proper pairing of elements of color bases independent on their layout. For example, red is the first semantic element of a color base regardless of whether it has an RGB layout or a BGR layout. All GIL color base algorithms taking multiple color bases use semantic indexing to access their elements. Example: \code // 16-bit BGR pixel, 4 bits for the blue, 3 bits for the green, 2 bits for the red channel and 7 unused bits using bgr432_pixel_t = packed_pixel_type<uint16_t, mp11::mp_list_c<unsigned,4,3,2>, bgr_layout_t>::type; // A reference to its red channel. Although the red channel is the third, its semantic index is 0 in the RGB color space using red_channel_reference_t = kth_semantic_element_reference_type<bgr432_pixel_t, 0>::type; // Initialize the pixel to black bgr432_pixel_t red_pixel(0,0,0); // Set the red channel to 100% red_channel_reference_t red_channel = semantic_at_c<0>(red_pixel); red_channel = channel_traits<red_channel_reference_t>::max_value(); \endcode / /// \brief Specifies the type of the K-th semantic element of a color base /// \ingroup ColorBaseAlgorithmSemanticAtC template <typename ColorBase, int K> struct kth_semantic_element_type { using channel_mapping_t = typename ColorBase::layout_t::channel_mapping_t; static_assert(K < mp11::mp_size<channel_mapping_t>::value, "K index should be less than size of channel_mapping_t sequence"); static constexpr int semantic_index = mp11::mp_at_c<channel_mapping_t, K>::type::value; using type = typename kth_element_type<ColorBase, semantic_index>::type; }; /// \brief Specifies the return type of the mutable semantic_at_c<K>(color_base); /// \ingroup ColorBaseAlgorithmSemanticAtC template <typename ColorBase, int K> struct kth_semantic_element_reference_type { using channel_mapping_t = typename ColorBase::layout_t::channel_mapping_t; static_assert(K < mp11::mp_size<channel_mapping_t>::value, "K index should be less than size of channel_mapping_t sequence"); static constexpr int semantic_index = mp11::mp_at_c<channel_mapping_t, K>::type::value; using type = typename kth_element_reference_type<ColorBase, semantic_index>::type; static type get(ColorBase& cb) { return gil::at_c<semantic_index>(cb); } }; /// \brief Specifies the return type of the constant semantic_at_c<K>(color_base); /// \ingroup ColorBaseAlgorithmSemanticAtC template <typename ColorBase, int K> struct kth_semantic_element_const_reference_type { using channel_mapping_t = typename ColorBase::layout_t::channel_mapping_t; static_assert(K < mp11::mp_size<channel_mapping_t>::value, "K index should be less than size of channel_mapping_t sequence"); static constexpr int semantic_index = mp11::mp_at_c<channel_mapping_t, K>::type::value; using type = typename kth_element_const_reference_type<ColorBase,semantic_index>::type; static type get(const ColorBase& cb) { return gil::at_c<semantic_index>(cb); } }; /// \brief A mutable accessor to the K-th semantic element of a color base /// \ingroup ColorBaseAlgorithmSemanticAtC template <int K, typename ColorBase> inline auto semantic_at_c(ColorBase& p) -> typename std::enable_if < !std::is_const<ColorBase>::value, typename kth_semantic_element_reference_type<ColorBase, K>::type >::type { return kth_semantic_element_reference_type<ColorBase, K>::get(p); } /// \brief A constant accessor to the K-th semantic element of a color base /// \ingroup ColorBaseAlgorithmSemanticAtC template <int K, typename ColorBase> inline auto semantic_at_c(ColorBase const& p) -> typename kth_semantic_element_const_reference_type<ColorBase, K>::type { return kth_semantic_element_const_reference_type<ColorBase, K>::get(p); } /////////////////////////////////////// /// get_color: Named channel accessors /////////////////////////////////////// /* \defgroup ColorBaseAlgorithmColor color_element_type, color_element_reference_type, color_element_const_reference_type, get_color, contains_color \ingroup ColorBaseAlgorithm \brief Support for accessing the elements of a color base by color name Example: A function that takes a generic pixel containing a red channel and sets it to 100%: \code template <typename Pixel> void set_red_to_max(Pixel& pixel) { boost::function_requires<MutablePixelConcept<Pixel> >(); static_assert(contains_color<Pixel, red_t>::value, ""); using red_channel_t = typename color_element_type<Pixel, red_t>::type; get_color(pixel, red_t()) = channel_traits<red_channel_t>::max_value(); } \endcode / /// \brief A predicate metafunction determining whether a given color base contains a given color /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> struct contains_color : mp11::mp_contains<typename ColorBase::layout_t::color_space_t, Color> {}; template <typename ColorBase, typename Color> struct color_index_type : public detail::type_to_index<typename ColorBase::layout_t::color_space_t,Color> {}; /// \brief Specifies the type of the element associated with a given color tag /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> struct color_element_type : public kth_semantic_element_type<ColorBase,color_index_type<ColorBase,Color>::value> {}; /// \brief Specifies the return type of the mutable element accessor by color name, get_color(color_base, Color()); /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> struct color_element_reference_type : public kth_semantic_element_reference_type<ColorBase,color_index_type<ColorBase,Color>::value> {}; /// \brief Specifies the return type of the constant element accessor by color name, get_color(color_base, Color()); /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> struct color_element_const_reference_type : public kth_semantic_element_const_reference_type<ColorBase,color_index_type<ColorBase,Color>::value> {}; /// \brief Mutable accessor to the element associated with a given color name /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> typename color_element_reference_type<ColorBase,Color>::type get_color(ColorBase& cb, Color=Color()) { return color_element_reference_type<ColorBase,Color>::get(cb); } /// \brief Constant accessor to the element associated with a given color name /// \ingroup ColorBaseAlgorithmColor template <typename ColorBase, typename Color> typename color_element_const_reference_type<ColorBase,Color>::type get_color(const ColorBase& cb, Color=Color()) { return color_element_const_reference_type<ColorBase,Color>::get(cb); } /////////////////////////////////////// /// /// element_type, element_reference_type, element_const_reference_type: Support for homogeneous color bases /// /////////////////////////////////////// /* \defgroup ColorBaseAlgorithmHomogeneous element_type, element_reference_type, element_const_reference_type \ingroup ColorBaseAlgorithm \brief Types for homogeneous color bases Example: \code using element_t = element_type<rgb8c_planar_ptr_t>::type; static_assert(std::is_same<element_t, const uint8_t>::value, ""); \endcode / /// \brief Specifies the element type of a homogeneous color base /// \ingroup ColorBaseAlgorithmHomogeneous template <typename ColorBase> struct element_type : public kth_element_type<ColorBase, 0> {}; /// \brief Specifies the return type of the mutable element accessor at_c of a homogeneous color base /// \ingroup ColorBaseAlgorithmHomogeneous template <typename ColorBase> struct element_reference_type : public kth_element_reference_type<ColorBase, 0> {}; /// \brief Specifies the return type of the constant element accessor at_c of a homogeneous color base /// \ingroup ColorBaseAlgorithmHomogeneous template <typename ColorBase> struct element_const_reference_type : public kth_element_const_reference_type<ColorBase, 0> {}; namespace detail { // compile-time recursion for per-element operations on color bases template <int N> struct element_recursion { #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wfloat-equal" #endif template <typename P1,typename P2> static bool static_equal(const P1& p1, const P2& p2) { return element_recursion<N-1>::static_equal(p1,p2) && semantic_at_c<N-1>(p1)==semantic_at_c<N-1>(p2); } template <typename P1,typename P2> static void static_copy(const P1& p1, P2& p2) { element_recursion<N-1>::static_copy(p1,p2); semantic_at_c<N-1>(p2)=semantic_at_c<N-1>(p1); } template <typename P,typename T2> static void static_fill(P& p, T2 v) { element_recursion<N-1>::static_fill(p,v); semantic_at_c<N-1>(p)=v; } template <typename Dst,typename Op> static void static_generate(Dst& dst, Op op) { element_recursion<N-1>::static_generate(dst,op); semantic_at_c<N-1>(dst)=op(); } #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif //static_for_each with one source template <typename P1,typename Op> static Op static_for_each(P1& p1, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,op)); op2(semantic_at_c<N-1>(p1)); return op2; } template <typename P1,typename Op> static Op static_for_each(const P1& p1, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,op)); op2(semantic_at_c<N-1>(p1)); return op2; } //static_for_each with two sources template <typename P1,typename P2,typename Op> static Op static_for_each(P1& p1, P2& p2, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2)); return op2; } template <typename P1,typename P2,typename Op> static Op static_for_each(P1& p1, const P2& p2, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2)); return op2; } template <typename P1,typename P2,typename Op> static Op static_for_each(const P1& p1, P2& p2, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2)); return op2; } template <typename P1,typename P2,typename Op> static Op static_for_each(const P1& p1, const P2& p2, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2)); return op2; } //static_for_each with three sources template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(P1& p1, P2& p2, P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(P1& p1, P2& p2, const P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(P1& p1, const P2& p2, P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(P1& p1, const P2& p2, const P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(const P1& p1, P2& p2, P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(const P1& p1, P2& p2, const P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(const P1& p1, const P2& p2, P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(const P1& p1, const P2& p2, const P3& p3, Op op) { Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op)); op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2), semantic_at_c<N-1>(p3)); return op2; } //static_transform with one source template <typename P1,typename Dst,typename Op> static Op static_transform(P1& src, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src)); return op2; } template <typename P1,typename Dst,typename Op> static Op static_transform(const P1& src, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src)); return op2; } //static_transform with two sources template <typename P1,typename P2,typename Dst,typename Op> static Op static_transform(P1& src1, P2& src2, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src1), semantic_at_c<N-1>(src2)); return op2; } template <typename P1,typename P2,typename Dst,typename Op> static Op static_transform(P1& src1, const P2& src2, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src1), semantic_at_c<N-1>(src2)); return op2; } template <typename P1,typename P2,typename Dst,typename Op> static Op static_transform(const P1& src1, P2& src2, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src1), semantic_at_c<N-1>(src2)); return op2; } template <typename P1,typename P2,typename Dst,typename Op> static Op static_transform(const P1& src1, const P2& src2, Dst& dst, Op op) { Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op)); semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src1), semantic_at_c<N-1>(src2)); return op2; } }; // Termination condition of the compile-time recursion for element operations on a color base template<> struct element_recursion<0> { //static_equal template <typename P1,typename P2> static bool static_equal(const P1&, const P2&) { return true; } //static_copy template <typename P1,typename P2> static void static_copy(const P1&, const P2&) {} //static_fill template <typename P, typename T2> static void static_fill(const P&, T2) {} //static_generate template <typename Dst,typename Op> static void static_generate(const Dst&,Op){} //static_for_each with one source template <typename P1,typename Op> static Op static_for_each(const P1&,Op op){return op;} //static_for_each with two sources template <typename P1,typename P2,typename Op> static Op static_for_each(const P1&,const P2&,Op op){return op;} //static_for_each with three sources template <typename P1,typename P2,typename P3,typename Op> static Op static_for_each(const P1&,const P2&,const P3&,Op op){return op;} //static_transform with one source template <typename P1,typename Dst,typename Op> static Op static_transform(const P1&,const Dst&,Op op){return op;} //static_transform with two sources template <typename P1,typename P2,typename Dst,typename Op> static Op static_transform(const P1&,const P2&,const Dst&,Op op){return op;} }; // std::min and std::max don't have the mutable overloads... template <typename Q> inline const Q& mutable_min(const Q& x, const Q& y) { return x<y ? x : y; } template <typename Q> inline Q& mutable_min( Q& x, Q& y) { return x<y ? x : y; } template <typename Q> inline const Q& mutable_max(const Q& x, const Q& y) { return x<y ? y : x; } template <typename Q> inline Q& mutable_max( Q& x, Q& y) { return x<y ? y : x; } // compile-time recursion for min/max element template <int N> struct min_max_recur { template <typename P> static typename element_const_reference_type<P>::type max_(const P& p) { return mutable_max(min_max_recur<N-1>::max_(p),semantic_at_c<N-1>(p)); } template <typename P> static typename element_reference_type<P>::type max_( P& p) { return mutable_max(min_max_recur<N-1>::max_(p),semantic_at_c<N-1>(p)); } template <typename P> static typename element_const_reference_type<P>::type min_(const P& p) { return mutable_min(min_max_recur<N-1>::min_(p),semantic_at_c<N-1>(p)); } template <typename P> static typename element_reference_type<P>::type min_( P& p) { return mutable_min(min_max_recur<N-1>::min_(p),semantic_at_c<N-1>(p)); } }; // termination condition of the compile-time recursion for min/max element template <> struct min_max_recur<1> { template <typename P> static typename element_const_reference_type<P>::type max_(const P& p) { return semantic_at_c<0>(p); } template <typename P> static typename element_reference_type<P>::type max_( P& p) { return semantic_at_c<0>(p); } template <typename P> static typename element_const_reference_type<P>::type min_(const P& p) { return semantic_at_c<0>(p); } template <typename P> static typename element_reference_type<P>::type min_( P& p) { return semantic_at_c<0>(p); } }; } // namespace detail /// \defgroup ColorBaseAlgorithmMinMax static_min, static_max /// \ingroup ColorBaseAlgorithm /// \brief Equivalents to std::min_element and std::max_element for homogeneous color bases /// /// Example: /// \code /// rgb8_pixel_t pixel(10,20,30); /// assert(pixel[2] == 30); /// static_max(pixel) = static_min(pixel); /// assert(pixel[2] == 10); /// \endcode /// \{ template <typename P> BOOST_FORCEINLINE typename element_const_reference_type<P>::type static_max(const P& p) { return detail::min_max_recur<size<P>::value>::max_(p); } template <typename P> BOOST_FORCEINLINE typename element_reference_type<P>::type static_max( P& p) { return detail::min_max_recur<size<P>::value>::max_(p); } template <typename P> BOOST_FORCEINLINE typename element_const_reference_type<P>::type static_min(const P& p) { return detail::min_max_recur<size<P>::value>::min_(p); } template <typename P> BOOST_FORCEINLINE typename element_reference_type<P>::type static_min( P& p) { return detail::min_max_recur<size<P>::value>::min_(p); } /// \} /// \defgroup ColorBaseAlgorithmEqual static_equal /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::equal. Pairs the elements semantically /// /// Example: /// \code /// rgb8_pixel_t rgb_red(255,0,0); /// bgr8_pixel_t bgr_red(0,0,255); /// assert(rgb_red[0]==255 && bgr_red[0]==0); /// /// assert(static_equal(rgb_red,bgr_red)); /// assert(rgb_red==bgr_red); // operator== invokes static_equal /// \endcode /// \{ template <typename P1,typename P2> BOOST_FORCEINLINE bool static_equal(const P1& p1, const P2& p2) { return detail::element_recursion<size<P1>::value>::static_equal(p1,p2); } /// \} /// \defgroup ColorBaseAlgorithmCopy static_copy /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::copy. Pairs the elements semantically /// /// Example: /// \code /// rgb8_pixel_t rgb_red(255,0,0); /// bgr8_pixel_t bgr_red; /// static_copy(rgb_red, bgr_red); // same as bgr_red = rgb_red /// /// assert(rgb_red[0] == 255 && bgr_red[0] == 0); /// assert(rgb_red == bgr_red); /// \endcode /// \{ template <typename Src,typename Dst> BOOST_FORCEINLINE void static_copy(const Src& src, Dst& dst) { detail::element_recursion<size<Dst>::value>::static_copy(src, dst); } /// \} /// \defgroup ColorBaseAlgorithmFill static_fill /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::fill. /// /// Example: /// \code /// rgb8_pixel_t p; /// static_fill(p, 10); /// assert(p == rgb8_pixel_t(10,10,10)); /// \endcode /// \{ template <typename P,typename V> BOOST_FORCEINLINE void static_fill(P& p, const V& v) { detail::element_recursion<size<P>::value>::static_fill(p,v); } /// \} /// \defgroup ColorBaseAlgorithmGenerate static_generate /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::generate. /// /// Example: Set each channel of a pixel to its semantic index. The channels must be assignable from an integer. /// \code /// struct consecutive_fn { /// int& _current; /// consecutive_fn(int& start) : _current(start) {} /// int operator()() { return _current++; } /// }; /// rgb8_pixel_t p; /// int start=0; /// static_generate(p, consecutive_fn(start)); /// assert(p == rgb8_pixel_t(0,1,2)); /// \endcode /// /// \{ template <typename P1,typename Op> BOOST_FORCEINLINE void static_generate(P1& dst,Op op) { detail::element_recursion<size<P1>::value>::static_generate(dst,op); } /// \} /// \defgroup ColorBaseAlgorithmTransform static_transform /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::transform. Pairs the elements semantically /// /// Example: Write a generic function that adds two pixels into a homogeneous result pixel. /// \code /// template <typename Result> /// struct my_plus { /// template <typename T1, typename T2> /// Result operator()(T1 f1, T2 f2) const { return f1+f2; } /// }; /// /// template <typename Pixel1, typename Pixel2, typename Pixel3> /// void sum_channels(const Pixel1& p1, const Pixel2& p2, Pixel3& result) { /// using result_channel_t = typename channel_type<Pixel3>::type; /// static_transform(p1,p2,result,my_plus<result_channel_t>()); /// } /// /// rgb8_pixel_t p1(1,2,3); /// bgr8_pixel_t p2(3,2,1); /// rgb8_pixel_t result; /// sum_channels(p1,p2,result); /// assert(result == rgb8_pixel_t(2,4,6)); /// \endcode /// \{ //static_transform with one source template <typename Src,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(Src& src,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(src,dst,op); } template <typename Src,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(const Src& src,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(src,dst,op); } //static_transform with two sources template <typename P2,typename P3,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(P2& p2,P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); } template <typename P2,typename P3,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(P2& p2,const P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); } template <typename P2,typename P3,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(const P2& p2,P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); } template <typename P2,typename P3,typename Dst,typename Op> BOOST_FORCEINLINE Op static_transform(const P2& p2,const P3& p3,Dst& dst,Op op) { return detail::element_recursion<size<Dst>::value>::static_transform(p2,p3,dst,op); } /// \} /// \defgroup ColorBaseAlgorithmForEach static_for_each /// \ingroup ColorBaseAlgorithm /// \brief Equivalent to std::for_each. Pairs the elements semantically /// /// Example: Use static_for_each to increment a planar pixel iterator /// \code /// struct increment { /// template <typename Incrementable> /// void operator()(Incrementable& x) const { ++x; } /// }; /// /// template <typename ColorBase> /// void increment_elements(ColorBase& cb) { /// static_for_each(cb, increment()); /// } /// /// uint8_t red[2], green[2], blue[2]; /// rgb8c_planar_ptr_t p1(red,green,blue); /// rgb8c_planar_ptr_t p2=p1; /// increment_elements(p1); /// ++p2; /// assert(p1 == p2); /// \endcode /// \{ //static_for_each with one source template <typename P1,typename Op> BOOST_FORCEINLINE Op static_for_each( P1& p1, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,op); } template <typename P1,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,op); } //static_for_each with two sources template <typename P1,typename P2,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1, P2& p2, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); } template <typename P1,typename P2,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1,const P2& p2, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); } template <typename P1,typename P2,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1, P2& p2, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); } template <typename P1,typename P2,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1,const P2& p2, Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); } //static_for_each with three sources template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1,P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1,P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1,const P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(P1& p1,const P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1,P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1,P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1,const P2& p2,P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } template <typename P1,typename P2,typename P3,typename Op> BOOST_FORCEINLINE Op static_for_each(const P1& p1,const P2& p2,const P3& p3,Op op) { return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,p3,op); } ///\} } } // namespace boost::gil #endif PK��p�[V��g4��g4��typedefs.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2018 Mateusz Loskot <mateusz@loskot.net> // // 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) // #ifndef BOOST_GIL_TYPEDEFS_HPP #define BOOST_GIL_TYPEDEFS_HPP #include <boost/gil/cmyk.hpp> #include <boost/gil/device_n.hpp> #include <boost/gil/gray.hpp> #include <boost/gil/point.hpp> #include <boost/gil/rgb.hpp> #include <boost/gil/rgba.hpp> #include <cstdint> #include <memory> // B - bits size/signedness, CM - channel model, CS - colour space, LAYOUT - pixel layout // Example: B = '8', CM = 'uint8_t', CS = 'bgr, LAYOUT='bgr_layout_t' #define BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT) \ template <typename, typename> struct pixel; \ template <typename, typename> struct planar_pixel_reference; \ template <typename, typename> struct planar_pixel_iterator; \ template <typename> class memory_based_step_iterator; \ template <typename> class point; \ template <typename> class memory_based_2d_locator; \ template <typename> class image_view; \ template <typename, bool, typename> class image; \ using CS##B##_pixel_t = pixel<CM, LAYOUT>; \ using CS##B##c_pixel_t = pixel<CM, LAYOUT> const; \ using CS##B##_ref_t = pixel<CM, LAYOUT>&; \ using CS##B##c_ref_t = pixel<CM, LAYOUT> const&; \ using CS##B##_ptr_t = CS##B##_pixel_t; \ using CS##B##c_ptr_t = CS##B##c_pixel_t; \ using CS##B##_step_ptr_t = memory_based_step_iterator<CS##B##_ptr_t>; \ using CS##B##c_step_ptr_t = memory_based_step_iterator<CS##B##c_ptr_t>; \ using CS##B##_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##_ptr_t>>; \ using CS##B##c_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_ptr_t>>; \ using CS##B##_step_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##_step_ptr_t>>; \ using CS##B##c_step_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_step_ptr_t>>; \ using CS##B##_view_t = image_view<CS##B##_loc_t>; \ using CS##B##c_view_t = image_view<CS##B##c_loc_t>; \ using CS##B##_step_view_t = image_view<CS##B##_step_loc_t>; \ using CS##B##c_step_view_t = image_view<CS##B##c_step_loc_t>; \ using CS##B##_image_t = image<CS##B##_pixel_t, false, std::allocator<unsigned char>>; // Example: B = '8', CM = 'uint8_t', CS = 'bgr' CS_FULL = 'rgb_t' LAYOUT='bgr_layout_t' #define BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS_FULL, LAYOUT) \ BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT) \ using CS##B##_planar_ref_t = planar_pixel_reference<CM&, CS_FULL>; \ using CS##B##c_planar_ref_t = planar_pixel_reference<CM const&, CS_FULL>; \ using CS##B##_planar_ptr_t = planar_pixel_iterator<CM, CS_FULL>; \ using CS##B##c_planar_ptr_t = planar_pixel_iterator<CM const, CS_FULL>; \ using CS##B##_planar_step_ptr_t = memory_based_step_iterator<CS##B##_planar_ptr_t>; \ using CS##B##c_planar_step_ptr_t \ = memory_based_step_iterator<CS##B##c_planar_ptr_t>; \ using CS##B##_planar_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_ptr_t>>; \ using CS##B##c_planar_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_ptr_t>>; \ using CS##B##_planar_step_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_step_ptr_t>>; \ using CS##B##c_planar_step_loc_t \ = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_step_ptr_t>>; \ using CS##B##_planar_view_t = image_view<CS##B##_planar_loc_t>; \ using CS##B##c_planar_view_t = image_view<CS##B##c_planar_loc_t>; \ using CS##B##_planar_step_view_t = image_view<CS##B##_planar_step_loc_t>; \ using CS##B##c_planar_step_view_t = image_view<CS##B##c_planar_step_loc_t>; \ using CS##B##_planar_image_t \ = image<CS##B##_pixel_t, true, std::allocator<unsigned char>>; #define BOOST_GIL_DEFINE_BASE_TYPEDEFS(B, CM, CS) \ BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, CS##_layout_t) #define BOOST_GIL_DEFINE_ALL_TYPEDEFS(B, CM, CS) \ BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS##_t, CS##_layout_t) namespace boost { namespace gil { // forward declarations template <typename B, typename Mn, typename Mx> struct scoped_channel_value; template <typename T> struct float_point_zero; template <typename T> struct float_point_one; ////////////////////////////////////////////////////////////////////////////////////////// /// Built-in channel models ////////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ChannelModel /// \brief 8-bit unsigned integral channel type (alias from uint8_t). Models ChannelValueConcept using std::uint8_t; /// \ingroup ChannelModel /// \brief 16-bit unsigned integral channel type (alias from uint16_t). Models ChannelValueConcept using std::uint16_t; /// \ingroup ChannelModel /// \brief 32-bit unsigned integral channel type (alias from uint32_t). Models ChannelValueConcept using std::uint32_t; /// \ingroup ChannelModel /// \brief 8-bit signed integral channel type (alias from int8_t). Models ChannelValueConcept using std::int8_t; /// \ingroup ChannelModel /// \brief 16-bit signed integral channel type (alias from int16_t). Models ChannelValueConcept using std::int16_t; /// \ingroup ChannelModel /// \brief 32-bit signed integral channel type (alias from int32_t). Models ChannelValueConcept using std::int32_t; /// \ingroup ChannelModel /// \brief 32-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept using float32_t = scoped_channel_value<float, float_point_zero<float>, float_point_one<float>>; /// \ingroup ChannelModel /// \brief 64-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept using float64_t = scoped_channel_value<double, float_point_zero<double>, float_point_one<double>>; BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, argb) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, abgr) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgra) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgra) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgb) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgba) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, cmyk) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, cmyk) template <int N> struct devicen_t; template <int N> struct devicen_layout_t; BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev2n, devicen_t<2>, devicen_layout_t<2>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev3n, devicen_t<3>, devicen_layout_t<3>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev4n, devicen_t<4>, devicen_layout_t<4>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev5n, devicen_t<5>, devicen_layout_t<5>) BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev5n, devicen_t<5>, devicen_layout_t<5>) }} // namespace boost::gil #endif PK��p�[��#��#��bit_aligned_pixel_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_BIT_ALIGNED_PIXEL_ITERATOR_HPP #define BOOST_GIL_BIT_ALIGNED_PIXEL_ITERATOR_HPP #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/config.hpp> #include <boost/iterator/iterator_facade.hpp> #include <functional> #include <type_traits> namespace boost { namespace gil { /// A model of a heterogeneous pixel that is not byte aligned. /// Examples are bitmap (1-bit pixels) or 6-bit RGB (222). /// \defgroup PixelIteratorNonAlignedPixelIterator bit_aligned_pixel_iterator /// \ingroup PixelIteratorModel /// \brief An iterator over non-byte-aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept //////////////////////////////////////////////////////////////////////////////////////// /// \brief An iterator over non-byte-aligned pixels. Models PixelIteratorConcept, PixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept /// /// An iterator over pixels that correspond to non-byte-aligned bit ranges. Examples of such pixels are single bit grayscale pixel, or a 6-bit RGB 222 pixel. /// /// \ingroup PixelIteratorNonAlignedPixelIterator PixelBasedModel template <typename NonAlignedPixelReference> struct bit_aligned_pixel_iterator : public iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>, typename NonAlignedPixelReference::value_type, std::random_access_iterator_tag, const NonAlignedPixelReference, typename NonAlignedPixelReference::bit_range_t::difference_type> { private: using parent_t = iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>, typename NonAlignedPixelReference::value_type, std::random_access_iterator_tag, const NonAlignedPixelReference, typename NonAlignedPixelReference::bit_range_t::difference_type>; template <typename Ref> friend struct bit_aligned_pixel_iterator; using bit_range_t = typename NonAlignedPixelReference::bit_range_t; public: using difference_type = typename parent_t::difference_type; using reference = typename parent_t::reference; bit_aligned_pixel_iterator() {} bit_aligned_pixel_iterator(const bit_aligned_pixel_iterator& p) : _bit_range(p._bit_range) {} bit_aligned_pixel_iterator& operator=(const bit_aligned_pixel_iterator& p) { _bit_range=p._bit_range; return this; } template <typename Ref> bit_aligned_pixel_iterator(const bit_aligned_pixel_iterator<Ref>& p) : _bit_range(p._bit_range) {} bit_aligned_pixel_iterator(reference ref) : _bit_range(ref->bit_range()) {} explicit bit_aligned_pixel_iterator(typename bit_range_t::byte_t* data, int bit_offset=0) : _bit_range(data,bit_offset) {} /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { bit_aligned_pixel_iterator it=this; it.advance(d); return it; } reference operator->() const { return *this; } const bit_range_t& bit_range() const { return _bit_range; } bit_range_t& bit_range() { return _bit_range; } private: bit_range_t _bit_range; static constexpr int bit_size = NonAlignedPixelReference::bit_size; friend class boost::iterator_core_access; reference dereference() const { return NonAlignedPixelReference(_bit_range); } void increment() { ++_bit_range; } void decrement() { --_bit_range; } void advance(difference_type d) { _bit_range.bit_advance(dbit_size); } difference_type distance_to(const bit_aligned_pixel_iterator& it) const { return _bit_range.bit_distance_to(it._bit_range) / bit_size; } bool equal(const bit_aligned_pixel_iterator& it) const { return _bit_range==it._bit_range; } }; template <typename NonAlignedPixelReference> struct const_iterator_type<bit_aligned_pixel_iterator<NonAlignedPixelReference>> { using type = bit_aligned_pixel_iterator<typename NonAlignedPixelReference::const_reference>; }; template <typename NonAlignedPixelReference> struct iterator_is_mutable<bit_aligned_pixel_iterator<NonAlignedPixelReference>> : std::integral_constant<bool, NonAlignedPixelReference::is_mutable> {}; template <typename NonAlignedPixelReference> struct is_iterator_adaptor<bit_aligned_pixel_iterator<NonAlignedPixelReference>> : std::false_type {}; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename NonAlignedPixelReference> struct color_space_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public color_space_type<NonAlignedPixelReference> {}; template <typename NonAlignedPixelReference> struct channel_mapping_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public channel_mapping_type<NonAlignedPixelReference> {}; template <typename NonAlignedPixelReference> struct is_planar<bit_aligned_pixel_iterator<NonAlignedPixelReference> > : public is_planar<NonAlignedPixelReference> {}; // == false ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template <typename NonAlignedPixelReference> struct byte_to_memunit<bit_aligned_pixel_iterator<NonAlignedPixelReference>> : std::integral_constant<int, 8> {}; template <typename NonAlignedPixelReference> inline std::ptrdiff_t memunit_step(const bit_aligned_pixel_iterator<NonAlignedPixelReference>&) { return NonAlignedPixelReference::bit_size; } template <typename NonAlignedPixelReference> inline std::ptrdiff_t memunit_distance(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p1, const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p2) { return (p2.bit_range().current_byte() - p1.bit_range().current_byte())8 + p2.bit_range().bit_offset() - p1.bit_range().bit_offset(); } template <typename NonAlignedPixelReference> inline void memunit_advance(bit_aligned_pixel_iterator<NonAlignedPixelReference>& p, std::ptrdiff_t diff) { p.bit_range().bit_advance(diff); } template <typename NonAlignedPixelReference> inline bit_aligned_pixel_iterator<NonAlignedPixelReference> memunit_advanced(const bit_aligned_pixel_iterator<NonAlignedPixelReference>& p, std::ptrdiff_t diff) { bit_aligned_pixel_iterator<NonAlignedPixelReference> ret=p; memunit_advance(ret, diff); return ret; } template <typename NonAlignedPixelReference> inline NonAlignedPixelReference memunit_advanced_ref(bit_aligned_pixel_iterator<NonAlignedPixelReference> it, std::ptrdiff_t diff) { return memunit_advanced(it,diff); } ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename NonAlignedPixelReference> struct dynamic_x_step_type<bit_aligned_pixel_iterator<NonAlignedPixelReference> > { using type = memory_based_step_iterator<bit_aligned_pixel_iterator<NonAlignedPixelReference> >; }; ///////////////////////////// // iterator_type_from_pixel ///////////////////////////// template <typename B, typename C, typename L, bool M> struct iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,false,false,false> { using type = bit_aligned_pixel_iterator<bit_aligned_pixel_reference<B,C,L,false>> ; }; template <typename B, typename C, typename L, bool M> struct iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,false,false,true> { using type = bit_aligned_pixel_iterator<bit_aligned_pixel_reference<B,C,L,true>>; }; template <typename B, typename C, typename L, bool M, bool IsPlanar, bool IsStep, bool IsMutable> struct iterator_type_from_pixel<bit_aligned_pixel_reference<B,C,L,M>,IsPlanar,IsStep,IsMutable> : public iterator_type_from_pixel<const bit_aligned_pixel_reference<B,C,L,M>,IsPlanar,IsStep,IsMutable> {}; } } // namespace boost::gil namespace std { // It is important to provide an overload of uninitialized_copy for bit_aligned_pixel_iterator. The default STL implementation calls placement new, // which is not defined for bit_aligned_pixel_iterator. template <typename NonAlignedPixelReference> boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> uninitialized_copy(boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> first, boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> last, boost::gil::bit_aligned_pixel_iterator<NonAlignedPixelReference> dst) { return std::copy(first,last,dst); } } // namespace std #endif PK��p�[6D)��)��promote_integral.hppnu��[��// Boost.GIL (Generic Image Library) // // Copyright (c) 2015, Oracle and/or its affiliates. // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle // // Copyright (c) 2020, Debabrata Mandal <mandaldebabrata123@gmail.com> // // Licensed under the Boost Software License version 1.0. // http://www.boost.org/users/license.html // // Source: Boost.Geometry (aka GGL, Generic Geometry Library) // Modifications: adapted for Boost.GIL // - Rename namespace boost::geometry to boost::gil // - Rename include guards // - Remove support for boost::multiprecision types // - Remove support for 128-bit integer types // - Replace mpl meta functions with mp11 equivalents // #ifndef BOOST_GIL_PROMOTE_INTEGRAL_HPP #define BOOST_GIL_PROMOTE_INTEGRAL_HPP #include <boost/mp11/list.hpp> #include <climits> #include <cstddef> #include <type_traits> namespace boost { namespace gil { namespace detail { namespace promote_integral { // meta-function that returns the bit size of a type template < typename T, bool IsFundamental = std::is_fundamental<T>::value > struct bit_size {}; // for fundamental types, just return CHAR_BIT * sizeof(T) template <typename T> struct bit_size<T, true> : std::integral_constant<std::size_t, (CHAR_BIT * sizeof(T))> {}; template < typename T, typename IntegralTypes, std::size_t MinSize > struct promote_to_larger { using current_type = boost::mp11::mp_first<IntegralTypes>; using list_after_front = boost::mp11::mp_rest<IntegralTypes>; using type = typename std::conditional < (bit_size<current_type>::value >= MinSize), current_type, typename promote_to_larger < T, list_after_front, MinSize >::type >::type; }; // The following specialization is required to finish the loop over // all list elements template <typename T, std::size_t MinSize> struct promote_to_larger<T, boost::mp11::mp_list<>, MinSize> { // if promotion fails, keep the number T // (and cross fingers that overflow will not occur) using type = T; }; }} // namespace detail::promote_integral /! \brief Meta-function to define an integral type with size than is (roughly) twice the bit size of T \ingroup utility \details This meta-function tries to promote the fundamental integral type T to a another integral type with size (roughly) twice the bit size of T. To do this, two times the bit size of T is tested against the bit sizes of: short, int, long, boost::long_long_type, boost::int128_t and the one that first matches is chosen. For unsigned types the bit size of T is tested against the bit sizes of the types above, if T is promoted to a signed type, or the bit sizes of unsigned short, unsigned int, unsigned long, std::size_t, boost::ulong_long_type, boost::uint128_t if T is promoted to an unsigned type. By default an unsigned type is promoted to a signed type. This behavior is controlled by the PromoteUnsignedToUnsigned boolean template parameter, whose default value is "false". To promote an unsigned type to an unsigned type set the value of this template parameter to "true". Finally, if the passed type is either a floating-point type or a user-defined type it is returned as is. \note boost::long_long_type and boost::ulong_long_type are considered only if the macro BOOST_HAS_LONG_LONG is defined / template < typename T, bool PromoteUnsignedToUnsigned = false, bool UseCheckedInteger = false, bool IsIntegral = std::is_integral<T>::value > class promote_integral { private: static bool const is_unsigned = std::is_unsigned<T>::value; using bit_size_type = detail::promote_integral::bit_size<T>; // Define the minimum size (in bits) needed for the promoted type // If T is the input type and P the promoted type, then the // minimum number of bits for P are (below b stands for the number // of bits of T): // * if T is unsigned and P is unsigned: 2 * b // * if T is signed and P is signed: 2 * b - 1 // * if T is unsigned and P is signed: 2 * b + 1 using min_bit_size_type = typename std::conditional < (PromoteUnsignedToUnsigned && is_unsigned), std::integral_constant<std::size_t, (2 * bit_size_type::value)>, typename std::conditional < is_unsigned, std::integral_constant<std::size_t, (2 * bit_size_type::value + 1)>, std::integral_constant<std::size_t, (2 * bit_size_type::value - 1)> >::type >::type; // Define the list of signed integral types we are going to use // for promotion using signed_integral_types = boost::mp11::mp_list < short, int, long #if defined(BOOST_HAS_LONG_LONG) , boost::long_long_type #endif >; // Define the list of unsigned integral types we are going to use // for promotion using unsigned_integral_types = boost::mp11::mp_list < unsigned short, unsigned int, unsigned long, std::size_t #if defined(BOOST_HAS_LONG_LONG) , boost::ulong_long_type #endif >; // Define the list of integral types that will be used for // promotion (depending in whether we was to promote unsigned to // unsigned or not) using integral_types = typename std::conditional < (is_unsigned && PromoteUnsignedToUnsigned), unsigned_integral_types, signed_integral_types >::type; public: using type = typename detail::promote_integral::promote_to_larger < T, integral_types, min_bit_size_type::value >::type; }; template <typename T, bool PromoteUnsignedToUnsigned, bool UseCheckedInteger> class promote_integral < T, PromoteUnsignedToUnsigned, UseCheckedInteger, false > { public: using type = T; }; }} // namespace boost::gil #endif // BOOST_GIL_PROMOTE_INTEGRAL_HPP PK��p�[0��rgb.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_RGB_HPP #define BOOST_GIL_RGB_HPP #include <boost/gil/metafunctions.hpp> #include <boost/gil/planar_pixel_iterator.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> #include <type_traits> namespace boost { namespace gil { /// \addtogroup ColorNameModel /// \{ /// \brief Red struct red_t {}; /// \brief Green struct green_t {}; /// \brief Blue struct blue_t {}; /// \} /// \ingroup ColorSpaceModel using rgb_t = mp11::mp_list<red_t, green_t, blue_t>; /// \ingroup LayoutModel using rgb_layout_t = layout<rgb_t>; /// \ingroup LayoutModel using bgr_layout_t = layout<rgb_t, mp11::mp_list_c<int, 2, 1, 0>>; /// \ingroup ImageViewConstructors /// \brief from raw RGB planar data template <typename IC> inline auto planar_rgb_view( std::size_t width, std::size_t height, IC r, IC g, IC b, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<planar_pixel_iterator<IC, rgb_t> >::view_t { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC, rgb_t>>::view_t; return view_t( width, height, typename view_t::locator( planar_pixel_iterator<IC, rgb_t>(r, g, b), rowsize_in_bytes)); } }} // namespace boost::gil #endif PK��p�[�� t��t��channel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CHANNEL_HPP #define BOOST_GIL_CHANNEL_HPP #include <boost/gil/utilities.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/config/pragma_message.hpp> #include <boost/integer/integer_mask.hpp> #include <cstdint> #include <limits> #include <type_traits> #ifdef BOOST_GIL_DOXYGEN_ONLY /// \def BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS /// \brief Define to allow unaligned memory access for models of packed channel value. /// Theoretically (or historically?) on platforms which support dereferencing on /// non-word memory boundary, unaligned access may result in performance improvement. /// \warning Unfortunately, this optimization may be a C/C++ strict aliasing rules /// violation, if accessed data buffer has effective type that cannot be aliased /// without leading to undefined behaviour. #define BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS #endif #ifdef BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS #if defined(sun) \|\| defined(__sun) \|\| \ // SunOS defined(__osf__) \|\| defined(__osf) \|\| \ // Tru64 defined(_hpux) \|\| defined(hpux) \|\| \ // HP-UX defined(__arm__) \|\| defined(__ARM_ARCH) \|\| \ // ARM defined(_AIX) // AIX #error Unaligned access strictly disabled for some UNIX platforms or ARM architecture #elif defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__vax__) // The check for little-endian architectures that tolerate unaligned memory // accesses is just an optimization. Nothing will break if it fails to detect // a suitable architecture. // // Unfortunately, this optimization may be a C/C++ strict aliasing rules violation // if accessed data buffer has effective type that cannot be aliased // without leading to undefined behaviour. BOOST_PRAGMA_MESSAGE("CAUTION: Unaligned access tolerated on little-endian may cause undefined behaviour") #else #error Unaligned access disabled for unknown platforms and architectures #endif #endif // defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS) namespace boost { namespace gil { /////////////////////////////////////////// //// channel_traits //// //// \ingroup ChannelModel //// \class channel_traits //// \brief defines properties of channels, such as their range and associated types //// //// The channel traits must be defined for every model of ChannelConcept //// Default traits are provided. For built-in types the default traits use //// built-in pointer and reference and the channel range is the physical //// range of the type. For classes, the default traits forward the associated types //// and range to the class. //// /////////////////////////////////////////// namespace detail { template <typename T, bool IsClass> struct channel_traits_impl; // channel traits for custom class template <typename T> struct channel_traits_impl<T, true> { using value_type = typename T::value_type; using reference = typename T::reference; using pointer = typename T::pointer; using const_reference = typename T::const_reference; using const_pointer = typename T::const_pointer; static constexpr bool is_mutable = T::is_mutable; static value_type min_value() { return T::min_value(); } static value_type max_value() { return T::max_value(); } }; // channel traits implementation for built-in integral or floating point channel type template <typename T> struct channel_traits_impl<T, false> { using value_type = T; using reference = T&; using pointer = T; using const_reference = T const&; using const_pointer = T const; static constexpr bool is_mutable = true; static value_type min_value() { return (std::numeric_limits<T>::min)(); } static value_type max_value() { return (std::numeric_limits<T>::max)(); } }; // channel traits implementation for constant built-in scalar or floating point type template <typename T> struct channel_traits_impl<T const, false> : channel_traits_impl<T, false> { using reference = T const&; using pointer = T const; static constexpr bool is_mutable = false; }; } // namespace detail /* \ingroup ChannelModel \brief Traits for channels. Contains the following members: \code template <typename Channel> struct channel_traits { using value_type = ...; using reference = ...; using pointer = ...; using const_reference = ...; using const_pointer = ...; static const bool is_mutable; static value_type min_value(); static value_type max_value(); }; \endcode / template <typename T> struct channel_traits : detail::channel_traits_impl<T, std::is_class<T>::value> {}; // Channel traits for C++ reference type - remove the reference template <typename T> struct channel_traits<T&> : channel_traits<T> {}; // Channel traits for constant C++ reference type template <typename T> struct channel_traits<T const&> : channel_traits<T> { using reference = typename channel_traits<T>::const_reference; using pointer = typename channel_traits<T>::const_pointer; static constexpr bool is_mutable = false; }; /////////////////////////////////////////// //// scoped_channel_value /////////////////////////////////////////// /// \defgroup ScopedChannelValue scoped_channel_value /// \ingroup ChannelModel /// \brief A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept /// /// Example: /// \code /// // Create a double channel with range [-0.5 .. 0.5] /// struct double_minus_half { static double apply() { return -0.5; } }; /// struct double_plus_half { static double apply() { return 0.5; } }; /// using bits64custom_t = scoped_channel_value<double, double_minus_half, double_plus_half>; /// /// // channel_convert its maximum should map to the maximum /// bits64custom_t x = channel_traits<bits64custom_t>::max_value(); /// assert(x == 0.5); /// uint16_t y = channel_convert<uint16_t>(x); /// assert(y == 65535); /// \endcode /// \ingroup ScopedChannelValue /// \brief A channel adaptor that modifies the range of the source channel. Models: ChannelValueConcept /// \tparam BaseChannelValue base channel (models ChannelValueConcept) /// \tparam MinVal class with a static apply() function returning the minimum channel values /// \tparam MaxVal class with a static apply() function returning the maximum channel values template <typename BaseChannelValue, typename MinVal, typename MaxVal> struct scoped_channel_value { using value_type = scoped_channel_value<BaseChannelValue, MinVal, MaxVal>; using reference = value_type&; using pointer = value_type; using const_reference = value_type const&; using const_pointer = value_type const; static constexpr bool is_mutable = channel_traits<BaseChannelValue>::is_mutable; using base_channel_t = BaseChannelValue; static value_type min_value() { return MinVal::apply(); } static value_type max_value() { return MaxVal::apply(); } scoped_channel_value() = default; scoped_channel_value(scoped_channel_value const& other) : value_(other.value_) {} scoped_channel_value& operator=(scoped_channel_value const& other) = default; scoped_channel_value(BaseChannelValue value) : value_(value) {} scoped_channel_value& operator=(BaseChannelValue value) { value_ = value; return this; } scoped_channel_value& operator++() { ++value_; return this; } scoped_channel_value& operator--() { --value_; return this; } scoped_channel_value operator++(int) { scoped_channel_value tmp=this; this->operator++(); return tmp; } scoped_channel_value operator--(int) { scoped_channel_value tmp=this; this->operator--(); return tmp; } template <typename Scalar2> scoped_channel_value& operator+=(Scalar2 v) { value_+=v; return this; } template <typename Scalar2> scoped_channel_value& operator-=(Scalar2 v) { value_-=v; return this; } template <typename Scalar2> scoped_channel_value& operator=(Scalar2 v) { value_=v; return this; } template <typename Scalar2> scoped_channel_value& operator/=(Scalar2 v) { value_/=v; return this; } operator BaseChannelValue() const { return value_; } private: BaseChannelValue value_{}; }; template <typename T> struct float_point_zero { static constexpr T apply() { return 0.0f; } }; template <typename T> struct float_point_one { static constexpr T apply() { return 1.0f; } }; /////////////////////////////////////////// //// Support for sub-byte channels. These are integral channels whose value is contained in a range of bits inside an integral type /////////////////////////////////////////// // It is necessary for packed channels to have their own value type. They cannot simply use an integral large enough to store the data. Here is why: // - Any operation that requires returning the result by value will otherwise return the built-in integral type, which will have incorrect range // That means that after getting the value of the channel we cannot properly do channel_convert, channel_invert, etc. // - Two channels are declared compatible if they have the same value type. That means that a packed channel is incorrectly declared compatible with an integral type namespace detail { // returns the smallest fast unsigned integral type that has at least NumBits bits template <int NumBits> struct min_fast_uint : std::conditional < NumBits <= 8, std::uint_least8_t, typename std::conditional < NumBits <= 16, std::uint_least16_t, typename std::conditional < NumBits <= 32, std::uint_least32_t, std::uintmax_t >::type >::type > {}; template <int NumBits> struct num_value_fn : std::conditional<NumBits < 32, std::uint32_t, std::uint64_t> {}; template <int NumBits> struct max_value_fn : std::conditional<NumBits <= 32, std::uint32_t, std::uint64_t> {}; } // namespace detail /// \defgroup PackedChannelValueModel packed_channel_value /// \ingroup ChannelModel /// \brief Represents the value of an unsigned integral channel operating over a bit range. Models: ChannelValueConcept /// Example: /// \code /// // A 4-bit unsigned integral channel. /// using bits4 = packed_channel_value<4>; /// /// assert(channel_traits<bits4>::min_value()==0); /// assert(channel_traits<bits4>::max_value()==15); /// assert(sizeof(bits4)==1); /// static_assert(gil::is_channel_integral<bits4>::value, ""); /// \endcode /// \ingroup PackedChannelValueModel /// \brief The value of a subbyte channel. Models: ChannelValueConcept template <int NumBits> class packed_channel_value { public: using integer_t = typename detail::min_fast_uint<NumBits>::type; using value_type = packed_channel_value<NumBits>; using reference = value_type&; using const_reference = value_type const&; using pointer = value_type; using const_pointer = value_type const; static constexpr bool is_mutable = true; static value_type min_value() { return 0; } static value_type max_value() { return low_bits_mask_t< NumBits >::sig_bits; } packed_channel_value() = default; packed_channel_value(integer_t v) { value_ = static_cast<integer_t>(v & low_bits_mask_t<NumBits>::sig_bits_fast); } template <typename Scalar> packed_channel_value(Scalar v) { value_ = packed_channel_value(static_cast<integer_t>(v)); } static unsigned int num_bits() { return NumBits; } operator integer_t() const { return value_; } private: integer_t value_{}; }; namespace detail { template <std::size_t K> struct static_copy_bytes { void operator()(unsigned char const* from, unsigned char* to) const { to = from; static_copy_bytes<K - 1>()(++from, ++to); } }; template <> struct static_copy_bytes<0> { void operator()(unsigned char const, unsigned char) const {} }; template <typename Derived, typename BitField, int NumBits, bool IsMutable> class packed_channel_reference_base { protected: using data_ptr_t = typename std::conditional<IsMutable, void, void const>::type; public: data_ptr_t _data_ptr; // void* pointer to the first byte of the bit range using value_type = packed_channel_value<NumBits>; using reference = const Derived; using pointer = value_type ; using const_pointer = const value_type ; static constexpr int num_bits = NumBits; static constexpr bool is_mutable = IsMutable; static value_type min_value() { return channel_traits<value_type>::min_value(); } static value_type max_value() { return channel_traits<value_type>::max_value(); } using bitfield_t = BitField; using integer_t = typename value_type::integer_t; packed_channel_reference_base(data_ptr_t data_ptr) : _data_ptr(data_ptr) {} packed_channel_reference_base(const packed_channel_reference_base& ref) : _data_ptr(ref._data_ptr) {} const Derived& operator=(integer_t v) const { set(v); return derived(); } const Derived& operator++() const { set(get()+1); return derived(); } const Derived& operator--() const { set(get()-1); return derived(); } Derived operator++(int) const { Derived tmp=derived(); this->operator++(); return tmp; } Derived operator--(int) const { Derived tmp=derived(); this->operator--(); return tmp; } template <typename Scalar2> const Derived& operator+=(Scalar2 v) const { set( static_cast<integer_t>( get() + v )); return derived(); } template <typename Scalar2> const Derived& operator-=(Scalar2 v) const { set( static_cast<integer_t>( get() - v )); return derived(); } template <typename Scalar2> const Derived& operator=(Scalar2 v) const { set( static_cast<integer_t>( get() v )); return derived(); } template <typename Scalar2> const Derived& operator/=(Scalar2 v) const { set( static_cast<integer_t>( get() / v )); return derived(); } operator integer_t() const { return get(); } data_ptr_t operator &() const {return _data_ptr;} protected: using num_value_t = typename detail::num_value_fn<NumBits>::type; using max_value_t = typename detail::max_value_fn<NumBits>::type; static const num_value_t num_values = static_cast< num_value_t >( 1 ) << NumBits ; static const max_value_t max_val = static_cast< max_value_t >( num_values - 1 ); #if defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS) const bitfield_t& get_data() const { return static_cast<const bitfield_t>(_data_ptr); } void set_data(const bitfield_t& val) const { static_cast< bitfield_t>(_data_ptr) = val; } #else bitfield_t get_data() const { bitfield_t ret; static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char>(_data_ptr),gil_reinterpret_cast<unsigned char>(&ret)); return ret; } void set_data(const bitfield_t& val) const { static_copy_bytes<sizeof(bitfield_t) >()(gil_reinterpret_cast_c<const unsigned char>(&val),gil_reinterpret_cast<unsigned char>(_data_ptr)); } #endif private: void set(integer_t value) const { // can this be done faster?? this->derived().set_unsafe(((value % num_values) + num_values) % num_values); } integer_t get() const { return derived().get(); } const Derived& derived() const { return static_cast<const Derived&>(this); } }; } // namespace detail /// \defgroup PackedChannelReferenceModel packed_channel_reference /// \ingroup ChannelModel /// \brief Represents a reference proxy to a channel operating over a bit range whose offset is fixed at compile time. Models ChannelConcept /// Example: /// \code /// // Reference to a 2-bit channel starting at bit 1 (i.e. the second bit) /// using bits2_1_ref_t = packed_channel_reference<uint16_t,1,2,true> const; /// /// uint16_t data=0; /// bits2_1_ref_t channel_ref(&data); /// channel_ref = channel_traits<bits2_1_ref_t>::max_value(); // == 3 /// assert(data == 6); // == 3<<1 == 6 /// \endcode /// \tparam BitField A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t /// \tparam Defines the sequence of bits in the data value that contain the channel /// \tparam true if the reference is mutable template <typename BitField, int FirstBit, int NumBits, bool IsMutable> class packed_channel_reference; /// \tparam A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t /// \tparam Defines the sequence of bits in the data value that contain the channel /// \tparam true if the reference is mutable template <typename BitField, int NumBits, bool IsMutable> class packed_dynamic_channel_reference; /// \ingroup PackedChannelReferenceModel /// \brief A constant subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept template <typename BitField, int FirstBit, int NumBits> class packed_channel_reference<BitField, FirstBit, NumBits, false> : public detail::packed_channel_reference_base < packed_channel_reference<BitField, FirstBit, NumBits, false>, BitField, NumBits, false > { using parent_t = detail::packed_channel_reference_base < packed_channel_reference<BitField, FirstBit, NumBits, false>, BitField, NumBits, false >; friend class packed_channel_reference<BitField, FirstBit, NumBits, true>; static const BitField channel_mask = static_cast<BitField>(parent_t::max_val) << FirstBit; void operator=(packed_channel_reference const&); public: using const_reference = packed_channel_reference<BitField,FirstBit,NumBits,false> const; using mutable_reference = packed_channel_reference<BitField,FirstBit,NumBits,true> const; using integer_t = typename parent_t::integer_t; explicit packed_channel_reference(const void data_ptr) : parent_t(data_ptr) {} packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} packed_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr) {} unsigned first_bit() const { return FirstBit; } integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); } }; /// \ingroup PackedChannelReferenceModel /// \brief A mutable subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept template <typename BitField, int FirstBit, int NumBits> class packed_channel_reference<BitField,FirstBit,NumBits,true> : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> { using parent_t = detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true>; friend class packed_channel_reference<BitField,FirstBit,NumBits,false>; static const BitField channel_mask = static_cast< BitField >( parent_t::max_val ) << FirstBit; public: using const_reference = packed_channel_reference<BitField,FirstBit,NumBits,false> const; using mutable_reference = packed_channel_reference<BitField,FirstBit,NumBits,true> const; using integer_t = typename parent_t::integer_t; explicit packed_channel_reference(void* data_ptr) : parent_t(data_ptr) {} packed_channel_reference(const packed_channel_reference& ref) : parent_t(ref._data_ptr) {} packed_channel_reference const& operator=(integer_t value) const { BOOST_ASSERT(value <= parent_t::max_val); set_unsafe(value); return this; } const packed_channel_reference& operator=(const mutable_reference& ref) const { set_from_reference(ref.get_data()); return this; } const packed_channel_reference& operator=(const const_reference& ref) const { set_from_reference(ref.get_data()); return this; } template <bool Mutable1> const packed_channel_reference& operator=(const packed_dynamic_channel_reference<BitField,NumBits,Mutable1>& ref) const { set_unsafe(ref.get()); return this; } unsigned first_bit() const { return FirstBit; } integer_t get() const { return integer_t((this->get_data()&channel_mask) >> FirstBit); } void set_unsafe(integer_t value) const { this->set_data((this->get_data() & ~channel_mask) \| (( static_cast< BitField >( value )<<FirstBit))); } private: void set_from_reference(const BitField& other_bits) const { this->set_data((this->get_data() & ~channel_mask) \| (other_bits & channel_mask)); } }; }} // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy /// \ingroup PackedChannelReferenceModel /// \brief swap for packed_channel_reference template <typename BF, int FB, int NB, bool M, typename R> inline void swap(boost::gil::packed_channel_reference<BF, FB, NB, M> const x, R& y) { boost::gil::swap_proxy < typename boost::gil::packed_channel_reference<BF, FB, NB, M>::value_type >(x, y); } /// \ingroup PackedChannelReferenceModel /// \brief swap for packed_channel_reference template <typename BF, int FB, int NB, bool M> inline void swap( typename boost::gil::packed_channel_reference<BF, FB, NB, M>::value_type& x, boost::gil::packed_channel_reference<BF, FB, NB, M> const y) { boost::gil::swap_proxy < typename boost::gil::packed_channel_reference<BF, FB, NB, M>::value_type >(x,y); } /// \ingroup PackedChannelReferenceModel /// \brief swap for packed_channel_reference template <typename BF, int FB, int NB, bool M> inline void swap( boost::gil::packed_channel_reference<BF, FB, NB, M> const x, boost::gil::packed_channel_reference<BF, FB, NB, M> const y) { boost::gil::swap_proxy < typename boost::gil::packed_channel_reference<BF, FB, NB, M>::value_type >(x,y); } } // namespace std namespace boost { namespace gil { /// \defgroup PackedChannelDynamicReferenceModel packed_dynamic_channel_reference /// \ingroup ChannelModel /// \brief Represents a reference proxy to a channel operating over a bit range whose offset is specified at run time. Models ChannelConcept /// /// Example: /// \code /// // Reference to a 2-bit channel whose offset is specified at construction time /// using bits2_dynamic_ref_t = packed_dynamic_channel_reference<uint8_t,2,true> const; /// /// uint16_t data=0; /// bits2_dynamic_ref_t channel_ref(&data,1); /// channel_ref = channel_traits<bits2_dynamic_ref_t>::max_value(); // == 3 /// assert(data == 6); // == (3<<1) == 6 /// \endcode /// \brief Models a constant subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept /// Same as packed_channel_reference, except that the offset is a runtime parameter /// \ingroup PackedChannelDynamicReferenceModel template <typename BitField, int NumBits> class packed_dynamic_channel_reference<BitField,NumBits,false> : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> { using parent_t = detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false>; friend class packed_dynamic_channel_reference<BitField,NumBits,true>; unsigned _first_bit; // 0..7 void operator=(const packed_dynamic_channel_reference&); public: using const_reference = packed_dynamic_channel_reference<BitField,NumBits,false> const; using mutable_reference = packed_dynamic_channel_reference<BitField,NumBits,true> const; using integer_t = typename parent_t::integer_t; packed_dynamic_channel_reference(const void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {} packed_dynamic_channel_reference(const const_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} packed_dynamic_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} unsigned first_bit() const { return _first_bit; } integer_t get() const { const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) <<_first_bit; return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit ); } }; /// \brief Models a mutable subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept /// Same as packed_channel_reference, except that the offset is a runtime parameter /// \ingroup PackedChannelDynamicReferenceModel template <typename BitField, int NumBits> class packed_dynamic_channel_reference<BitField,NumBits,true> : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> { using parent_t = detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true>; friend class packed_dynamic_channel_reference<BitField,NumBits,false>; unsigned _first_bit; public: using const_reference = packed_dynamic_channel_reference<BitField,NumBits,false> const; using mutable_reference = packed_dynamic_channel_reference<BitField,NumBits,true> const; using integer_t = typename parent_t::integer_t; packed_dynamic_channel_reference(void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {} packed_dynamic_channel_reference(const packed_dynamic_channel_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {} packed_dynamic_channel_reference const& operator=(integer_t value) const { BOOST_ASSERT(value <= parent_t::max_val); set_unsafe(value); return this; } const packed_dynamic_channel_reference& operator=(const mutable_reference& ref) const { set_unsafe(ref.get()); return this; } const packed_dynamic_channel_reference& operator=(const const_reference& ref) const { set_unsafe(ref.get()); return this; } template <typename BitField1, int FirstBit1, bool Mutable1> const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const { set_unsafe(ref.get()); return this; } unsigned first_bit() const { return _first_bit; } integer_t get() const { const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit; return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit ); } void set_unsafe(integer_t value) const { const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit; this->set_data((this->get_data() & ~channel_mask) \| value<<_first_bit); } }; } } // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy /// \ingroup PackedChannelDynamicReferenceModel /// \brief swap for packed_dynamic_channel_reference template <typename BF, int NB, bool M, typename R> inline void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } /// \ingroup PackedChannelDynamicReferenceModel /// \brief swap for packed_dynamic_channel_reference template <typename BF, int NB, bool M> inline void swap(typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type& x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } /// \ingroup PackedChannelDynamicReferenceModel /// \brief swap for packed_dynamic_channel_reference template <typename BF, int NB, bool M> inline void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); } } // namespace std // \brief Determines the fundamental type which may be used, e.g., to cast from larger to smaller channel types. namespace boost { namespace gil { template <typename T> struct base_channel_type_impl { using type = T; }; template <int N> struct base_channel_type_impl<packed_channel_value<N> > { using type = typename packed_channel_value<N>::integer_t; }; template <typename B, int F, int N, bool M> struct base_channel_type_impl<packed_channel_reference<B, F, N, M> > { using type = typename packed_channel_reference<B,F,N,M>::integer_t; }; template <typename B, int N, bool M> struct base_channel_type_impl<packed_dynamic_channel_reference<B, N, M> > { using type = typename packed_dynamic_channel_reference<B,N,M>::integer_t; }; template <typename ChannelValue, typename MinV, typename MaxV> struct base_channel_type_impl<scoped_channel_value<ChannelValue, MinV, MaxV> > { using type = ChannelValue; }; template <typename T> struct base_channel_type : base_channel_type_impl<typename std::remove_cv<T>::type> {}; }} //namespace boost::gil #endif PK��p�[�c��rgba.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_RGBA_HPP #define BOOST_GIL_RGBA_HPP #include <boost/gil/planar_pixel_iterator.hpp> #include <boost/gil/rgb.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> #include <type_traits> namespace boost { namespace gil { /// \ingroup ColorNameModel /// \brief Alpha struct alpha_t {}; /// \ingroup ColorSpaceModel using rgba_t =mp11::mp_list<red_t, green_t, blue_t, alpha_t>; /// \ingroup LayoutModel using rgba_layout_t = layout<rgba_t>; /// \ingroup LayoutModel using bgra_layout_t = layout<rgba_t, mp11::mp_list_c<int, 2, 1, 0, 3>>; /// \ingroup LayoutModel using argb_layout_t = layout<rgba_t, mp11::mp_list_c<int, 1, 2, 3, 0>>; /// \ingroup LayoutModel using abgr_layout_t = layout<rgba_t, mp11::mp_list_c<int, 3, 2, 1, 0>>; /// \ingroup ImageViewConstructors /// \brief from raw RGBA planar data template <typename ChannelPtr> inline auto planar_rgba_view(std::size_t width, std::size_t height, ChannelPtr r, ChannelPtr g, ChannelPtr b, ChannelPtr a, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<planar_pixel_iterator<ChannelPtr, rgba_t> >::view_t { using pixel_iterator_t = planar_pixel_iterator<ChannelPtr, rgba_t>; using view_t = typename type_from_x_iterator<pixel_iterator_t>::view_t; using locator_t = typename view_t::locator; locator_t loc(pixel_iterator_t(r, g, b, a), rowsize_in_bytes); return view_t(width, height, loc); } }} // namespace boost::gil #endif PK��p�[2[/)Z��)Z��channel_algorithm.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_GIL_CHANNEL_ALGORITHM_HPP #define BOOST_GIL_GIL_CHANNEL_ALGORITHM_HPP #include <boost/gil/channel.hpp> #include <boost/gil/promote_integral.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/is_channel_integral.hpp> #include <boost/gil/detail/mp11.hpp> #include <limits> #include <type_traits> namespace boost { namespace gil { namespace detail { // some forward declarations template <typename SrcChannelV, typename DstChannelV, bool SrcIsIntegral, bool DstIsIntegral> struct channel_converter_unsigned_impl; template <typename SrcChannelV, typename DstChannelV, bool SrcIsGreater> struct channel_converter_unsigned_integral; template <typename SrcChannelV, typename DstChannelV, bool SrcLessThanDst, bool SrcDivisible> struct channel_converter_unsigned_integral_impl; template <typename SrcChannelV, typename DstChannelV, bool SrcLessThanDst, bool CannotFitInInteger> struct channel_converter_unsigned_integral_nondivisible; ////////////////////////////////////// //// unsigned_integral_max_value - given an unsigned integral channel type, //// returns its maximum value as an integral constant ////////////////////////////////////// template <typename UnsignedIntegralChannel> struct unsigned_integral_max_value : std::integral_constant < UnsignedIntegralChannel, (std::numeric_limits<UnsignedIntegralChannel>::max)() > {}; template <> struct unsigned_integral_max_value<uint8_t> : std::integral_constant<uint32_t, 0xFF> {}; template <> struct unsigned_integral_max_value<uint16_t> : std::integral_constant<uint32_t, 0xFFFF> {}; template <> struct unsigned_integral_max_value<uint32_t> : std::integral_constant<uintmax_t, 0xFFFFFFFF> {}; template <int K> struct unsigned_integral_max_value<packed_channel_value<K>> : std::integral_constant < typename packed_channel_value<K>::integer_t, (uint64_t(1)<<K)-1 > {}; ////////////////////////////////////// //// unsigned_integral_num_bits - given an unsigned integral channel type, //// returns the minimum number of bits needed to represent it ////////////////////////////////////// template <typename UnsignedIntegralChannel> struct unsigned_integral_num_bits : std::integral_constant<int, sizeof(UnsignedIntegralChannel) * 8> {}; template <int K> struct unsigned_integral_num_bits<packed_channel_value<K>> : std::integral_constant<int, K> {}; } // namespace detail /// \defgroup ChannelConvertAlgorithm channel_convert /// \brief Converting from one channel type to another /// \ingroup ChannelAlgorithm /// /// Conversion is done as a simple linear mapping of one channel range to the other, /// such that the minimum/maximum value of the source maps to the minimum/maximum value of the destination. /// One implication of this is that the value 0 of signed channels may not be preserved! /// /// When creating new channel models, it is often a good idea to provide specializations for the channel conversion algorithms, for /// example, for performance optimizations. If the new model is an integral type that can be signed, it is easier to define the conversion /// only for the unsigned type (\p channel_converter_unsigned) and provide specializations of \p detail::channel_convert_to_unsigned /// and \p detail::channel_convert_from_unsigned to convert between the signed and unsigned type. /// /// Example: /// \code /// // float32_t is a floating point channel with range [0.0f ... 1.0f] /// float32_t src_channel = channel_traits<float32_t>::max_value(); /// assert(src_channel == 1); /// /// // uint8_t is 8-bit unsigned integral channel (aliased from unsigned char) /// uint8_t dst_channel = channel_convert<uint8_t>(src_channel); /// assert(dst_channel == 255); // max value goes to max value /// \endcode /// /// \defgroup ChannelConvertUnsignedAlgorithm channel_converter_unsigned /// \ingroup ChannelConvertAlgorithm /// \brief Convert one unsigned/floating point channel to another. Converts both the channel type and range /// @{ ////////////////////////////////////// //// channel_converter_unsigned ////////////////////////////////////// template <typename SrcChannelV, typename DstChannelV> // Model ChannelValueConcept struct channel_converter_unsigned : detail::channel_converter_unsigned_impl < SrcChannelV, DstChannelV, detail::is_channel_integral<SrcChannelV>::value, detail::is_channel_integral<DstChannelV>::value > {}; /// \brief Converting a channel to itself - identity operation template <typename T> struct channel_converter_unsigned<T,T> : public detail::identity<T> {}; namespace detail { ////////////////////////////////////// //// channel_converter_unsigned_impl ////////////////////////////////////// /// \brief This is the default implementation. Performance specializatons are provided template <typename SrcChannelV, typename DstChannelV, bool SrcIsIntegral, bool DstIsIntegral> struct channel_converter_unsigned_impl { using argument_type = SrcChannelV; using result_type = DstChannelV; DstChannelV operator()(SrcChannelV src) const { return DstChannelV(channel_traits<DstChannelV>::min_value() + (src - channel_traits<SrcChannelV>::min_value()) / channel_range<SrcChannelV>() * channel_range<DstChannelV>()); } private: template <typename C> static double channel_range() { return double(channel_traits<C>::max_value()) - double(channel_traits<C>::min_value()); } }; // When both the source and the destination are integral channels, perform a faster conversion template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_impl<SrcChannelV, DstChannelV, true, true> : channel_converter_unsigned_integral < SrcChannelV, DstChannelV, mp11::mp_less < unsigned_integral_max_value<SrcChannelV>, unsigned_integral_max_value<DstChannelV> >::value > {}; ////////////////////////////////////// //// channel_converter_unsigned_integral ////////////////////////////////////// template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral<SrcChannelV,DstChannelV,true> : public channel_converter_unsigned_integral_impl<SrcChannelV,DstChannelV,true, !(unsigned_integral_max_value<DstChannelV>::value % unsigned_integral_max_value<SrcChannelV>::value) > {}; template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral<SrcChannelV,DstChannelV,false> : public channel_converter_unsigned_integral_impl<SrcChannelV,DstChannelV,false, !(unsigned_integral_max_value<SrcChannelV>::value % unsigned_integral_max_value<DstChannelV>::value) > {}; ////////////////////////////////////// //// channel_converter_unsigned_integral_impl ////////////////////////////////////// // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is divisible by the src max value template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral_impl<SrcChannelV,DstChannelV,true,true> { DstChannelV operator()(SrcChannelV src) const { using integer_t = typename unsigned_integral_max_value<DstChannelV>::value_type; static const integer_t mul = unsigned_integral_max_value<DstChannelV>::value / unsigned_integral_max_value<SrcChannelV>::value; return DstChannelV(src * mul); } }; // Both source and destination are unsigned integral channels, // the dst max value is less than (or equal to) the src max value, // and the src max value is divisible by the dst max value template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral_impl<SrcChannelV,DstChannelV,false,true> { DstChannelV operator()(SrcChannelV src) const { using integer_t = typename unsigned_integral_max_value<SrcChannelV>::value_type; static const integer_t div = unsigned_integral_max_value<SrcChannelV>::value / unsigned_integral_max_value<DstChannelV>::value; static const integer_t div2 = div/2; return DstChannelV((src + div2) / div); } }; // Prevent overflow for the largest integral type template <typename DstChannelV> struct channel_converter_unsigned_integral_impl<uintmax_t,DstChannelV,false,true> { DstChannelV operator()(uintmax_t src) const { static const uintmax_t div = unsigned_integral_max_value<uint32_t>::value / unsigned_integral_max_value<DstChannelV>::value; static const uintmax_t div2 = div/2; if (src > unsigned_integral_max_value<uintmax_t>::value - div2) return unsigned_integral_max_value<DstChannelV>::value; return DstChannelV((src + div2) / div); } }; // Both source and destination are unsigned integral channels, // and the dst max value is not divisible by the src max value // See if you can represent the expression (src * dst_max) / src_max in integral form template <typename SrcChannelV, typename DstChannelV, bool SrcLessThanDst> struct channel_converter_unsigned_integral_impl<SrcChannelV, DstChannelV, SrcLessThanDst, false> : channel_converter_unsigned_integral_nondivisible < SrcChannelV, DstChannelV, SrcLessThanDst, mp11::mp_less < unsigned_integral_num_bits<uintmax_t>, mp11::mp_plus < unsigned_integral_num_bits<SrcChannelV>, unsigned_integral_num_bits<DstChannelV> > >::value > {}; // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is not divisible by the src max value // The expression (src * dst_max) / src_max fits in an integer template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral_nondivisible<SrcChannelV, DstChannelV, true, false> { DstChannelV operator()(SrcChannelV src) const { using dest_t = typename base_channel_type<DstChannelV>::type; return DstChannelV( static_cast<dest_t>(src * unsigned_integral_max_value<DstChannelV>::value) / unsigned_integral_max_value<SrcChannelV>::value); } }; // Both source and destination are unsigned integral channels, // the src max value is less than the dst max value, // and the dst max value is not divisible by the src max value // The expression (src * dst_max) / src_max cannot fit in an integer (overflows). Use a double template <typename SrcChannelV, typename DstChannelV> struct channel_converter_unsigned_integral_nondivisible<SrcChannelV, DstChannelV, true, true> { DstChannelV operator()(SrcChannelV src) const { static const double mul = unsigned_integral_max_value<DstChannelV>::value / double(unsigned_integral_max_value<SrcChannelV>::value); return DstChannelV(src * mul); } }; // Both source and destination are unsigned integral channels, // the dst max value is less than (or equal to) the src max value, // and the src max value is not divisible by the dst max value template <typename SrcChannelV, typename DstChannelV, bool CannotFit> struct channel_converter_unsigned_integral_nondivisible<SrcChannelV,DstChannelV,false,CannotFit> { DstChannelV operator()(SrcChannelV src) const { using src_integer_t = typename detail::unsigned_integral_max_value<SrcChannelV>::value_type; using dst_integer_t = typename detail::unsigned_integral_max_value<DstChannelV>::value_type; static const double div = unsigned_integral_max_value<SrcChannelV>::value / static_cast< double >( unsigned_integral_max_value<DstChannelV>::value ); static const src_integer_t div2 = static_cast< src_integer_t >( div / 2.0 ); return DstChannelV( static_cast< dst_integer_t >(( static_cast< double >( src + div2 ) / div ))); } }; } // namespace detail ///////////////////////////////////////////////////// /// float32_t conversion ///////////////////////////////////////////////////// template <typename DstChannelV> struct channel_converter_unsigned<float32_t,DstChannelV> { using argument_type = float32_t; using result_type = DstChannelV; DstChannelV operator()(float32_t x) const { using dst_integer_t = typename detail::unsigned_integral_max_value<DstChannelV>::value_type; return DstChannelV( static_cast< dst_integer_t >(xchannel_traits<DstChannelV>::max_value()+0.5f )); } }; template <typename SrcChannelV> struct channel_converter_unsigned<SrcChannelV,float32_t> { using argument_type = float32_t; using result_type = SrcChannelV; float32_t operator()(SrcChannelV x) const { return float32_t(x/float(channel_traits<SrcChannelV>::max_value())); } }; template <> struct channel_converter_unsigned<float32_t,float32_t> { using argument_type = float32_t; using result_type = float32_t; float32_t operator()(float32_t x) const { return x; } }; /// \brief 32 bit <-> float channel conversion template <> struct channel_converter_unsigned<uint32_t,float32_t> { using argument_type = uint32_t; using result_type = float32_t; float32_t operator()(uint32_t x) const { // unfortunately without an explicit check it is possible to get a round-off error. We must ensure that max_value of uint32_t matches max_value of float32_t if (x>=channel_traits<uint32_t>::max_value()) return channel_traits<float32_t>::max_value(); return float(x) / float(channel_traits<uint32_t>::max_value()); } }; /// \brief 32 bit <-> float channel conversion template <> struct channel_converter_unsigned<float32_t,uint32_t> { using argument_type = float32_t; using result_type = uint32_t; uint32_t operator()(float32_t x) const { // unfortunately without an explicit check it is possible to get a round-off error. We must ensure that max_value of uint32_t matches max_value of float32_t if (x>=channel_traits<float32_t>::max_value()) return channel_traits<uint32_t>::max_value(); auto const max_value = channel_traits<uint32_t>::max_value(); auto const result = x static_cast<float32_t::base_channel_t>(max_value) + 0.5f; return static_cast<uint32_t>(result); } }; /// @} namespace detail { // Converting from signed to unsigned integral channel. // It is both a unary function, and a metafunction (thus requires the 'type' nested alias, which equals result_type) template <typename ChannelValue> // Model ChannelValueConcept struct channel_convert_to_unsigned : public detail::identity<ChannelValue> { using type = ChannelValue; }; template <> struct channel_convert_to_unsigned<int8_t> { using argument_type = int8_t; using result_type = uint8_t; using type = uint8_t; type operator()(int8_t val) const { return static_cast<uint8_t>(static_cast<uint32_t>(val) + 128u); } }; template <> struct channel_convert_to_unsigned<int16_t> { using argument_type = int16_t; using result_type = uint16_t; using type = uint16_t; type operator()(int16_t val) const { return static_cast<uint16_t>(static_cast<uint32_t>(val) + 32768u); } }; template <> struct channel_convert_to_unsigned<int32_t> { using argument_type = int32_t; using result_type = uint32_t; using type = uint32_t; type operator()(int32_t val) const { return static_cast<uint32_t>(val)+(1u<<31); } }; // Converting from unsigned to signed integral channel // It is both a unary function, and a metafunction (thus requires the 'type' nested alias, which equals result_type) template <typename ChannelValue> // Model ChannelValueConcept struct channel_convert_from_unsigned : public detail::identity<ChannelValue> { using type = ChannelValue; }; template <> struct channel_convert_from_unsigned<int8_t> { using argument_type = uint8_t; using result_type = int8_t; using type = int8_t; type operator()(uint8_t val) const { return static_cast<int8_t>(static_cast<int32_t>(val) - 128); } }; template <> struct channel_convert_from_unsigned<int16_t> { using argument_type = uint16_t; using result_type = int16_t; using type = int16_t; type operator()(uint16_t val) const { return static_cast<int16_t>(static_cast<int32_t>(val) - 32768); } }; template <> struct channel_convert_from_unsigned<int32_t> { using argument_type = uint32_t; using result_type = int32_t; using type = int32_t; type operator()(uint32_t val) const { return static_cast<int32_t>(val - (1u<<31)); } }; } // namespace detail /// \ingroup ChannelConvertAlgorithm /// \brief A unary function object converting between channel types template <typename SrcChannelV, typename DstChannelV> // Model ChannelValueConcept struct channel_converter { using argument_type = SrcChannelV; using result_type = DstChannelV; DstChannelV operator()(const SrcChannelV& src) const { using to_unsigned = detail::channel_convert_to_unsigned<SrcChannelV>; using from_unsigned = detail::channel_convert_from_unsigned<DstChannelV>; using converter_unsigned = channel_converter_unsigned<typename to_unsigned::result_type, typename from_unsigned::argument_type>; return from_unsigned()(converter_unsigned()(to_unsigned()(src))); } }; /// \ingroup ChannelConvertAlgorithm /// \brief Converting from one channel type to another. template <typename DstChannel, typename SrcChannel> // Model ChannelConcept (could be channel references) inline typename channel_traits<DstChannel>::value_type channel_convert(const SrcChannel& src) { return channel_converter<typename channel_traits<SrcChannel>::value_type, typename channel_traits<DstChannel>::value_type>()(src); } /// \ingroup ChannelConvertAlgorithm /// \brief Same as channel_converter, except it takes the destination channel by reference, which allows /// us to move the templates from the class level to the method level. This is important when invoking it /// on heterogeneous pixels. struct default_channel_converter { template <typename Ch1, typename Ch2> void operator()(const Ch1& src, Ch2& dst) const { dst=channel_convert<Ch2>(src); } }; namespace detail { // fast integer division by 255 inline uint32_t div255(uint32_t in) { uint32_t tmp=in+128; return (tmp + (tmp>>8))>>8; } // fast integer divison by 32768 inline uint32_t div32768(uint32_t in) { return (in+16384)>>15; } } /// \defgroup ChannelMultiplyAlgorithm channel_multiply /// \ingroup ChannelAlgorithm /// \brief Multiplying unsigned channel values of the same type. Performs scaled multiplication result = a * b / max_value /// /// Example: /// \code /// uint8_t x=128; /// uint8_t y=128; /// uint8_t mul = channel_multiply(x,y); /// assert(mul == 64); // 64 = 128 * 128 / 255 /// \endcode /// @{ /// \brief This is the default implementation. Performance specializatons are provided template <typename ChannelValue> struct channel_multiplier_unsigned { using first_argument_type = ChannelValue; using second_argument_type = ChannelValue; using result_type = ChannelValue; ChannelValue operator()(ChannelValue a, ChannelValue b) const { return ChannelValue(static_cast<typename base_channel_type<ChannelValue>::type>(a / double(channel_traits<ChannelValue>::max_value()) * b)); } }; /// \brief Specialization of channel_multiply for 8-bit unsigned channels template<> struct channel_multiplier_unsigned<uint8_t> { using first_argument_type = uint8_t; using second_argument_type = uint8_t; using result_type = uint8_t; uint8_t operator()(uint8_t a, uint8_t b) const { return uint8_t(detail::div255(uint32_t(a) * uint32_t(b))); } }; /// \brief Specialization of channel_multiply for 16-bit unsigned channels template<> struct channel_multiplier_unsigned<uint16_t> { using first_argument_type = uint16_t; using second_argument_type = uint16_t; using result_type = uint16_t; uint16_t operator()(uint16_t a, uint16_t b) const { return uint16_t((uint32_t(a) * uint32_t(b))/65535); } }; /// \brief Specialization of channel_multiply for float 0..1 channels template<> struct channel_multiplier_unsigned<float32_t> { using first_argument_type = float32_t; using second_argument_type = float32_t; using result_type = float32_t; float32_t operator()(float32_t a, float32_t b) const { return ab; } }; /// \brief A function object to multiply two channels. result = a b / max_value template <typename ChannelValue> struct channel_multiplier { using first_argument_type = ChannelValue; using second_argument_type = ChannelValue; using result_type = ChannelValue; ChannelValue operator()(ChannelValue a, ChannelValue b) const { using to_unsigned = detail::channel_convert_to_unsigned<ChannelValue>; using from_unsigned = detail::channel_convert_from_unsigned<ChannelValue>; using multiplier_unsigned = channel_multiplier_unsigned<typename to_unsigned::result_type>; return from_unsigned()(multiplier_unsigned()(to_unsigned()(a), to_unsigned()(b))); } }; /// \brief A function multiplying two channels. result = a * b / max_value template <typename Channel> // Models ChannelConcept (could be a channel reference) inline typename channel_traits<Channel>::value_type channel_multiply(Channel a, Channel b) { return channel_multiplier<typename channel_traits<Channel>::value_type>()(a,b); } /// @} /// \defgroup ChannelInvertAlgorithm channel_invert /// \ingroup ChannelAlgorithm /// \brief Returns the inverse of a channel. result = max_value - x + min_value /// /// Example: /// \code /// // uint8_t == uint8_t == unsigned char /// uint8_t x=255; /// uint8_t inv = channel_invert(x); /// assert(inv == 0); /// \endcode /// \brief Default implementation. Provide overloads for performance /// \ingroup ChannelInvertAlgorithm channel_invert template <typename Channel> // Models ChannelConcept (could be a channel reference) inline typename channel_traits<Channel>::value_type channel_invert(Channel x) { using base_t = typename base_channel_type<Channel>::type; using promoted_t = typename promote_integral<base_t>::type; promoted_t const promoted_x = x; promoted_t const promoted_max = channel_traits<Channel>::max_value(); promoted_t const promoted_min = channel_traits<Channel>::min_value(); promoted_t const promoted_inverted_x = promoted_max - promoted_x + promoted_min; auto const inverted_x = static_cast<base_t>(promoted_inverted_x); return inverted_x; } } } // namespace boost::gil #endif PK��p�[�P�`��iterator_from_2d.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_ITERATOR_FROM_2D_HPP #define BOOST_GIL_ITERATOR_FROM_2D_HPP #include <boost/gil/concepts.hpp> #include <boost/gil/locator.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/gil/point.hpp> #include <boost/assert.hpp> #include <boost/iterator/iterator_facade.hpp> namespace boost { namespace gil { /// pixel step iterator, pixel image iterator and pixel dereference iterator //////////////////////////////////////////////////////////////////////////////////////// /// /// ITERATOR FROM 2D ADAPTOR /// //////////////////////////////////////////////////////////////////////////////////////// /// \defgroup PixelIteratorModelFromLocator iterator_from_2d /// \ingroup PixelIteratorModel /// \brief An iterator over two-dimensional locator. Useful for iterating over the pixels of an image view. Models PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept /// \ingroup PixelIteratorModelFromLocator PixelBasedModel /// \brief Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept /// /// Pixels are traversed from the top to the bottom row and from the left to the right /// within each row template <typename Loc2> // Models PixelLocatorConcept class iterator_from_2d : public iterator_facade<iterator_from_2d<Loc2>, typename Loc2::value_type, std::random_access_iterator_tag, typename Loc2::reference, typename Loc2::coord_t> { BOOST_GIL_CLASS_REQUIRE(Loc2, boost::gil, PixelLocatorConcept) public: using parent_t = iterator_facade<iterator_from_2d<Loc2>, typename Loc2::value_type, std::random_access_iterator_tag, typename Loc2::reference, typename Loc2::coord_t>; using reference = typename parent_t::reference; using difference_type = typename parent_t::difference_type; using x_iterator = typename Loc2::x_iterator; using point_t = typename Loc2::point_t; std::ptrdiff_t width() const { return _width; } // number of pixels per image row std::ptrdiff_t x_pos() const { return _coords.x; } // current x position std::ptrdiff_t y_pos() const { return _coords.y; } // current y position /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { return (this+d); } bool is_1d_traversable() const { return _p.is_1d_traversable(width()); } // is there no gap at the end of each row? x_iterator& x() { return _p.x(); } iterator_from_2d() = default; iterator_from_2d(const Loc2& p, std::ptrdiff_t width, std::ptrdiff_t x=0, std::ptrdiff_t y=0) : _coords(x,y), _width(width), _p(p) {} iterator_from_2d(const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {} template <typename Loc> iterator_from_2d(const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {} iterator_from_2d& operator=(iterator_from_2d const& other) = default; private: template <typename Loc> friend class iterator_from_2d; friend class boost::iterator_core_access; reference dereference() const { return _p; } void increment() { ++_coords.x; ++_p.x(); if (_coords.x>=_width) { _coords.x=0; ++_coords.y; _p+=point_t(-_width,1); } } void decrement() { --_coords.x; --_p.x(); if (_coords.x<0) { _coords.x=_width-1; --_coords.y; _p+=point_t(_width,-1); } } BOOST_FORCEINLINE void advance(difference_type d) { if (_width==0) return; // unfortunately we need to check for that. Default-constructed images have width of 0 and the code below will throw if executed. point_t delta; if (_coords.x+d>=0) { // not going back to a previous row? delta.x=(_coords.x+(std::ptrdiff_t)d)%_width - _coords.x; delta.y=(_coords.x+(std::ptrdiff_t)d)/_width; } else { delta.x=(_coords.x+(std::ptrdiff_t)d(1-_width))%_width -_coords.x; delta.y=-(_width-_coords.x-(std::ptrdiff_t)d-1)/_width; } _p+=delta; _coords.x+=delta.x; _coords.y+=delta.y; } difference_type distance_to(const iterator_from_2d& it) const { if (_width==0) return 0; return (it.y_pos()-_coords.y)_width + (it.x_pos()-_coords.x); } bool equal(iterator_from_2d const& it) const { BOOST_ASSERT(_width == it.width()); // they must belong to the same image return _coords == it._coords && _p == it._p; } point_t _coords; std::ptrdiff_t _width; Loc2 _p; }; template <typename Loc> // Models PixelLocatorConcept struct const_iterator_type<iterator_from_2d<Loc> > { using type = iterator_from_2d<typename Loc::const_t>; }; template <typename Loc> // Models PixelLocatorConcept struct iterator_is_mutable<iterator_from_2d<Loc> > : public iterator_is_mutable<typename Loc::x_iterator> {}; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename Loc> struct dynamic_x_step_type<iterator_from_2d<Loc> > { using type = iterator_from_2d<typename dynamic_x_step_type<Loc>::type>; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename Loc> // Models PixelLocatorConcept struct color_space_type<iterator_from_2d<Loc> > : public color_space_type<Loc> {}; template <typename Loc> // Models PixelLocatorConcept struct channel_mapping_type<iterator_from_2d<Loc> > : public channel_mapping_type<Loc> {}; template <typename Loc> // Models PixelLocatorConcept struct is_planar<iterator_from_2d<Loc> > : public is_planar<Loc> {}; template <typename Loc> // Models PixelLocatorConcept struct channel_type<iterator_from_2d<Loc> > : public channel_type<Loc> {}; } } // namespace boost::gil #endif PK��p�[fp�]�6��6��image_view.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_VIEW_HPP #define BOOST_GIL_IMAGE_VIEW_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/iterator_from_2d.hpp> #include <boost/assert.hpp> #include <cstddef> #include <iterator> namespace boost { namespace gil { //////////////////////////////////////////////////////////////////////////////////////// /// \class image_view /// \ingroup ImageViewModel PixelBasedModel /// \brief A lightweight object that interprets memory as a 2D array of pixels. Models ImageViewConcept,PixelBasedConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept /// /// Image view consists of a pixel 2D locator (defining the mechanism for navigating in 2D) /// and the image dimensions. /// /// Image views to images are what ranges are to STL containers. They are lightweight objects, /// that don't own the pixels. It is the user's responsibility that the underlying data remains /// valid for the lifetime of the image view. /// /// Similar to iterators and ranges, constness of views does not extend to constness of pixels. /// A const \p image_view does not allow changing its location in memory (resizing, moving) but does /// not prevent one from changing the pixels. The latter requires an image view whose value_type /// is const. /// /// Images have interfaces consistent with STL 1D random access containers, so they can be used /// directly in STL algorithms like: /// \code /// std::fill(img.begin(), img.end(), red_pixel); /// \endcode /// /// In addition, horizontal, vertical and 2D random access iterators are provided. /// /// Note also that \p image_view does not require that its element type be a pixel. It could be /// instantiated with a locator whose \p value_type models only \p Regular. In this case the image /// view models the weaker RandomAccess2DImageViewConcept, and does not model PixelBasedConcept. /// Many generic algorithms don't require the elements to be pixels. /// //////////////////////////////////////////////////////////////////////////////////////// template <typename Loc> // Models 2D Pixel Locator class image_view { public: // aliases required by ConstRandomAccessNDImageViewConcept static const std::size_t num_dimensions=2; using value_type = typename Loc::value_type; using reference = typename Loc::reference; // result of dereferencing using coord_t = typename Loc::coord_t; // 1D difference type (same for all dimensions) using difference_type = coord_t; // result of operator-(1d_iterator,1d_iterator) using point_t = typename Loc::point_t; using locator = Loc; using const_t = image_view<typename Loc::const_t>; // same as this type, but over const values template <std::size_t D> struct axis { using coord_t = typename Loc::template axis<D>::coord_t; // difference_type along each dimension using iterator = typename Loc::template axis<D>::iterator; // 1D iterator type along each dimension }; using iterator = iterator_from_2d<Loc>; // 1D iterator type for each pixel left-to-right inside top-to-bottom using const_iterator = typename const_t::iterator; // may be used to examine, but not to modify values using const_reference = typename const_t::reference; // behaves as a const reference using pointer = typename std::iterator_traits<iterator>::pointer; // behaves as a pointer to the value type using reverse_iterator = std::reverse_iterator<iterator>; using size_type = std::size_t; // aliases required by ConstRandomAccess2DImageViewConcept using xy_locator = locator; using x_iterator = typename xy_locator::x_iterator; // pixel iterator along a row using y_iterator = typename xy_locator::y_iterator; // pixel iterator along a column using x_coord_t = typename xy_locator::x_coord_t; using y_coord_t = typename xy_locator::y_coord_t; template <typename Deref> struct add_deref { using type = image_view<typename Loc::template add_deref<Deref>::type>; static type make(image_view<Loc> const& view, Deref const& d) { return type(view.dimensions(), Loc::template add_deref<Deref>::make(view.pixels(), d)); } }; image_view() : _dimensions(0,0) {} image_view(image_view const& img_view) : _dimensions(img_view.dimensions()), _pixels(img_view.pixels()) {} template <typename View> image_view(View const& view) : _dimensions(view.dimensions()), _pixels(view.pixels()) {} template <typename L2> image_view(point_t const& dims, L2 const& loc) : _dimensions(dims), _pixels(loc) {} template <typename L2> image_view(coord_t width, coord_t height, L2 const& loc) : _dimensions(x_coord_t(width), y_coord_t(height)), _pixels(loc) {} template <typename View> image_view& operator=(View const& view) { _pixels = view.pixels(); _dimensions = view.dimensions(); return this; } image_view& operator=(image_view const& view) { // TODO: Self-assignment protection? _pixels = view.pixels(); _dimensions = view.dimensions(); return this; } template <typename View> bool operator==(View const &view) const { return pixels() == view.pixels() && dimensions() == view.dimensions(); } template <typename View> bool operator!=(View const& view) const { return !(this == view); } template <typename L2> friend void swap(image_view<L2> &lhs, image_view<L2> &rhs); /// \brief Exchanges the elements of the current view with those of \a other /// in constant time. /// /// \note Required by the Collection concept /// \see https://www.boost.org/libs/utility/Collection.html void swap(image_view<Loc>& other) { using boost::gil::swap; swap(this, other); } auto dimensions() const -> point_t const& { return _dimensions; } auto pixels() const -> locator const& { return _pixels; } auto width() const -> x_coord_t { return dimensions().x; } auto height() const -> y_coord_t { return dimensions().y; } auto num_channels() const -> std::size_t { return gil::num_channels<value_type>::value; } bool is_1d_traversable() const { return _pixels.is_1d_traversable(width()); } /// \brief Returns true if the view has no elements, false otherwise. /// /// \note Required by the Collection concept /// \see https://www.boost.org/libs/utility/Collection.html bool empty() const { return !(width() > 0 && height() > 0); } /// \brief Returns a reference to the first element in raster order. /// /// \note Required by the ForwardCollection, since view model the concept. /// \see https://www.boost.org/libs/utility/Collection.html auto front() const -> reference { BOOST_ASSERT(!empty()); return begin(); } /// \brief Returns a reference to the last element in raster order. /// /// \note Required by the ForwardCollection, since view model the concept. /// \see https://www.boost.org/libs/utility/Collection.html auto back() const -> reference { BOOST_ASSERT(!empty()); return rbegin(); } //\{@ /// \name 1D navigation auto size() const -> size_type { return width() height(); } auto begin() const -> iterator { return iterator(_pixels, _dimensions.x); } auto end() const -> iterator { // potential performance problem! return begin() + static_cast<difference_type>(size()); } auto rbegin() const -> reverse_iterator { return reverse_iterator(end()); } auto rend() const -> reverse_iterator { return reverse_iterator(begin()); } auto operator[](difference_type i) const -> reference { BOOST_ASSERT(i < static_cast<difference_type>(size())); return begin()[i]; // potential performance problem! } auto at(difference_type i) const -> iterator { // UB if the specified increment advances non-incrementable iterator (i.e. past-the-end) BOOST_ASSERT(i < static_cast<difference_type>(size())); return begin() + i; } auto at(point_t const& p) const -> iterator { // UB if the specified coordinates advance non-incrementable iterator (i.e. past-the-end) BOOST_ASSERT(0 <= p.x && p.x < width()); BOOST_ASSERT(0 <= p.y && p.y < height()); return begin() + p.y * width() + p.x; } auto at(x_coord_t x, y_coord_t y) const -> iterator { // UB if the specified coordinates advance non-incrementable iterator (i.e. past-the-end) BOOST_ASSERT(0 <= x && x < width()); BOOST_ASSERT(0 <= y && y < height()); return begin() + y * width() + x; } //\}@ //\{@ /// \name 2-D navigation auto operator()(point_t const& p) const -> reference { BOOST_ASSERT(0 <= p.x && p.x < width()); BOOST_ASSERT(0 <= p.y && p.y < height()); return _pixels(p.x, p.y); } auto operator()(x_coord_t x, y_coord_t y) const -> reference { BOOST_ASSERT(0 <= x && x < width()); BOOST_ASSERT(0 <= y && y < height()); return _pixels(x, y); } template <std::size_t D> auto axis_iterator(point_t const& p) const -> typename axis<D>::iterator { // Allow request for iterators from inclusive range of [begin, end] BOOST_ASSERT(0 <= p.x && p.x <= width()); BOOST_ASSERT(0 <= p.y && p.y <= height()); return _pixels.template axis_iterator<D>(p); } auto xy_at(x_coord_t x, y_coord_t y) const -> xy_locator { // TODO: Are relative locations of neighbors with negative offsets valid? Sampling? BOOST_ASSERT(x < width()); BOOST_ASSERT(y <= height()); return _pixels + point_t(x, y); } auto xy_at(point_t const& p) const -> xy_locator { // TODO: Are relative locations of neighbors with negative offsets valid? Sampling? BOOST_ASSERT(p.x < width()); BOOST_ASSERT(p.y < height()); return _pixels + p; } //\}@ //\{@ /// \name X navigation auto x_at(x_coord_t x, y_coord_t y) const -> x_iterator { BOOST_ASSERT(0 <= x && x <= width()); // allow request for [begin, end] inclusive BOOST_ASSERT(0 <= y && y < height()); // TODO: For empty image/view, shouldn't we accept: row_begin(0) == view.row_end(0) ? return _pixels.x_at(x, y); } auto x_at(point_t const& p) const -> x_iterator { BOOST_ASSERT(0 <= p.x && p.x <= width()); // allow request for [begin, end] inclusive BOOST_ASSERT(0 <= p.y && p.y < height()); // TODO: For empty image/view, shouldn't we accept: row_begin(0) == view.row_end(0) ? return _pixels.x_at(p); } auto row_begin(y_coord_t y) const -> x_iterator { BOOST_ASSERT(0 <= y && y < height()); return x_at(0, y); } auto row_end(y_coord_t y) const -> x_iterator { BOOST_ASSERT(0 <= y && y < height()); return x_at(width(), y); } //\}@ //\{@ /// \name Y navigation auto y_at(x_coord_t x, y_coord_t y) const -> y_iterator { BOOST_ASSERT(0 <= x && x < width()); // TODO: For empty image/view, shouldn't we accept: view.col_begin(0) == view.col_end(0) ? BOOST_ASSERT(0 <= y && y <= height()); // allow request for [begin, end] inclusive return xy_at(x, y).y(); } auto y_at(point_t const& p) const -> y_iterator { BOOST_ASSERT(0 <= p.x && p.x < width()); // TODO: For empty image/view, shouldn't we accept: view.col_begin(0) == view.col_end(0) ? BOOST_ASSERT(0 <= p.y && p.y <= height()); // allow request for [begin, end] inclusive return xy_at(p).y(); } auto col_begin(x_coord_t x) const -> y_iterator { BOOST_ASSERT(0 <= x && x < width()); return y_at(x, 0); } auto col_end(x_coord_t x) const -> y_iterator { BOOST_ASSERT(0 <= x && x < width()); return y_at(x, height()); } //\}@ private: template <typename L2> friend class image_view; point_t _dimensions; xy_locator _pixels; }; template <typename L2> inline void swap(image_view<L2>& x, image_view<L2>& y) { using std::swap; swap(x._dimensions,y._dimensions); swap(x._pixels, y._pixels); // TODO: Extend further } ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename L> struct channel_type<image_view<L> > : public channel_type<L> {}; template <typename L> struct color_space_type<image_view<L> > : public color_space_type<L> {}; template <typename L> struct channel_mapping_type<image_view<L> > : public channel_mapping_type<L> {}; template <typename L> struct is_planar<image_view<L> > : public is_planar<L> {}; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename L> struct dynamic_x_step_type<image_view<L>> { using type = image_view<typename gil::dynamic_x_step_type<L>::type>; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template <typename L> struct dynamic_y_step_type<image_view<L>> { using type = image_view<typename gil::dynamic_y_step_type<L>::type>; }; ///////////////////////////// // HasTransposedTypeConcept ///////////////////////////// template <typename L> struct transposed_type<image_view<L>> { using type = image_view<typename transposed_type<L>::type>; }; }} // namespace boost::gil #endif PK��p�[��W�O��O�� image.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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 = false, typename Alloc=std::allocator<unsigned char> > 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; const point_t& 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(const point_t& 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(const point_t& 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); } // 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); swap(_alloc, img._alloc); swap(_allocated_bytes, img._allocated_bytes ); } ///////////////////// // recreate ///////////////////// // without Allocator void recreate(const point_t& 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(const point_t& 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(const point_t& 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(const point_t& 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(const point_t& 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(const point_t& 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 = widthmemunit_step(typename view_t::x_iterator()); if (_align_in_bytes>0) { std::size_t alignment_in_memunits=_align_in_bytesbyte_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); _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_sizedimensions.y; _allocated_bytes = total_allocated_size_in_bytes( dimensions ); _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_sizedims.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 const typename image<Pixel,IsPlanar,Alloc>::view_t& view(image<Pixel,IsPlanar,Alloc>& img) { return img._view; } /// \brief Returns the constant-pixel view of an image template <typename Pixel, bool IsPlanar, typename Alloc> inline const typename image<Pixel,IsPlanar,Alloc>::const_view_t const_view(const image<Pixel,IsPlanar,Alloc>& img) { 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 PK��p�[�o��&��&��planar_pixel_reference.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_PLANAR_PIXEL_REFERENCE_HPP #define BOOST_GIL_PLANAR_PIXEL_REFERENCE_HPP #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/concepts.hpp> #include <boost/gil/pixel.hpp> #include <boost/gil/planar_pixel_iterator.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost { namespace gil { /// \defgroup ColorBaseModelPlanarRef planar_pixel_reference /// \ingroup ColorBaseModel /// \brief A homogeneous color base whose element is a channel reference. Models HomogeneousColorBaseConcept, HomogeneousPixelConcept. /// This class is used as a reference proxy to a planar pixel. /// \defgroup PixelModelPlanarRef planar_pixel_reference /// \ingroup PixelModel /// \brief A reference proxy to a planar pixel. Models HomogeneousColorBaseConcept, HomogeneousPixelConcept. /// \ingroup PixelModelPlanarRef ColorBaseModelPlanarRef PixelBasedModel /// \brief A reference proxy to a planar pixel. /// /// A reference to a planar pixel is a proxy class containing references to each of the corresponding channels. /// Models: HomogeneousColorBaseConcept, HomogeneousPixelConcept /// /// \tparam ChannelReference A channel reference, either const or mutable /// \tparam ColorSpace template <typename ChannelReference, typename ColorSpace> struct planar_pixel_reference : detail::homogeneous_color_base < ChannelReference, layout<ColorSpace>, mp11::mp_size<ColorSpace>::value > { using parent_t =detail::homogeneous_color_base < ChannelReference, layout<ColorSpace>, mp11::mp_size<ColorSpace>::value >; private: // These three are only defined for homogeneous pixels using channel_t = typename channel_traits<ChannelReference>::value_type; using channel_const_reference = typename channel_traits<ChannelReference>::const_reference; public: static constexpr bool is_mutable = channel_traits<ChannelReference>::is_mutable; using value_type = pixel<channel_t,layout<ColorSpace>>; using reference = planar_pixel_reference<ChannelReference, ColorSpace>; using const_reference = planar_pixel_reference<channel_const_reference,ColorSpace>; planar_pixel_reference(ChannelReference v0, ChannelReference v1) : parent_t(v0, v1) {} planar_pixel_reference(ChannelReference v0, ChannelReference v1, ChannelReference v2) : parent_t(v0, v1, v2) {} planar_pixel_reference(ChannelReference v0, ChannelReference v1, ChannelReference v2, ChannelReference v3) : parent_t(v0, v1, v2, v3) {} planar_pixel_reference(ChannelReference v0, ChannelReference v1, ChannelReference v2, ChannelReference v3, ChannelReference v4) : parent_t(v0, v1, v2, v3, v4) {} planar_pixel_reference(ChannelReference v0, ChannelReference v1, ChannelReference v2, ChannelReference v3, ChannelReference v4, ChannelReference v5) : parent_t(v0, v1, v2, v3, v4, v5) {} planar_pixel_reference(planar_pixel_reference const& p) : parent_t(p) {} // TODO: What is the purpose of returning via const reference? auto operator=(planar_pixel_reference const& p) const -> planar_pixel_reference const& { static_copy(p, this); return this; } template <typename Pixel> planar_pixel_reference(Pixel const& p) : parent_t(p) { check_compatible<Pixel>(); } // TODO: What is the purpose of returning via const reference? template <typename Pixel> auto operator=(Pixel const& p) const -> planar_pixel_reference const& { check_compatible<Pixel>(); static_copy(p, this); return this; } // PERFORMANCE_CHECK: Is this constructor necessary? template <typename ChannelV, typename Mapping> planar_pixel_reference(pixel<ChannelV, layout<ColorSpace, Mapping>>& p) : parent_t(p) { check_compatible<pixel<ChannelV, layout<ColorSpace, Mapping>>>(); } // Construct at offset from a given location template <typename ChannelPtr> planar_pixel_reference(planar_pixel_iterator<ChannelPtr, ColorSpace> const& p, std::ptrdiff_t diff) : parent_t(p, diff) {} // This overload is necessary for a compiler implementing Core Issue 574 // to prevent generation of an implicit copy assignment operator (the reason // for generating implicit copy assignment operator is that according to // Core Issue 574, a cv-qualified assignment operator is not considered // "copy assignment operator"). // EDG implemented Core Issue 574 starting with EDG Version 3.8. I'm not // sure why they did it for a template member function as well. #if BOOST_WORKAROUND(__HP_aCC, >= 61700) \|\| BOOST_WORKAROUND(__INTEL_COMPILER, >= 1000) const planar_pixel_reference& operator=(const planar_pixel_reference& p) { static_copy(p,this); return this; } template <typename P> const planar_pixel_reference& operator=(const P& p) { check_compatible<P>(); static_copy(p,this); return this; } #endif template <typename Pixel> bool operator==(Pixel const& p) const { check_compatible<Pixel>(); return static_equal(this, p); } template <typename Pixel> bool operator!=(Pixel const &p) const { return !(this == p); } auto operator[](std::size_t i) const -> ChannelReference { return this->at_c_dynamic(i); } auto operator->() const -> planar_pixel_reference const* { return this; } private: template <typename Pixel> static void check_compatible() { gil_function_requires<PixelsCompatibleConcept<Pixel, planar_pixel_reference>>(); } }; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template <typename ChannelReference, typename ColorSpace, int K> struct kth_element_type<planar_pixel_reference<ChannelReference, ColorSpace>, K> { using type = ChannelReference; }; template <typename ChannelReference, typename ColorSpace, int K> struct kth_element_reference_type < planar_pixel_reference<ChannelReference, ColorSpace>, K > { using type = ChannelReference; }; template <typename ChannelReference, typename ColorSpace, int K> struct kth_element_const_reference_type < planar_pixel_reference<ChannelReference, ColorSpace>, K > : std::add_lvalue_reference<typename std::add_const<ChannelReference>::type> { // using type = typename channel_traits<ChannelReference>::const_reference; }; ///////////////////////////// // PixelConcept ///////////////////////////// /// \brief Metafunction predicate that flags planar_pixel_reference as a model of PixelConcept. Required by PixelConcept /// \ingroup PixelModelPlanarRef template <typename ChannelReference, typename ColorSpace> struct is_pixel< planar_pixel_reference<ChannelReference, ColorSpace>> : std::true_type {}; ///////////////////////////// // HomogeneousPixelBasedConcept ///////////////////////////// /// \brief Specifies the color space type of a planar pixel reference. Required by PixelBasedConcept /// \ingroup PixelModelPlanarRef template <typename ChannelReference, typename ColorSpace> struct color_space_type<planar_pixel_reference<ChannelReference,ColorSpace> > { using type = ColorSpace; }; /// \brief Specifies the color space type of a planar pixel reference. Required by PixelBasedConcept /// \ingroup PixelModelPlanarRef template <typename ChannelReference, typename ColorSpace> struct channel_mapping_type<planar_pixel_reference<ChannelReference,ColorSpace> > { using type = typename layout<ColorSpace>::channel_mapping_t; }; /// \brief Specifies that planar_pixel_reference represents a planar construct. Required by PixelBasedConcept /// \ingroup PixelModelPlanarRef template <typename ChannelReference, typename ColorSpace> struct is_planar<planar_pixel_reference<ChannelReference, ColorSpace>> : std::true_type {}; /// \brief Specifies the color space type of a planar pixel reference. Required by HomogeneousPixelBasedConcept /// \ingroup PixelModelPlanarRef template <typename ChannelReference, typename ColorSpace> struct channel_type<planar_pixel_reference<ChannelReference,ColorSpace> > { using type = typename channel_traits<ChannelReference>::value_type; }; }} // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy // Having three overloads allows us to swap between different (but compatible) models of PixelConcept /// \brief swap for planar_pixel_reference /// \ingroup PixelModelPlanarRef template <typename CR, typename CS, typename R> inline void swap(const boost::gil::planar_pixel_reference<CR,CS> x, R& y) { boost::gil::swap_proxy<typename boost::gil::planar_pixel_reference<CR,CS>::value_type>(x,y); } /// \brief swap for planar_pixel_reference /// \ingroup PixelModelPlanarRef template <typename CR, typename CS> inline void swap(typename boost::gil::planar_pixel_reference<CR,CS>::value_type& x, const boost::gil::planar_pixel_reference<CR,CS> y) { boost::gil::swap_proxy<typename boost::gil::planar_pixel_reference<CR,CS>::value_type>(x,y); } /// \brief swap for planar_pixel_reference /// \ingroup PixelModelPlanarRef template <typename CR, typename CS> inline void swap(const boost::gil::planar_pixel_reference<CR,CS> x, const boost::gil::planar_pixel_reference<CR,CS> y) { boost::gil::swap_proxy<typename boost::gil::planar_pixel_reference<CR,CS>::value_type>(x,y); } } // namespace std #endif PK��p�[�e#�u��u�� algorithm.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_ALGORITHM_HPP #define BOOST_GIL_ALGORITHM_HPP #include <boost/gil/bit_aligned_pixel_iterator.hpp> #include <boost/gil/color_base_algorithm.hpp> #include <boost/gil/concepts.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/image_view_factory.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/detail/type_traits.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <algorithm> #include <cstddef> #include <cstring> #include <iterator> #include <memory> #include <type_traits> #include <typeinfo> namespace boost { namespace gil { //forward declarations template <typename ChannelPtr, typename ColorSpace> struct planar_pixel_iterator; template <typename Iterator> class memory_based_step_iterator; template <typename StepIterator> class memory_based_2d_locator; // a tag denoting incompatible arguments struct error_t {}; /// \defgroup ImageViewSTLAlgorithms STL-like Algorithms /// \ingroup ImageViewAlgorithm /// \brief Image view-equivalents of STL algorithms /// /// Image views provide 1D iteration of their pixels via \p begin() and \p end() methods, /// which makes it possible to use STL algorithms with them. However, using nested loops /// over X and Y is in many cases more efficient. The algorithms in this section resemble /// STL algorithms, but they abstract away the nested loops and take views (as opposed to ranges) as input. /// /// Most algorithms check whether the image views are 1D-traversable. A 1D-traversable image view has no gaps /// at the end of the rows. In other words, if an x_iterator of that view is advanced past the last pixel in a row /// it will move to the first pixel of the next row. When image views are 1D-traversable, the algorithms use /// a single loop and run more efficiently. If one or more of the input views are not 1D-traversable, the algorithms /// fall-back to an X-loop nested inside a Y-loop. /// /// The algorithms typically delegate the work to their corresponding STL algorithms. For example, \p copy_pixels calls /// \p std::copy either for each row, or, when the images are 1D-traversable, once for all pixels. /// /// In addition, overloads are sometimes provided for the STL algorithms. For example, std::copy for planar iterators /// is overloaded to perform \p std::copy for each of the planes. \p std::copy over bitwise-copiable pixels results in /// std::copy over unsigned char, which STL typically implements via \p memmove. /// /// As a result \p copy_pixels may result in a single call to \p memmove for interleaved 1D-traversable views, /// or one per each plane of planar 1D-traversable views, or one per each row of interleaved non-1D-traversable images, etc. /// \defgroup STLOptimizations Performance overloads of STL algorithms /// \ingroup ImageViewAlgorithm /// \brief overloads of STL algorithms allowing more efficient implementation when used with GIL constructs /// \brief A generic binary operation on views /// \ingroup ImageViewSTLAlgorithms /// /// Use this class as a convenience superclass when defining an operation for any image views. /// Many operations have different behavior when the two views are compatible. This class checks /// for compatibility and invokes apply_compatible(V1,V2) or apply_incompatible(V1,V2) of the subclass. /// You must provide apply_compatible(V1,V2) method in your subclass, but apply_incompatible(V1,V2) /// is not required and the default throws std::bad_cast. template <typename Derived, typename Result=void> struct binary_operation_obj { using result_type = Result; template <typename V1, typename V2> BOOST_FORCEINLINE result_type operator()(const std::pair<const V1,const V2>& p) const { return apply(p.first, p.second, typename views_are_compatible<V1,V2>::type()); } template <typename V1, typename V2> BOOST_FORCEINLINE result_type operator()(const V1& v1, const V2& v2) const { return apply(v1, v2, typename views_are_compatible<V1,V2>::type()); } result_type operator()(const error_t&) const { throw std::bad_cast(); } private: // dispatch from apply overload to a function with distinct name template <typename V1, typename V2> BOOST_FORCEINLINE result_type apply(V1 const& v1, V2 const& v2, std::false_type) const { return ((const Derived)this)->apply_incompatible(v1, v2); } // dispatch from apply overload to a function with distinct name template <typename V1, typename V2> BOOST_FORCEINLINE result_type apply(V1 const& v1, V2 const& v2, std::true_type) const { return ((const Derived)this)->apply_compatible(v1, v2); } // function with distinct name - it can be overloaded by subclasses template <typename V1, typename V2> BOOST_FORCEINLINE result_type apply_incompatible(V1 const& /v1/, V2 const& /v2/) const { throw std::bad_cast(); } }; }} // namespace boost::gil ////////////////////////////////////////////////////////////////////////////////////// // std::copy and gil::copy_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsCopyPixels copy_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::copy for image views namespace std { /// \ingroup STLOptimizations /// \brief Copy when both src and dst are interleaved and of the same type can be just memmove template<typename T, typename CS> BOOST_FORCEINLINE auto copy( boost::gil::pixel<T, CS>* first, boost::gil::pixel<T, CS>* last, boost::gil::pixel<T, CS>* dst) -> boost::gil::pixel<T, CS>* { auto p = std::copy((unsigned char)first, (unsigned char)last, (unsigned char)dst); return reinterpret_cast<boost::gil::pixel<T, CS>>(p); } /// \ingroup STLOptimizations /// \brief Copy when both src and dst are interleaved and of the same type can be just memmove template<typename T, typename CS> BOOST_FORCEINLINE boost::gil::pixel<T,CS>* copy(const boost::gil::pixel<T,CS>* first, const boost::gil::pixel<T,CS>* last, boost::gil::pixel<T,CS>* dst) { return (boost::gil::pixel<T,CS>)std::copy((unsigned char)first,(unsigned char)last, (unsigned char)dst); } } // namespace std namespace boost { namespace gil { namespace detail { template <typename I, typename O> struct copy_fn { BOOST_FORCEINLINE I operator()(I first, I last, O dst) const { return std::copy(first,last,dst); } }; } // namespace detail } } // namespace boost::gil namespace std { /// \ingroup STLOptimizations /// \brief Copy when both src and dst are planar pointers is copy for each channel template<typename CS, typename IC1, typename IC2> BOOST_FORCEINLINE boost::gil::planar_pixel_iterator<IC2,CS> copy(boost::gil::planar_pixel_iterator<IC1,CS> first, boost::gil::planar_pixel_iterator<IC1,CS> last, boost::gil::planar_pixel_iterator<IC2,CS> dst) { boost::gil::gil_function_requires<boost::gil::ChannelsCompatibleConcept<typename std::iterator_traits<IC1>::value_type,typename std::iterator_traits<IC2>::value_type>>(); static_for_each(first,last,dst,boost::gil::detail::copy_fn<IC1,IC2>()); return dst+(last-first); } } // namespace std namespace boost { namespace gil { namespace detail { /// Does a copy-n. If the inputs contain image iterators, performs a copy at each row using the row iterators /// \ingroup CopyPixels template <typename I, typename O> struct copier_n { BOOST_FORCEINLINE void operator()(I src, typename std::iterator_traits<I>::difference_type n, O dst) const { std::copy(src,src+n, dst); } }; /// Source range is delimited by image iterators template <typename IL, typename O> // IL Models ConstPixelLocatorConcept, O Models PixelIteratorConcept struct copier_n<iterator_from_2d<IL>,O> { using diff_t = typename std::iterator_traits<iterator_from_2d<IL>>::difference_type; BOOST_FORCEINLINE void operator()(iterator_from_2d<IL> src, diff_t n, O dst) const { gil_function_requires<PixelLocatorConcept<IL>>(); gil_function_requires<MutablePixelIteratorConcept<O>>(); while (n>0) { diff_t l=src.width()-src.x_pos(); diff_t numToCopy=(n<l ? n:l); detail::copy_n(src.x(), numToCopy, dst); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; /// Destination range is delimited by image iterators template <typename I, typename OL> // I Models ConstPixelIteratorConcept, OL Models PixelLocatorConcept struct copier_n<I,iterator_from_2d<OL>> { using diff_t = typename std::iterator_traits<I>::difference_type; BOOST_FORCEINLINE void operator()(I src, diff_t n, iterator_from_2d<OL> dst) const { gil_function_requires<PixelIteratorConcept<I>>(); gil_function_requires<MutablePixelLocatorConcept<OL>>(); while (n>0) { diff_t l=dst.width()-dst.x_pos(); diff_t numToCopy=(n<l ? n:l); detail::copy_n(src, numToCopy, dst.x()); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; /// Both source and destination ranges are delimited by image iterators template <typename IL, typename OL> struct copier_n<iterator_from_2d<IL>,iterator_from_2d<OL>> { using diff_t = typename iterator_from_2d<IL>::difference_type; BOOST_FORCEINLINE void operator()(iterator_from_2d<IL> src, diff_t n, iterator_from_2d<OL> dst) const { gil_function_requires<PixelLocatorConcept<IL>>(); gil_function_requires<MutablePixelLocatorConcept<OL>>(); if (src.x_pos()!=dst.x_pos() \|\| src.width()!=dst.width()) { while(n-->0) { dst++=src++; } } while (n>0) { diff_t l=dst.width()-dst.x_pos(); diff_t numToCopy=(n<l ? n : l); detail::copy_n(src.x(), numToCopy, dst.x()); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; template <typename SrcIterator, typename DstIterator> BOOST_FORCEINLINE DstIterator copy_with_2d_iterators(SrcIterator first, SrcIterator last, DstIterator dst) { using src_x_iterator = typename SrcIterator::x_iterator; using dst_x_iterator = typename DstIterator::x_iterator; typename SrcIterator::difference_type n = last - first; if (first.is_1d_traversable()) { if (dst.is_1d_traversable()) copier_n<src_x_iterator,dst_x_iterator>()(first.x(),n, dst.x()); else copier_n<src_x_iterator,DstIterator >()(first.x(),n, dst); } else { if (dst.is_1d_traversable()) copier_n<SrcIterator,dst_x_iterator>()(first,n, dst.x()); else copier_n<SrcIterator,DstIterator>()(first,n,dst); } return dst+n; } } // namespace detail } } // namespace boost::gil namespace std { /// \ingroup STLOptimizations /// \brief std::copy(I1,I1,I2) with I1 and I2 being a iterator_from_2d template <typename IL, typename OL> BOOST_FORCEINLINE boost::gil::iterator_from_2d<OL> copy1(boost::gil::iterator_from_2d<IL> first, boost::gil::iterator_from_2d<IL> last, boost::gil::iterator_from_2d<OL> dst) { return boost::gil::detail::copy_with_2d_iterators(first,last,dst); } } // namespace std namespace boost { namespace gil { /// \ingroup ImageViewSTLAlgorithmsCopyPixels /// \brief std::copy for image views template <typename View1, typename View2> BOOST_FORCEINLINE void copy_pixels(const View1& src, const View2& dst) { BOOST_ASSERT(src.dimensions() == dst.dimensions()); detail::copy_with_2d_iterators(src.begin(),src.end(),dst.begin()); } ////////////////////////////////////////////////////////////////////////////////////// // copy_and_convert_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsCopyAndConvertPixels copy_and_convert_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief copies src view into dst view, color converting if necessary. /// /// Versions taking static and runtime views are provided. Versions taking user-defined color convered are provided. namespace detail { template <typename CC> class copy_and_convert_pixels_fn : public binary_operation_obj<copy_and_convert_pixels_fn<CC>> { private: CC _cc; public: using result_type = typename binary_operation_obj<copy_and_convert_pixels_fn<default_color_converter>>::result_type; copy_and_convert_pixels_fn() {} copy_and_convert_pixels_fn(CC cc_in) : _cc(cc_in) {} // when the two color spaces are incompatible, a color conversion is performed template <typename V1, typename V2> BOOST_FORCEINLINE result_type apply_incompatible(const V1& src, const V2& dst) const { copy_pixels(color_converted_view<typename V2::value_type>(src,_cc),dst); } // If the two color spaces are compatible, copy_and_convert is just copy template <typename V1, typename V2> BOOST_FORCEINLINE result_type apply_compatible(const V1& src, const V2& dst) const { copy_pixels(src,dst); } }; } // namespace detail /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels template <typename V1, typename V2,typename CC> BOOST_FORCEINLINE void copy_and_convert_pixels(const V1& src, const V2& dst,CC cc) { detail::copy_and_convert_pixels_fn<CC> ccp(cc); ccp(src,dst); } struct default_color_converter; /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels template <typename View1, typename View2> BOOST_FORCEINLINE void copy_and_convert_pixels(const View1& src, const View2& dst) { detail::copy_and_convert_pixels_fn<default_color_converter> ccp; ccp(src,dst); } } } // namespace boost::gil ////////////////////////////////////////////////////////////////////////////////////// // std::fill and gil::fill_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsFillPixels fill_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::fill for image views namespace std { /// \ingroup STLOptimizations /// \brief std::fill(I,I,V) with I being a iterator_from_2d /// /// Invoked when one calls std::fill(I,I,V) with I being a iterator_from_2d (which is /// a 1D iterator over the pixels in an image). For contiguous images (i.e. images that have /// no alignment gap at the end of each row) it is more efficient to use the underlying /// pixel iterator that does not check for the end of rows. For non-contiguous images fill /// resolves to fill of each row using the underlying pixel iterator, which is still faster template <typename IL, typename V> void fill(boost::gil::iterator_from_2d<IL> first, boost::gil::iterator_from_2d<IL> last, const V& val) { boost::gil::gil_function_requires<boost::gil::MutablePixelLocatorConcept<IL>>(); if (first.is_1d_traversable()) { std::fill(first.x(), last.x(), val); } else { // fill row by row std::ptrdiff_t n=last-first; while (n>0) { std::ptrdiff_t numToDo=std::min<const std::ptrdiff_t>(n,(std::ptrdiff_t)(first.width()-first.x_pos())); std::fill_n(first.x(), numToDo, val); first+=numToDo; n-=numToDo; } } } } // namespace std namespace boost { namespace gil { namespace detail { /// struct to do std::fill struct std_fill_t { template <typename It, typename P> void operator()(It first, It last, const P& p_in) { std::fill(first,last,p_in); } }; /// std::fill for planar iterators template <typename It, typename P> BOOST_FORCEINLINE void fill_aux(It first, It last, P const& p, std::true_type) { static_for_each(first, last, p, std_fill_t()); } /// std::fill for interleaved iterators template <typename It, typename P> BOOST_FORCEINLINE void fill_aux(It first, It last, P const& p, std::false_type) { std::fill(first, last, p); } } // namespace detail /// \ingroup ImageViewSTLAlgorithmsFillPixels /// \brief std::fill for image views template <typename View, typename Value> BOOST_FORCEINLINE void fill_pixels(View const& view, Value const& value) { if (view.is_1d_traversable()) { detail::fill_aux( view.begin().x(), view.end().x(), value, is_planar<View>()); } else { for (std::ptrdiff_t y = 0; y < view.height(); ++y) detail::fill_aux( view.row_begin(y), view.row_end(y), value, is_planar<View>()); } } ////////////////////////////////////////////////////////////////////////////////////// // destruct_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsDestructPixels destruct_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief invokes the destructor on every pixel of an image view namespace detail { template <typename Iterator> BOOST_FORCEINLINE void destruct_range_impl(Iterator first, Iterator last, typename std::enable_if < mp11::mp_and < std::is_pointer<Iterator>, mp11::mp_not < detail::is_trivially_destructible<typename std::iterator_traits<Iterator>::value_type> > >::value >::type* /ptr/ = 0) { while (first != last) { first->~value_t(); ++first; } } template <typename Iterator> BOOST_FORCEINLINE void destruct_range_impl(Iterator /first/, Iterator /last/, typename std::enable_if < mp11::mp_or < mp11::mp_not<std::is_pointer<Iterator>>, detail::is_trivially_destructible<typename std::iterator_traits<Iterator>::value_type> >::value >::type* /* ptr / = nullptr) { } template <typename Iterator> BOOST_FORCEINLINE void destruct_range(Iterator first, Iterator last) { destruct_range_impl(first, last); } struct std_destruct_t { template <typename Iterator> void operator()(Iterator first, Iterator last) const { destruct_range(first,last); } }; /// destruct for planar iterators template <typename It> BOOST_FORCEINLINE void destruct_aux(It first, It last, std::true_type) { static_for_each(first,last,std_destruct_t()); } /// destruct for interleaved iterators template <typename It> BOOST_FORCEINLINE void destruct_aux(It first, It last, std::false_type) { destruct_range(first,last); } } // namespace detail /// \ingroup ImageViewSTLAlgorithmsDestructPixels /// \brief Invokes the in-place destructor on every pixel of the view template <typename View> BOOST_FORCEINLINE void destruct_pixels(View const& view) { if (view.is_1d_traversable()) { detail::destruct_aux( view.begin().x(), view.end().x(), is_planar<View>()); } else { for (std::ptrdiff_t y = 0; y < view.height(); ++y) detail::destruct_aux( view.row_begin(y), view.row_end(y), is_planar<View>()); } } ////////////////////////////////////////////////////////////////////////////////////// // uninitialized_fill_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsUninitializedFillPixels uninitialized_fill_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::uninitialized_fill for image views namespace detail { /// std::uninitialized_fill for planar iterators /// If an exception is thrown destructs any in-place copy-constructed objects template <typename It, typename P> BOOST_FORCEINLINE void uninitialized_fill_aux(It first, It last, P const& p, std::true_type) { std::size_t channel = 0; try { using pixel_t = typename std::iterator_traits<It>::value_type; while (channel < num_channels<pixel_t>::value) { std::uninitialized_fill( dynamic_at_c(first,channel), dynamic_at_c(last,channel), dynamic_at_c(p,channel)); ++channel; } } catch (...) { for (std::size_t c = 0; c < channel; ++c) destruct_range(dynamic_at_c(first, c), dynamic_at_c(last, c)); throw; } } /// std::uninitialized_fill for interleaved iterators /// If an exception is thrown destructs any in-place copy-constructed objects template <typename It, typename P> BOOST_FORCEINLINE void uninitialized_fill_aux(It first, It last, P const& p, std::false_type) { std::uninitialized_fill(first,last,p); } } // namespace detail /// \ingroup ImageViewSTLAlgorithmsUninitializedFillPixels /// \brief std::uninitialized_fill for image views. /// Does not support planar heterogeneous views. /// If an exception is thrown destructs any in-place copy-constructed pixels template <typename View, typename Value> void uninitialized_fill_pixels(const View& view, const Value& val) { if (view.is_1d_traversable()) detail::uninitialized_fill_aux(view.begin().x(), view.end().x(), val,is_planar<View>()); else { typename View::y_coord_t y = 0; try { for (y=0; y<view.height(); ++y) detail::uninitialized_fill_aux(view.row_begin(y),view.row_end(y), val,is_planar<View>()); } catch(...) { for (typename View::y_coord_t y0=0; y0<y; ++y0) detail::destruct_aux(view.row_begin(y0),view.row_end(y0), is_planar<View>()); throw; } } } ////////////////////////////////////////////////////////////////////////////////////// // default_construct_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsDefaultConstructPixels default_construct_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief invokes the default constructor on every pixel of an image view namespace detail { template <typename It> BOOST_FORCEINLINE void default_construct_range_impl(It first, It last, std::true_type) { It first1 = first; try { using value_t = typename std::iterator_traits<It>::value_type; while (first != last) { new (first) value_t(); ++first; } } catch (...) { destruct_range(first1, first); throw; } } template <typename It> BOOST_FORCEINLINE void default_construct_range_impl(It, It, std::false_type) {} template <typename It> BOOST_FORCEINLINE void default_construct_range(It first, It last) { default_construct_range_impl(first, last, typename std::is_pointer<It>::type()); } /// uninitialized_default_construct for planar iterators template <typename It> BOOST_FORCEINLINE void default_construct_aux(It first, It last, std::true_type) { std::size_t channel = 0; try { using pixel_t = typename std::iterator_traits<It>::value_type; while (channel < num_channels<pixel_t>::value) { default_construct_range(dynamic_at_c(first, channel), dynamic_at_c(last, channel)); ++channel; } } catch (...) { for (std::size_t c = 0; c < channel; ++c) destruct_range(dynamic_at_c(first, c), dynamic_at_c(last, c)); throw; } } /// uninitialized_default_construct for interleaved iterators template <typename It> BOOST_FORCEINLINE void default_construct_aux(It first, It last, std::false_type) { default_construct_range(first, last); } template <typename View, bool IsPlanar> struct has_trivial_pixel_constructor : detail::is_trivially_default_constructible<typename View::value_type> {}; template <typename View> struct has_trivial_pixel_constructor<View, true> : detail::is_trivially_default_constructible<typename channel_type<View>::type> {}; template<typename View, bool IsTriviallyConstructible> BOOST_FORCEINLINE void default_construct_pixels_impl( View const& view, std::enable_if<!IsTriviallyConstructible> /ptr/ = nullptr) { if (view.is_1d_traversable()) { detail::default_construct_aux( view.begin().x(), view.end().x(), is_planar<View>()); } else { typename View::y_coord_t y = 0; try { for( y = 0; y < view.height(); ++y ) detail::default_construct_aux( view.row_begin(y), view.row_end(y), is_planar<View>()); } catch(...) { for (typename View::y_coord_t y0 = 0; y0 < y; ++y0 ) detail::destruct_aux( view.row_begin(y0), view.row_end(y0), is_planar<View>()); throw; } } } } // namespace detail /// \ingroup ImageViewSTLAlgorithmsDefaultConstructPixels /// \brief Invokes the in-place default constructor on every pixel of the (uninitialized) view. /// Does not support planar heterogeneous views. /// If an exception is thrown destructs any in-place default-constructed pixels template <typename View> void default_construct_pixels(View const& view) { detail::default_construct_pixels_impl < View, detail::has_trivial_pixel_constructor < View, is_planar<View>::value >::value >(view); } ////////////////////////////////////////////////////////////////////////////////////// // uninitialized_copy_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsUninitializedCopyPixels uninitialized_copy_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::uninitialized_copy for image views namespace detail { /// std::uninitialized_copy for pairs of planar iterators template <typename It1, typename It2> BOOST_FORCEINLINE void uninitialized_copy_aux(It1 first1, It1 last1, It2 first2, std::true_type) { std::size_t channel=0; try { using pixel_t = typename std::iterator_traits<It1>::value_type; while (channel < num_channels<pixel_t>::value) { std::uninitialized_copy( dynamic_at_c(first1, channel), dynamic_at_c(last1, channel), dynamic_at_c(first2, channel)); ++channel; } } catch (...) { It2 last2 = first2; std::advance(last2, std::distance(first1, last1)); for (std::size_t c = 0; c < channel; ++c) destruct_range(dynamic_at_c(first2, c), dynamic_at_c(last2, c)); throw; } } /// std::uninitialized_copy for interleaved or mixed iterators template <typename It1, typename It2> BOOST_FORCEINLINE void uninitialized_copy_aux(It1 first1, It1 last1, It2 first2, std::false_type) { std::uninitialized_copy(first1, last1, first2); } } // namespace detail /// \ingroup ImageViewSTLAlgorithmsUninitializedCopyPixels /// \brief std::uninitialized_copy for image views. /// Does not support planar heterogeneous views. /// If an exception is thrown destructs any in-place copy-constructed objects template <typename View1, typename View2> void uninitialized_copy_pixels(View1 const& view1, View2 const& view2) { using is_planar = std::integral_constant<bool, is_planar<View1>::value && is_planar<View2>::value>; BOOST_ASSERT(view1.dimensions() == view2.dimensions()); if (view1.is_1d_traversable() && view2.is_1d_traversable()) { detail::uninitialized_copy_aux( view1.begin().x(), view1.end().x(), view2.begin().x(), is_planar()); } else { typename View1::y_coord_t y = 0; try { for (y = 0; y < view1.height(); ++y) detail::uninitialized_copy_aux( view1.row_begin(y), view1.row_end(y), view2.row_begin(y), is_planar()); } catch(...) { for (typename View1::y_coord_t y0 = 0; y0 < y; ++y0) detail::destruct_aux(view2.row_begin(y0), view2.row_end(y0), is_planar()); throw; } } } ////////////////////////////////////////////////////////////////////////////////////// // for_each_pixel ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsForEachPixel for_each_pixel /// \ingroup ImageViewSTLAlgorithms /// \brief std::for_each for image views /// /// For contiguous images (i.e. images that have no alignment gap at the end of each row) it is /// more efficient to use the underlying pixel iterator that does not check for the end of rows. /// For non-contiguous images for_each_pixel resolves to for_each of each row using the underlying /// pixel iterator, which is still faster /// \ingroup ImageViewSTLAlgorithmsForEachPixel template <typename View, typename F> F for_each_pixel(View const& view, F fun) { if (view.is_1d_traversable()) { return std::for_each(view.begin().x(), view.end().x(), fun); } else { for (std::ptrdiff_t y = 0; y < view.height(); ++y) std::for_each(view.row_begin(y), view.row_end(y), fun); return fun; } } /// \defgroup ImageViewSTLAlgorithmsForEachPixelPosition for_each_pixel_position /// \ingroup ImageViewSTLAlgorithms /// \brief adobe::for_each_position for image views (passes locators, instead of pixel references, to the function object) /// \ingroup ImageViewSTLAlgorithmsForEachPixelPosition template <typename View, typename F> F for_each_pixel_position(View const& view, F fun) { typename View::xy_locator loc = view.xy_at(0, 0); for (std::ptrdiff_t y = 0; y < view.height(); ++y) { for (std::ptrdiff_t x = 0; x < view.width(); ++x, ++loc.x()) fun(loc); loc.x() -= view.width(); ++loc.y(); } return fun; } ////////////////////////////////////////////////////////////////////////////////////// // generate_pixels ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsGeneratePixels generate_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::generate for image views /// \ingroup ImageViewSTLAlgorithmsGeneratePixels /// \brief std::generate for image views template <typename View, typename F> void generate_pixels(View const& view, F fun) { if (view.is_1d_traversable()) { std::generate(view.begin().x(), view.end().x(), fun); } else { for (std::ptrdiff_t y = 0; y < view.height(); ++y) std::generate(view.row_begin(y), view.row_end(y), fun); } } ////////////////////////////////////////////////////////////////////////////////////// // std::equal and gil::equal_pixels for GIL constructs ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsEqualPixels equal_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::equal for image views template <typename I1, typename I2> BOOST_FORCEINLINE bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2); namespace detail { template <typename I1, typename I2> struct equal_n_fn { BOOST_FORCEINLINE bool operator()(I1 i1, std::ptrdiff_t n, I2 i2) const { return std::equal(i1, i1 + n, i2); } }; /// Equal when both ranges are interleaved and of the same type. /// GIL pixels are bitwise comparable, so memcmp is used. User-defined pixels that are not bitwise comparable need to provide an overload template<typename T, typename CS> struct equal_n_fn<pixel<T, CS> const, pixel<T, CS> const> { BOOST_FORCEINLINE bool operator()(pixel<T, CS> const* i1, std::ptrdiff_t n, pixel<T, CS> const* i2) const { return memcmp(i1, i2, n * sizeof(pixel<T, CS>)) == 0; } }; template<typename T, typename CS> struct equal_n_fn<pixel<T, CS>, pixel<T, CS>> : equal_n_fn<pixel<T, CS> const, pixel<T, CS> const> {}; /// EqualPixels /// Equal when both ranges are planar pointers of the same type. memcmp is invoked for each channel plane /// User-defined channels that are not bitwise comparable need to provide an overload template<typename IC, typename CS> struct equal_n_fn<planar_pixel_iterator<IC, CS>, planar_pixel_iterator<IC, CS>> { BOOST_FORCEINLINE bool operator()(planar_pixel_iterator<IC, CS> const i1, std::ptrdiff_t n, planar_pixel_iterator<IC, CS> const i2) const { // FIXME: ptrdiff_t vs size_t constexpr std::ptrdiff_t byte_size = n * sizeof(typename std::iterator_traits<IC>::value_type); for (std::ptrdiff_t i = 0; i < mp11::mp_size<CS>::value; ++i) { if (memcmp(dynamic_at_c(i1, i), dynamic_at_c(i2, i), byte_size) != 0) return false; } return true; } }; /// Source range is delimited by image iterators /// \tparam Loc Models ConstPixelLocatorConcept /// \tparam It Models PixelIteratorConcept template <typename Loc, typename It> struct equal_n_fn<boost::gil::iterator_from_2d<Loc>, It> { BOOST_FORCEINLINE bool operator()(boost::gil::iterator_from_2d<Loc> i1, std::ptrdiff_t n, It i2) const { gil_function_requires<boost::gil::PixelLocatorConcept<Loc>>(); gil_function_requires<boost::gil::PixelIteratorConcept<It>>(); while (n > 0) { std::ptrdiff_t const num = std::min<std::ptrdiff_t>(n, i1.width() - i1.x_pos()); if (!equal_n(i1.x(), num, i2)) return false; i1 += num; i2 += num; n -= num; } return true; } }; /// Destination range is delimited by image iterators /// \tparam It Models PixelIteratorConcept /// \tparam Loc Models PixelLocatorConcept template <typename It, typename Loc> struct equal_n_fn<It, boost::gil::iterator_from_2d<Loc>> { BOOST_FORCEINLINE bool operator()(It i1, std::ptrdiff_t n, boost::gil::iterator_from_2d<Loc> i2) const { gil_function_requires<boost::gil::PixelIteratorConcept<It>>(); gil_function_requires<boost::gil::PixelLocatorConcept<Loc>>(); while (n > 0) { std::ptrdiff_t const num = std::min<std::ptrdiff_t>(n, i2.width() - i2.x_pos()); if (!equal_n(i1, num, i2.x())) return false; i1 += num; i2 += num; n -= num; } return true; } }; /// Both source and destination ranges are delimited by image iterators template <typename Loc1, typename Loc2> struct equal_n_fn<boost::gil::iterator_from_2d<Loc1>,boost::gil::iterator_from_2d<Loc2>> { BOOST_FORCEINLINE bool operator()(boost::gil::iterator_from_2d<Loc1> i1, std::ptrdiff_t n, boost::gil::iterator_from_2d<Loc2> i2) const { gil_function_requires<boost::gil::PixelLocatorConcept<Loc1>>(); gil_function_requires<boost::gil::PixelLocatorConcept<Loc2>>(); if (i1.x_pos()!=i2.x_pos() \|\| i1.width()!=i2.width()) { while(n-->0) { if (i1++!=i2++) return false; } } while (n>0) { std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos()); if (!equal_n(i1.x(), num, i2.x())) return false; i1+=num; i2+=num; n-=num; } return true; } }; } // namespace detail template <typename I1, typename I2> BOOST_FORCEINLINE bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2) { return detail::equal_n_fn<I1,I2>()(i1,n,i2); } } } // namespace boost::gil namespace std { /// \ingroup STLOptimizations /// \brief std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d /// /// Invoked when one calls std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d (which is /// a 1D iterator over the pixels in an image). Attempts to demote the source and destination /// iterators to simpler/faster types if the corresponding range is contiguous. /// For contiguous images (i.e. images that have /// no alignment gap at the end of each row) it is more efficient to use the underlying /// pixel iterator that does not check for the end of rows. If the underlying pixel iterator /// happens to be a fundamental planar/interleaved pointer, the call may further resolve /// to memcmp. Otherwise it resolves to copying each row using the underlying pixel iterator template <typename Loc1, typename Loc2> BOOST_FORCEINLINE bool equal(boost::gil::iterator_from_2d<Loc1> first, boost::gil::iterator_from_2d<Loc1> last, boost::gil::iterator_from_2d<Loc2> first2) { boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc1>>(); boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc2>>(); std::ptrdiff_t n=last-first; if (first.is_1d_traversable()) { if (first2.is_1d_traversable()) return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,typename Loc2::x_iterator>()(first.x(),n, first2.x()); else return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,boost::gil::iterator_from_2d<Loc2>>()(first.x(),n, first2); } else { if (first2.is_1d_traversable()) return boost::gil::detail::equal_n_fn<boost::gil::iterator_from_2d<Loc1>,typename Loc2::x_iterator>()(first,n, first2.x()); else return boost::gil::detail::equal_n_fn<boost::gil::iterator_from_2d<Loc1>,boost::gil::iterator_from_2d<Loc2>>()(first,n,first2); } } } // namespace std namespace boost { namespace gil { /// \ingroup ImageViewSTLAlgorithmsEqualPixels /// \brief std::equal for image views template <typename View1, typename View2> BOOST_FORCEINLINE bool equal_pixels(const View1& v1, const View2& v2) { BOOST_ASSERT(v1.dimensions() == v2.dimensions()); return std::equal(v1.begin(),v1.end(),v2.begin()); // std::equal has overloads with GIL iterators for optimal performance } ////////////////////////////////////////////////////////////////////////////////////// /// /// transform_pixels /// ////////////////////////////////////////////////////////////////////////////////////// /// \defgroup ImageViewSTLAlgorithmsTransformPixels transform_pixels /// \ingroup ImageViewSTLAlgorithms /// \brief std::transform for image views /// \ingroup ImageViewSTLAlgorithmsTransformPixels /// \brief std::transform for image views template <typename View1, typename View2, typename F> BOOST_FORCEINLINE F transform_pixels(const View1& src,const View2& dst, F fun) { BOOST_ASSERT(src.dimensions() == dst.dimensions()); for (std::ptrdiff_t y=0; y<src.height(); ++y) { typename View1::x_iterator srcIt=src.row_begin(y); typename View2::x_iterator dstIt=dst.row_begin(y); for (std::ptrdiff_t x=0; x<src.width(); ++x) dstIt[x]=fun(srcIt[x]); } return fun; } /// \ingroup ImageViewSTLAlgorithmsTransformPixels /// \brief transform_pixels with two sources template <typename View1, typename View2, typename View3, typename F> BOOST_FORCEINLINE F transform_pixels(const View1& src1, const View2& src2,const View3& dst, F fun) { for (std::ptrdiff_t y=0; y<dst.height(); ++y) { typename View1::x_iterator srcIt1=src1.row_begin(y); typename View2::x_iterator srcIt2=src2.row_begin(y); typename View3::x_iterator dstIt=dst.row_begin(y); for (std::ptrdiff_t x=0; x<dst.width(); ++x) dstIt[x]=fun(srcIt1[x],srcIt2[x]); } return fun; } /// \defgroup ImageViewSTLAlgorithmsTransformPixelPositions transform_pixel_positions /// \ingroup ImageViewSTLAlgorithms /// \brief adobe::transform_positions for image views (passes locators, instead of pixel references, to the function object) /// \ingroup ImageViewSTLAlgorithmsTransformPixelPositions /// \brief Like transform_pixels but passes to the function object pixel locators instead of pixel references template <typename View1, typename View2, typename F> BOOST_FORCEINLINE F transform_pixel_positions(const View1& src,const View2& dst, F fun) { BOOST_ASSERT(src.dimensions() == dst.dimensions()); typename View1::xy_locator loc=src.xy_at(0,0); for (std::ptrdiff_t y=0; y<src.height(); ++y) { typename View2::x_iterator dstIt=dst.row_begin(y); for (std::ptrdiff_t x=0; x<src.width(); ++x, ++loc.x()) dstIt[x]=fun(loc); loc.x()-=src.width(); ++loc.y(); } return fun; } /// \ingroup ImageViewSTLAlgorithmsTransformPixelPositions /// \brief transform_pixel_positions with two sources template <typename View1, typename View2, typename View3, typename F> BOOST_FORCEINLINE F transform_pixel_positions(const View1& src1,const View2& src2,const View3& dst, F fun) { BOOST_ASSERT(src1.dimensions() == dst.dimensions()); BOOST_ASSERT(src2.dimensions() == dst.dimensions()); typename View1::xy_locator loc1=src1.xy_at(0,0); typename View2::xy_locator loc2=src2.xy_at(0,0); for (std::ptrdiff_t y=0; y<src1.height(); ++y) { typename View3::x_iterator dstIt=dst.row_begin(y); for (std::ptrdiff_t x=0; x<src1.width(); ++x, ++loc1.x(), ++loc2.x()) dstIt[x]=fun(loc1,loc2); loc1.x()-=src1.width(); ++loc1.y(); loc2.x()-=src2.width(); ++loc2.y(); } return fun; } } } // namespace boost::gil #endif PK��p�[D�ӥ@��@��detail/type_traits.hppnu��[��// // Copyright 2017-2019 Peter Dimov. // // 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_DETAIL_TYPE_TRAITS_HPP #define BOOST_GIL_DETAIL_TYPE_TRAITS_HPP #include <boost/config.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { #if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 50100 template<class T> struct is_trivially_default_constructible : std::integral_constant < bool, std::is_default_constructible<T>::value && std::has_trivial_default_constructor<T>::value > {}; #else using std::is_trivially_default_constructible; #endif using std::is_trivially_destructible; }}} //namespace boost::gil::detail #endif PK��p�[�谓e��e��detail/math.hppnu��[��// // Copyright 2019 Olzhas Zhumabek <anonymous.from.applecity@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_DETAIL_MATH_HPP #define BOOST_GIL_IMAGE_PROCESSING_DETAIL_MATH_HPP #include <array> #include <boost/gil/extension/numeric/kernel.hpp> namespace boost { namespace gil { namespace detail { static constexpr double pi = 3.14159265358979323846; static constexpr std::array<float, 9> dx_sobel = {{-1, 0, 1, -2, 0, 2, -1, 0, 1}}; static constexpr std::array<float, 9> dx_scharr = {{-1, 0, 1, -1, 0, 1, -1, 0, 1}}; static constexpr std::array<float, 9> dy_sobel = {{1, 2, 1, 0, 0, 0, -1, -2, -1}}; static constexpr std::array<float, 9> dy_scharr = {{1, 1, 1, 0, 0, 0, -1, -1, -1}}; template <typename T, typename Allocator> inline detail::kernel_2d<T, Allocator> get_identity_kernel() { detail::kernel_2d<T, Allocator> kernel(1, 0, 0); kernel[0] = 1; return kernel; } }}} // namespace boost::gil::detail #endif PK��p�[%�YI��detail/std_common_type.hppnu��[��// // Copyright Louis Dionne 2013-2017 // // Distributed under the Boost Software License, Version 1.0. //(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) // #ifndef BOOST_GIL_DETAIL_STD_COMMON_TYPE_HPP #define BOOST_GIL_DETAIL_STD_COMMON_TYPE_HPP #include <type_traits> #include <utility> namespace boost { namespace gil { namespace detail { // Defines a SFINAE-friendly version of `std::common_type`. // // Based on boost/hana/detail/std_common_type.hpp // Equivalent to `std::common_type`, except it is SFINAE-friendly and // does not support custom specializations. template <typename T, typename U, typename = void> struct std_common_type {}; template <typename T, typename U> struct std_common_type < T, U, decltype((void)(true ? std::declval<T>() : std::declval<U>())) > { using type = typename std::decay < decltype(true ? std::declval<T>() : std::declval<U>()) >::type; }; }}} // namespace boost::gil::detail #endif PK��p�[��k��k��detail/is_channel_integral.hppnu��[��// // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // Copyright 2005-2007 Adobe Systems Incorporated // // 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_DETAIL_IS_CHANNEL_INTEGRAL_HPP #define BOOST_GIL_DETAIL_IS_CHANNEL_INTEGRAL_HPP #include <boost/gil/channel.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template <typename ChannelValue> struct is_channel_integral : std::is_integral<ChannelValue> {}; template <int NumBits> struct is_channel_integral<boost::gil::packed_channel_value<NumBits>> : std::true_type {}; template <typename BitField, int FirstBit, int NumBits, bool IsMutable> struct is_channel_integral < boost::gil::packed_channel_reference<BitField, FirstBit, NumBits, IsMutable> > : std::true_type {}; template <typename BitField, int NumBits, bool IsMutable> struct is_channel_integral < boost::gil::packed_dynamic_channel_reference<BitField, NumBits, IsMutable> > : std::true_type {}; template <typename BaseChannelValue, typename MinVal, typename MaxVal> struct is_channel_integral < boost::gil::scoped_channel_value<BaseChannelValue, MinVal, MaxVal> > : std::is_integral<BaseChannelValue> {}; }}} //namespace boost::gil::detail #endif PK��p�[osP��detail/mp11.hppnu��[��// // Copyright 2017 Peter Dimov. // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_DETAIL_MP11_HPP #define BOOST_GIL_DETAIL_MP11_HPP #include <boost/mp11.hpp> #include <boost/mp11/mpl.hpp> // required by dynamic_image and boost::variant (?) namespace boost { namespace gil { namespace detail { template<typename L> using mp_back = ::boost::mp11::mp_at_c<L, ::boost::mp11::mp_size<L>::value - 1>; template<typename L> using mp_pop_back = ::boost::mp11::mp_take_c<L, ::boost::mp11::mp_size<L>::value - 1>; }}} // namespace boost::gil::detail #endif PK��p�[:=p�U��U��color_base.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_COLOR_BASE_HPP #define BOOST_GIL_COLOR_BASE_HPP #include <boost/gil/utilities.hpp> #include <boost/gil/concepts.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <type_traits> namespace boost { namespace gil { // Forward-declare template <typename P> P memunit_advanced(const P* p, std::ptrdiff_t diff); // Forward-declare semantic_at_c template <int K, typename ColorBase> auto semantic_at_c(ColorBase& p) -> typename std::enable_if < !std::is_const<ColorBase>::value, typename kth_semantic_element_reference_type<ColorBase, K>::type >::type; template <int K, typename ColorBase> typename kth_semantic_element_const_reference_type<ColorBase,K>::type semantic_at_c(const ColorBase& p); // Forward declare element_reference_type template <typename ColorBase> struct element_reference_type; template <typename ColorBase> struct element_const_reference_type; template <typename ColorBase, int K> struct kth_element_type; template <typename ColorBase, int K> struct kth_element_type<const ColorBase,K> : public kth_element_type<ColorBase,K> {}; template <typename ColorBase, int K> struct kth_element_reference_type; template <typename ColorBase, int K> struct kth_element_reference_type<const ColorBase,K> : public kth_element_reference_type<ColorBase,K> {}; template <typename ColorBase, int K> struct kth_element_const_reference_type; template <typename ColorBase, int K> struct kth_element_const_reference_type<const ColorBase,K> : public kth_element_const_reference_type<ColorBase,K> {}; namespace detail { template <typename DstLayout, typename SrcLayout, int K> struct mapping_transform : mp11::mp_at < typename SrcLayout::channel_mapping_t, typename detail::type_to_index < typename DstLayout::channel_mapping_t, std::integral_constant<int, K> > >::type {}; /// \defgroup ColorBaseModelHomogeneous detail::homogeneous_color_base /// \ingroup ColorBaseModel /// \brief A homogeneous color base holding one color element. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// If the element type models Regular, this class models HomogeneousColorBaseValueConcept. #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// \brief A homogeneous color base holding one color element. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template <typename Element, typename Layout> struct homogeneous_color_base<Element, Layout, 1> { using layout_t = Layout; homogeneous_color_base() = default; homogeneous_color_base(Element v) : v0_(v) {} template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 1> const& c) : v0_(gil::at_c<0>(c)) {} auto at(std::integral_constant<int, 0>) -> typename element_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 0>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v0_; } // grayscale pixel values are convertible to channel type // FIXME: explicit? operator Element() const { return v0_; } private: Element v0_{}; }; /// \brief A homogeneous color base holding two color elements /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template <typename Element, typename Layout> struct homogeneous_color_base<Element, Layout, 2> { using layout_t = Layout; homogeneous_color_base() = default; explicit homogeneous_color_base(Element v) : v0_(v), v1_(v) {} homogeneous_color_base(Element v0, Element v1) : v0_(v0), v1_(v1) {} template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 2> const& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) {} // Support for l-value reference proxy copy construction template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 2>& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template <typename P> homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(p)) , v1_(&semantic_at_c<1>(p)) {} // Support for planar_pixel_reference offset constructor template <typename Ptr> homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(memunit_advanced(semantic_at_c<1>(ptr), diff)) {} template <typename Ref> Ref deref() const { return Ref(semantic_at_c<0>(this), semantic_at_c<1>(this)); } auto at(std::integral_constant<int, 0>) -> typename element_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 0>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 1>) -> typename element_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 1>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v1_; } // Support for planar_pixel_reference operator[] Element at_c_dynamic(std::size_t i) const { if (i == 0) return v0_; else return v1_; } private: Element v0_{}; Element v1_{}; }; /// \brief A homogeneous color base holding three color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template <typename Element, typename Layout> struct homogeneous_color_base<Element, Layout, 3> { using layout_t = Layout; homogeneous_color_base() = default; explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2) : v0_(v0), v1_(v1), v2_(v2) {} template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 3> const& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) {} // Support for l-value reference proxy copy construction template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 3>& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template <typename P> homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(p)) , v1_(&semantic_at_c<1>(p)) , v2_(&semantic_at_c<2>(p)) {} // Support for planar_pixel_reference offset constructor template <typename Ptr> homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(memunit_advanced(semantic_at_c<2>(ptr), diff)) {} template <typename Ref> Ref deref() const { return Ref( semantic_at_c<0>(this), semantic_at_c<1>(this), semantic_at_c<2>(this)); } auto at(std::integral_constant<int, 0>) -> typename element_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 0>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 1>) -> typename element_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 1>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 2>) -> typename element_reference_type<homogeneous_color_base>::type { return v2_; } auto at(std::integral_constant<int, 2>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v2_; } // Support for planar_pixel_reference operator[] Element at_c_dynamic(std::size_t i) const { switch (i) { case 0: return v0_; case 1: return v1_; } return v2_; } private: Element v0_{}; Element v1_{}; Element v2_{}; }; /// \brief A homogeneous color base holding four color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template <typename Element, typename Layout> struct homogeneous_color_base<Element, Layout, 4> { using layout_t = Layout; homogeneous_color_base() = default; explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v), v3_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2, Element v3) : v0_(v0), v1_(v1), v2_(v2), v3_(v3) {} template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 4> const& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) , v3_(gil::at_c<mapping_transform<Layout, L2, 3>::value>(c)) {} // Support for l-value reference proxy copy construction template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 4>& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) , v3_(gil::at_c<mapping_transform<Layout, L2, 3>::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template <typename P> homogeneous_color_base(P * p, bool) : v0_(&semantic_at_c<0>(p)) , v1_(&semantic_at_c<1>(p)) , v2_(&semantic_at_c<2>(p)) , v3_(&semantic_at_c<3>(p)) {} // Support for planar_pixel_reference offset constructor template <typename Ptr> homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(memunit_advanced(semantic_at_c<2>(ptr), diff)) , v3_(memunit_advanced(semantic_at_c<3>(ptr), diff)) {} template <typename Ref> Ref deref() const { return Ref( semantic_at_c<0>(this), semantic_at_c<1>(this), semantic_at_c<2>(this), semantic_at_c<3>(this)); } auto at(std::integral_constant<int, 0>) -> typename element_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 0>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 1>) -> typename element_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 1>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 2>) -> typename element_reference_type<homogeneous_color_base>::type { return v2_; } auto at(std::integral_constant<int, 2>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v2_; } auto at(std::integral_constant<int, 3>) -> typename element_reference_type<homogeneous_color_base>::type { return v3_; } auto at(std::integral_constant<int, 3>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v3_; } // Support for planar_pixel_reference operator[] Element at_c_dynamic(std::size_t i) const { switch (i) { case 0: return v0_; case 1: return v1_; case 2: return v2_; } return v3_; } private: Element v0_{}; Element v1_{}; Element v2_{}; Element v3_{}; }; /// \brief A homogeneous color base holding five color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template <typename Element, typename Layout> struct homogeneous_color_base<Element, Layout, 5> { using layout_t = Layout; homogeneous_color_base() = default; explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v), v3_(v), v4_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2, Element v3, Element v4) : v0_(v0), v1_(v1), v2_(v2), v3_(v3), v4_(v4) {} template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 5> const& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) , v3_(gil::at_c<mapping_transform<Layout, L2, 3>::value>(c)) , v4_(gil::at_c<mapping_transform<Layout, L2, 4>::value>(c)) {} // Support for l-value reference proxy copy construction template <typename E2, typename L2> homogeneous_color_base(homogeneous_color_base<E2, L2, 5>& c) : v0_(gil::at_c<mapping_transform<Layout, L2, 0>::value>(c)) , v1_(gil::at_c<mapping_transform<Layout, L2, 1>::value>(c)) , v2_(gil::at_c<mapping_transform<Layout, L2, 2>::value>(c)) , v3_(gil::at_c<mapping_transform<Layout, L2, 3>::value>(c)) , v4_(gil::at_c<mapping_transform<Layout, L2, 4>::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template <typename P> homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(p)) , v1_(&semantic_at_c<1>(p)) , v2_(&semantic_at_c<2>(p)) , v3_(&semantic_at_c<3>(p)) , v4_(&semantic_at_c<4>(p)) {} // Support for planar_pixel_reference offset constructor template <typename Ptr> homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(memunit_advanced(semantic_at_c<2>(ptr), diff)) , v3_(memunit_advanced(semantic_at_c<3>(ptr), diff)) , v4_(memunit_advanced(semantic_at_c<4>(ptr), diff)) {} auto at(std::integral_constant<int, 0>) -> typename element_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 0>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v0_; } auto at(std::integral_constant<int, 1>) -> typename element_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 1>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v1_; } auto at(std::integral_constant<int, 2>) -> typename element_reference_type<homogeneous_color_base>::type { return v2_; } auto at(std::integral_constant<int, 2>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v2_; } auto at(std::integral_constant<int, 3>) -> typename element_reference_type<homogeneous_color_base>::type { return v3_; } auto at(std::integral_constant<int, 3>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v3_; } auto at(std::integral_constant<int, 4>) -> typename element_reference_type<homogeneous_color_base>::type { return v4_; } auto at(std::integral_constant<int, 4>) const -> typename element_const_reference_type<homogeneous_color_base>::type { return v4_; } template <typename Ref> Ref deref() const { return Ref( semantic_at_c<0>(this), semantic_at_c<1>(this), semantic_at_c<2>(this), semantic_at_c<3>(this), semantic_at_c<4>(this)); } // Support for planar_pixel_reference operator[] Element at_c_dynamic(std::size_t i) const { switch (i) { case 0: return v0_; case 1: return v1_; case 2: return v2_; case 3: return v3_; } return v4_; } private: Element v0_{}; Element v1_{}; Element v2_{}; Element v3_{}; Element v4_{}; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif // The following way of casting adjacent channels (the contents of color_base) into an array appears to be unsafe // -- there is no guarantee that the compiler won't add any padding between adjacent channels. // Note, however, that GIL _must_ be compiled with compiler settings ensuring there is no padding in the color base structs. // This is because the color base structs must model the interleaved organization in memory. In other words, the client may // have existing RGB image in the form "RGBRGBRGB..." and we must be able to represent it with an array of RGB color bases (i.e. RGB pixels) // with no padding. We have tested with char/int/float/double channels on gcc and VC and have so far discovered no problem. // We have even tried using strange channels consisting of short + char (3 bytes). With the default 4-byte alignment on VC, the size // of this channel is padded to 4 bytes, so an RGB pixel of it will be 4x3=12 bytes. The code below will still work properly. // However, the client must nevertheless ensure that proper compiler settings are used for their compiler and their channel types. template <typename Element, typename Layout, int K> auto dynamic_at_c(homogeneous_color_base<Element,Layout,K>& cb, std::size_t i) -> typename element_reference_type<homogeneous_color_base<Element, Layout, K>>::type { BOOST_ASSERT(i < K); return (gil_reinterpret_cast<Element>(&cb))[i]; } template <typename Element, typename Layout, int K> auto dynamic_at_c(homogeneous_color_base<Element, Layout, K> const& cb, std::size_t i) -> typename element_const_reference_type < homogeneous_color_base<Element, Layout, K> >::type { BOOST_ASSERT(i < K); return (gil_reinterpret_cast_c<const Element>(&cb))[i]; } template <typename Element, typename Layout, int K> auto dynamic_at_c(homogeneous_color_base<Element&, Layout, K> const& cb, std::size_t i) -> typename element_reference_type < homogeneous_color_base<Element&, Layout, K> >::type { BOOST_ASSERT(i < K); return cb.at_c_dynamic(i); } template <typename Element, typename Layout, int K> auto dynamic_at_c( homogeneous_color_base<Element const&, Layout, K>const& cb, std::size_t i) -> typename element_const_reference_type < homogeneous_color_base<Element const&, Layout, K> >::type { BOOST_ASSERT(i < K); return cb.at_c_dynamic(i); } } // namespace detail template <typename Element, typename Layout, int K1, int K> struct kth_element_type<detail::homogeneous_color_base<Element, Layout, K1>, K> { using type = Element; }; template <typename Element, typename Layout, int K1, int K> struct kth_element_reference_type<detail::homogeneous_color_base<Element, Layout, K1>, K> : std::add_lvalue_reference<Element> {}; template <typename Element, typename Layout, int K1, int K> struct kth_element_const_reference_type < detail::homogeneous_color_base<Element, Layout, K1>, K > : std::add_lvalue_reference<typename std::add_const<Element>::type> {}; /// \brief Provides mutable access to the K-th element, in physical order /// \ingroup ColorBaseModelHomogeneous template <int K, typename E, typename L, int N> inline auto at_c(detail::homogeneous_color_base<E, L, N>& p) -> typename std::add_lvalue_reference<E>::type { return p.at(std::integral_constant<int, K>()); } /// \brief Provides constant access to the K-th element, in physical order /// \ingroup ColorBaseModelHomogeneous template <int K, typename E, typename L, int N> inline auto at_c(const detail::homogeneous_color_base<E, L, N>& p) -> typename std::add_lvalue_reference<typename std::add_const<E>::type>::type { return p.at(std::integral_constant<int, K>()); } namespace detail { struct swap_fn { template <typename T> void operator()(T& x, T& y) const { using std::swap; swap(x, y); } }; } // namespace detail template <typename E, typename L, int N> inline void swap( detail::homogeneous_color_base<E, L, N>& x, detail::homogeneous_color_base<E, L, N>& y) { static_for_each(x, y, detail::swap_fn()); } }} // namespace boost::gil #endif PK��p�[��}�}��}��dynamic_step.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_DYNAMIC_STEP_HPP #define BOOST_GIL_DYNAMIC_STEP_HPP #include <boost/gil/concepts/dynamic_step.hpp> namespace boost { namespace gil { /// Base template for types that model HasDynamicXStepTypeConcept. template <typename IteratorOrLocatorOrView> struct dynamic_x_step_type; /// Base template for types that model HasDynamicYStepTypeConcept. template <typename LocatorOrView> struct dynamic_y_step_type; /// Base template for types that model both, HasDynamicXStepTypeConcept and HasDynamicYStepTypeConcept. /// /// \todo TODO: Is Locator allowed or practical to occur? template <typename View> struct dynamic_xy_step_type; }} // namespace boost::gil #endif PK��p�[g��`��concepts/fwd.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_FWD_HPP #define BOOST_GIL_CONCEPTS_FWD_HPP namespace boost { namespace gil { // Forward declarations used by concepts template <typename ColorBase, int K> struct kth_element_type; template <typename ColorBase, int K> struct kth_element_reference_type; template <typename ColorBase, int K> struct kth_element_const_reference_type; template <typename ColorBase, int K> struct kth_semantic_element_reference_type; template <typename ColorBase, int K> struct kth_semantic_element_const_reference_type; template <typename ColorBase> struct size; template <typename ColorBase> struct element_type; template <typename T> struct is_pixel; template <typename T> struct is_planar; template <typename T> struct channel_type; template <typename T> struct color_space_type; template <typename T> struct channel_mapping_type; template <typename T> struct num_channels; template <typename T> struct dynamic_x_step_type; template <typename T> struct dynamic_y_step_type; template <typename T> struct transposed_type; }} // namespace boost::gil #endif PK��p�[��l�S��S��concepts/channel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_CHANNEL_HPP #define BOOST_GIL_CONCEPTS_CHANNEL_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/concept_check.hpp> #include <utility> // std::swap #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { // Forward declarations template <typename T> struct channel_traits; template <typename DstT, typename SrcT> auto channel_convert(SrcT const& val) -> typename channel_traits<DstT>::value_type; /// \ingroup ChannelConcept /// \brief A channel is the building block of a color. /// Color is defined as a mixture of primary colors and a channel defines /// the degree to which each primary color is used in the mixture. /// /// For example, in the RGB color space, using 8-bit unsigned channels, /// the color red is defined as [255 0 0], which means maximum of Red, /// and no Green and Blue. /// /// Built-in scalar types, such as \p int and \p float, are valid GIL channels. /// In more complex scenarios, channels may be represented as bit ranges or /// even individual bits. /// In such cases special classes are needed to represent the value and /// reference to a channel. /// /// Channels have a traits class, \p channel_traits, which defines their /// associated types as well as their operating ranges. /// /// \code /// concept ChannelConcept<typename T> : EqualityComparable<T> /// { /// typename value_type = T; // use channel_traits<T>::value_type to access it /// typename reference = T&; // use channel_traits<T>::reference to access it /// typename pointer = T; // use channel_traits<T>::pointer to access it /// typename const_reference = const T&; // use channel_traits<T>::const_reference to access it /// typename const_pointer = const T; // use channel_traits<T>::const_pointer to access it /// static const bool is_mutable; // use channel_traits<T>::is_mutable to access it /// /// static T min_value(); // use channel_traits<T>::min_value to access it /// static T max_value(); // use channel_traits<T>::max_value to access it /// }; /// \endcode template <typename T> struct ChannelConcept { void constraints() { gil_function_requires<boost::EqualityComparableConcept<T>>(); using v = typename channel_traits<T>::value_type; using r = typename channel_traits<T>::reference; using p = typename channel_traits<T>::pointer; using cr = typename channel_traits<T>::const_reference; using cp = typename channel_traits<T>::const_pointer; channel_traits<T>::min_value(); channel_traits<T>::max_value(); } T c; }; namespace detail { /// \tparam T models ChannelConcept template <typename T> struct ChannelIsMutableConcept { void constraints() { c1 = c2; using std::swap; swap(c1, c2); } T c1; T c2; }; } // namespace detail /// \brief A channel that allows for modifying its value /// \code /// concept MutableChannelConcept<ChannelConcept T> : Assignable<T>, Swappable<T> {}; /// \endcode /// \ingroup ChannelConcept template <typename T> struct MutableChannelConcept { void constraints() { gil_function_requires<ChannelConcept<T>>(); gil_function_requires<detail::ChannelIsMutableConcept<T>>(); } }; /// \brief A channel that supports default construction. /// \code /// concept ChannelValueConcept<ChannelConcept T> : Regular<T> {}; /// \endcode /// \ingroup ChannelConcept template <typename T> struct ChannelValueConcept { void constraints() { gil_function_requires<ChannelConcept<T>>(); gil_function_requires<Regular<T>>(); } }; /// \brief Predicate metafunction returning whether two channels are compatible /// /// Channels are considered compatible if their value types /// (ignoring constness and references) are the same. /// /// Example: /// /// \code /// static_assert(channels_are_compatible<uint8_t, const uint8_t&>::value, ""); /// \endcode /// \ingroup ChannelAlgorithm template <typename T1, typename T2> // Models GIL Pixel struct channels_are_compatible : std::is_same < typename channel_traits<T1>::value_type, typename channel_traits<T2>::value_type > { }; /// \brief Channels are compatible if their associated value types (ignoring constness and references) are the same /// /// \code /// concept ChannelsCompatibleConcept<ChannelConcept T1, ChannelConcept T2> /// { /// where SameType<T1::value_type, T2::value_type>; /// }; /// \endcode /// \ingroup ChannelConcept template <typename Channel1, typename Channel2> struct ChannelsCompatibleConcept { void constraints() { static_assert(channels_are_compatible<Channel1, Channel2>::value, ""); } }; /// \brief A channel is convertible to another one if the \p channel_convert algorithm is defined for the two channels. /// /// Convertibility is non-symmetric and implies that one channel can be /// converted to another. Conversion is explicit and often lossy operation. /// /// concept ChannelConvertibleConcept<ChannelConcept SrcChannel, ChannelValueConcept DstChannel> /// { /// DstChannel channel_convert(const SrcChannel&); /// }; /// \endcode /// \ingroup ChannelConcept template <typename SrcChannel, typename DstChannel> struct ChannelConvertibleConcept { void constraints() { gil_function_requires<ChannelConcept<SrcChannel>>(); gil_function_requires<MutableChannelConcept<DstChannel>>(); dst = channel_convert<DstChannel, SrcChannel>(src); ignore_unused_variable_warning(dst); } SrcChannel src; DstChannel dst; }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[ y<��concepts/pixel_dereference.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_PIXEL_DEREFERENCE_HPP #define BOOST_GIL_CONCEPTS_PIXEL_DEREFERENCE_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/pixel.hpp> #include <boost/gil/concepts/detail/type_traits.hpp> #include <boost/concept_check.hpp> #include <cstddef> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \ingroup PixelDereferenceAdaptorConcept /// \brief Represents a unary function object that can be invoked upon dereferencing a pixel iterator. /// /// This can perform an arbitrary computation, such as color conversion or table lookup. /// \code /// concept PixelDereferenceAdaptorConcept<boost::UnaryFunctionConcept D> /// : DefaultConstructibleConcept<D>, CopyConstructibleConcept<D>, AssignableConcept<D> /// { /// typename const_t; where PixelDereferenceAdaptorConcept<const_t>; /// typename value_type; where PixelValueConcept<value_type>; /// typename reference; // may be mutable /// typename const_reference; // must not be mutable /// static const bool D::is_mutable; /// /// where Convertible<value_type,result_type>; /// }; /// \endcode template <typename D> struct PixelDereferenceAdaptorConcept { void constraints() { gil_function_requires < boost::UnaryFunctionConcept < D, typename detail::remove_const_and_reference<typename D::result_type>::type, typename D::argument_type > >(); gil_function_requires<boost::DefaultConstructibleConcept<D>>(); gil_function_requires<boost::CopyConstructibleConcept<D>>(); gil_function_requires<boost::AssignableConcept<D>>(); gil_function_requires<PixelConcept < typename detail::remove_const_and_reference<typename D::result_type>::type >>(); using const_t = typename D::const_t; gil_function_requires<PixelDereferenceAdaptorConcept<const_t>>(); using value_type = typename D::value_type; gil_function_requires<PixelValueConcept<value_type>>(); // TODO: Should this be concept-checked after "if you remove const and reference"? --mloskot using reference = typename D::reference; // == PixelConcept (if you remove const and reference) using const_reference = typename D::const_reference; // == PixelConcept (if you remove const and reference) bool const is_mutable = D::is_mutable; ignore_unused_variable_warning(is_mutable); } D d; }; template <typename P> struct PixelDereferenceAdaptorArchetype { using argument_type = P; using result_type = P; using const_t = PixelDereferenceAdaptorArchetype; using value_type = typename std::remove_reference<P>::type; using reference = typename std::add_lvalue_reference<P>::type; using const_reference = reference; static const bool is_mutable = false; P operator()(P) const { throw; } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[�}׍ �� concepts/color.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_COLOR_HPP #define BOOST_GIL_CONCEPTS_COLOR_HPP #include <boost/gil/concepts/concept_check.hpp> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \ingroup ColorSpaceAndLayoutConcept /// \brief Color space type concept /// \code /// concept ColorSpaceConcept<MPLRandomAccessSequence CS> /// { /// // Boost.MP11-compatible list, whose elements are color tags. /// }; /// \endcode template <typename CS> struct ColorSpaceConcept { void constraints() { // Boost.MP11-compatible list, whose elements are color tags // TODO: Is this incomplete? } }; // Models ColorSpaceConcept template <typename CS1, typename CS2> struct color_spaces_are_compatible : std::is_same<CS1, CS2> {}; /// \ingroup ColorSpaceAndLayoutConcept /// \brief Two color spaces are compatible if they are the same /// \code /// concept ColorSpacesCompatibleConcept<ColorSpaceConcept CS1, ColorSpaceConcept CS2> /// { /// where SameType<CS1, CS2>; /// }; /// \endcode template <typename CS1, typename CS2> struct ColorSpacesCompatibleConcept { void constraints() { static_assert(color_spaces_are_compatible<CS1, CS2>::value, ""); } }; /// \ingroup ColorSpaceAndLayoutConcept /// \brief Channel mapping concept /// \code /// concept ChannelMappingConcept<MPLRandomAccessSequence CM> /// { /// // Boost.MP11-compatible list, whose elements /// // model MPLIntegralConstant representing a permutation /// }; /// \endcode template <typename CM> struct ChannelMappingConcept { void constraints() { // Boost.MP11-compatible list, whose elements model // MPLIntegralConstant representing a permutation. // TODO: Is this incomplete? } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[/�}4�9��9��concepts/pixel_locator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_PIXEL_LOCATOR_HPP #define BOOST_GIL_CONCEPTS_PIXEL_LOCATOR_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/pixel.hpp> #include <boost/gil/concepts/pixel_dereference.hpp> #include <boost/gil/concepts/pixel_iterator.hpp> #include <boost/gil/concepts/point.hpp> #include <boost/gil/concepts/detail/utility.hpp> #include <cstddef> #include <iterator> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #pragma GCC diagnostic ignored "-Wunused-but-set-variable" #endif namespace boost { namespace gil { /// \defgroup LocatorNDConcept RandomAccessNDLocatorConcept /// \ingroup PixelLocatorConcept /// \brief N-dimensional locator /// \defgroup Locator2DConcept RandomAccess2DLocatorConcept /// \ingroup PixelLocatorConcept /// \brief 2-dimensional locator /// \defgroup PixelLocator2DConcept PixelLocatorConcept /// \ingroup PixelLocatorConcept /// \brief 2-dimensional locator over pixel data /// \ingroup LocatorNDConcept /// \brief N-dimensional locator over immutable values /// /// \code /// concept RandomAccessNDLocatorConcept<Regular Loc> /// { /// typename value_type; // value over which the locator navigates /// typename reference; // result of dereferencing /// typename difference_type; where PointNDConcept<difference_type>; // return value of operator-. /// typename const_t; // same as Loc, but operating over immutable values /// typename cached_location_t; // type to store relative location (for efficient repeated access) /// typename point_t = difference_type; /// /// static const size_t num_dimensions; // dimensionality of the locator /// where num_dimensions = point_t::num_dimensions; /// /// // The difference_type and iterator type along each dimension. The iterators may only differ in /// // difference_type. Their value_type must be the same as Loc::value_type /// template <size_t D> /// struct axis /// { /// typename coord_t = point_t::axis<D>::coord_t; /// typename iterator; where RandomAccessTraversalConcept<iterator>; // iterator along D-th axis. /// where iterator::value_type == value_type; /// }; /// /// // Defines the type of a locator similar to this type, except it invokes Deref upon dereferencing /// template <PixelDereferenceAdaptorConcept Deref> /// struct add_deref /// { /// typename type; /// where RandomAccessNDLocatorConcept<type>; /// static type make(const Loc& loc, const Deref& deref); /// }; /// /// Loc& operator+=(Loc&, const difference_type&); /// Loc& operator-=(Loc&, const difference_type&); /// Loc operator+(const Loc&, const difference_type&); /// Loc operator-(const Loc&, const difference_type&); /// /// reference operator(const Loc&); /// reference operator[](const Loc&, const difference_type&); /// /// // Storing relative location for faster repeated access and accessing it /// cached_location_t Loc::cache_location(const difference_type&) const; /// reference operator[](const Loc&,const cached_location_t&); /// /// // Accessing iterators along a given dimension at the current location or at a given offset /// template <size_t D> axis<D>::iterator& Loc::axis_iterator(); /// template <size_t D> axis<D>::iterator const& Loc::axis_iterator() const; /// template <size_t D> axis<D>::iterator Loc::axis_iterator(const difference_type&) const; /// }; /// \endcode template <typename Loc> struct RandomAccessNDLocatorConcept { void constraints() { gil_function_requires<Regular<Loc>>(); // TODO: Should these be concept-checked instead of ignored? --mloskot using value_type = typename Loc::value_type; ignore_unused_variable_warning(value_type{}); // result of dereferencing using reference = typename Loc::reference; //ignore_unused_variable_warning(reference{}); // result of operator-(pixel_locator, pixel_locator) using difference_type = typename Loc::difference_type; ignore_unused_variable_warning(difference_type{}); // type used to store relative location (to allow for more efficient repeated access) using cached_location_t = typename Loc::cached_location_t; ignore_unused_variable_warning(cached_location_t{}); // same as this type, but over const values using const_t = typename Loc::const_t; ignore_unused_variable_warning(const_t{}); // same as difference_type using point_t = typename Loc::point_t; ignore_unused_variable_warning(point_t{}); static std::size_t const N = Loc::num_dimensions; ignore_unused_variable_warning(N); using first_it_type = typename Loc::template axis<0>::iterator; using last_it_type = typename Loc::template axis<N-1>::iterator; gil_function_requires<boost_concepts::RandomAccessTraversalConcept<first_it_type>>(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<last_it_type>>(); // point_t must be an N-dimensional point, each dimension of which must // have the same type as difference_type of the corresponding iterator gil_function_requires<PointNDConcept<point_t>>(); static_assert(point_t::num_dimensions == N, ""); static_assert(std::is_same < typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t >::value, ""); static_assert(std::is_same < typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t >::value, ""); difference_type d; loc += d; loc -= d; loc = loc + d; loc = loc - d; reference r1 = loc[d]; ignore_unused_variable_warning(r1); reference r2 = loc; ignore_unused_variable_warning(r2); cached_location_t cl = loc.cache_location(d); ignore_unused_variable_warning(cl); reference r3 = loc[d]; ignore_unused_variable_warning(r3); first_it_type fi = loc.template axis_iterator<0>(); fi = loc.template axis_iterator<0>(d); last_it_type li = loc.template axis_iterator<N-1>(); li = loc.template axis_iterator<N-1>(d); using deref_t = PixelDereferenceAdaptorArchetype<typename Loc::value_type>; using dtype = typename Loc::template add_deref<deref_t>::type; // TODO: infinite recursion - FIXME? //gil_function_requires<RandomAccessNDLocatorConcept<dtype>>(); } Loc loc; }; /// \ingroup Locator2DConcept /// \brief 2-dimensional locator over immutable values /// /// \code /// concept RandomAccess2DLocatorConcept<RandomAccessNDLocatorConcept Loc> /// { /// where num_dimensions==2; /// where Point2DConcept<point_t>; /// /// typename x_iterator = axis<0>::iterator; /// typename y_iterator = axis<1>::iterator; /// typename x_coord_t = axis<0>::coord_t; /// typename y_coord_t = axis<1>::coord_t; /// /// // Only available to locators that have dynamic step in Y /// //Loc::Loc(const Loc& loc, y_coord_t); /// /// // Only available to locators that have dynamic step in X and Y /// //Loc::Loc(const Loc& loc, x_coord_t, y_coord_t, bool transposed=false); /// /// x_iterator& Loc::x(); /// x_iterator const& Loc::x() const; /// y_iterator& Loc::y(); /// y_iterator const& Loc::y() const; /// /// x_iterator Loc::x_at(const difference_type&) const; /// y_iterator Loc::y_at(const difference_type&) const; /// Loc Loc::xy_at(const difference_type&) const; /// /// // x/y versions of all methods that can take difference type /// x_iterator Loc::x_at(x_coord_t, y_coord_t) const; /// y_iterator Loc::y_at(x_coord_t, y_coord_t) const; /// Loc Loc::xy_at(x_coord_t, y_coord_t) const; /// reference operator()(const Loc&, x_coord_t, y_coord_t); /// cached_location_t Loc::cache_location(x_coord_t, y_coord_t) const; /// /// bool Loc::is_1d_traversable(x_coord_t width) const; /// y_coord_t Loc::y_distance_to(const Loc& loc2, x_coord_t x_diff) const; /// }; /// \endcode template <typename Loc> struct RandomAccess2DLocatorConcept { void constraints() { gil_function_requires<RandomAccessNDLocatorConcept<Loc>>(); static_assert(Loc::num_dimensions == 2, ""); using dynamic_x_step_t = typename dynamic_x_step_type<Loc>::type; using dynamic_y_step_t = typename dynamic_y_step_type<Loc>::type; using transposed_t = typename transposed_type<Loc>::type; using cached_location_t = typename Loc::cached_location_t; gil_function_requires<Point2DConcept<typename Loc::point_t>>(); using x_iterator = typename Loc::x_iterator; using y_iterator = typename Loc::y_iterator; using x_coord_t = typename Loc::x_coord_t; using y_coord_t = typename Loc::y_coord_t; x_coord_t xd = 0; ignore_unused_variable_warning(xd); y_coord_t yd = 0; ignore_unused_variable_warning(yd); typename Loc::difference_type d; typename Loc::reference r=loc(xd,yd); ignore_unused_variable_warning(r); dynamic_x_step_t loc2(dynamic_x_step_t(), yd); dynamic_x_step_t loc3(dynamic_x_step_t(), xd, yd); using dynamic_xy_step_transposed_t = typename dynamic_y_step_type < typename dynamic_x_step_type<transposed_t>::type >::type; dynamic_xy_step_transposed_t loc4(loc, xd,yd,true); bool is_contiguous = loc.is_1d_traversable(xd); ignore_unused_variable_warning(is_contiguous); loc.y_distance_to(loc, xd); loc = loc.xy_at(d); loc = loc.xy_at(xd, yd); x_iterator xit = loc.x_at(d); xit = loc.x_at(xd, yd); xit = loc.x(); y_iterator yit = loc.y_at(d); yit = loc.y_at(xd, yd); yit = loc.y(); cached_location_t cl = loc.cache_location(xd, yd); ignore_unused_variable_warning(cl); } Loc loc; }; /// \ingroup PixelLocator2DConcept /// \brief GIL's 2-dimensional locator over immutable GIL pixels /// \code /// concept PixelLocatorConcept<RandomAccess2DLocatorConcept Loc> /// { /// where PixelValueConcept<value_type>; /// where PixelIteratorConcept<x_iterator>; /// where PixelIteratorConcept<y_iterator>; /// where x_coord_t == y_coord_t; /// /// typename coord_t = x_coord_t; /// }; /// \endcode template <typename Loc> struct PixelLocatorConcept { void constraints() { gil_function_requires<RandomAccess2DLocatorConcept<Loc>>(); gil_function_requires<PixelIteratorConcept<typename Loc::x_iterator>>(); gil_function_requires<PixelIteratorConcept<typename Loc::y_iterator>>(); using coord_t = typename Loc::coord_t; static_assert(std::is_same<typename Loc::x_coord_t, typename Loc::y_coord_t>::value, ""); } Loc loc; }; namespace detail { /// \tparam Loc Models RandomAccessNDLocatorConcept template <typename Loc> struct RandomAccessNDLocatorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessIteratorIsMutableConcept < typename Loc::template axis<0>::iterator >>(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept < typename Loc::template axis<Loc::num_dimensions-1>::iterator >>(); typename Loc::difference_type d; initialize_it(d); typename Loc::value_type v; initialize_it(v); typename Loc::cached_location_t cl = loc.cache_location(d); loc = v; loc[d] = v; loc[cl] = v; } Loc loc; }; // \tparam Loc Models RandomAccess2DLocatorConcept template <typename Loc> struct RandomAccess2DLocatorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<Loc>>(); typename Loc::x_coord_t xd = 0; ignore_unused_variable_warning(xd); typename Loc::y_coord_t yd = 0; ignore_unused_variable_warning(yd); typename Loc::value_type v; initialize_it(v); loc(xd, yd) = v; } Loc loc; }; } // namespace detail /// \ingroup LocatorNDConcept /// \brief N-dimensional locator over mutable pixels /// /// \code /// concept MutableRandomAccessNDLocatorConcept<RandomAccessNDLocatorConcept Loc> /// { /// where Mutable<reference>; /// }; /// \endcode template <typename Loc> struct MutableRandomAccessNDLocatorConcept { void constraints() { gil_function_requires<RandomAccessNDLocatorConcept<Loc>>(); gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<Loc>>(); } }; /// \ingroup Locator2DConcept /// \brief 2-dimensional locator over mutable pixels /// /// \code /// concept MutableRandomAccess2DLocatorConcept<RandomAccess2DLocatorConcept Loc> /// : MutableRandomAccessNDLocatorConcept<Loc> {}; /// \endcode template <typename Loc> struct MutableRandomAccess2DLocatorConcept { void constraints() { gil_function_requires<RandomAccess2DLocatorConcept<Loc>>(); gil_function_requires<detail::RandomAccess2DLocatorIsMutableConcept<Loc>>(); } }; /// \ingroup PixelLocator2DConcept /// \brief GIL's 2-dimensional locator over mutable GIL pixels /// /// \code /// concept MutablePixelLocatorConcept<PixelLocatorConcept Loc> /// : MutableRandomAccess2DLocatorConcept<Loc> {}; /// \endcode template <typename Loc> struct MutablePixelLocatorConcept { void constraints() { gil_function_requires<PixelLocatorConcept<Loc>>(); gil_function_requires<detail::RandomAccess2DLocatorIsMutableConcept<Loc>>(); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[�X�~K��~K��concepts/image_view.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_IMAGE_VIEW_HPP #define BOOST_GIL_CONCEPTS_IMAGE_VIEW_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/pixel.hpp> #include <boost/gil/concepts/pixel_dereference.hpp> #include <boost/gil/concepts/pixel_iterator.hpp> #include <boost/gil/concepts/pixel_locator.hpp> #include <boost/gil/concepts/point.hpp> #include <boost/gil/concepts/detail/utility.hpp> #include <cstddef> #include <iterator> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #pragma GCC diagnostic ignored "-Wunused-but-set-variable" #endif namespace boost { namespace gil { /// \defgroup ImageViewNDConcept ImageViewNDLocatorConcept /// \ingroup ImageViewConcept /// \brief N-dimensional range /// \defgroup ImageView2DConcept ImageView2DLocatorConcept /// \ingroup ImageViewConcept /// \brief 2-dimensional range /// \defgroup PixelImageViewConcept ImageViewConcept /// \ingroup ImageViewConcept /// \brief 2-dimensional range over pixel data /// \ingroup ImageViewNDConcept /// \brief N-dimensional view over immutable values /// /// \code /// concept RandomAccessNDImageViewConcept<Regular View> /// { /// typename value_type; /// typename reference; // result of dereferencing /// typename difference_type; // result of operator-(iterator,iterator) (1-dimensional!) /// typename const_t; where RandomAccessNDImageViewConcept<View>; // same as View, but over immutable values /// typename point_t; where PointNDConcept<point_t>; // N-dimensional point /// typename locator; where RandomAccessNDLocatorConcept<locator>; // N-dimensional locator. /// typename iterator; where RandomAccessTraversalConcept<iterator>; // 1-dimensional iterator over all values /// typename reverse_iterator; where RandomAccessTraversalConcept<reverse_iterator>; /// typename size_type; // the return value of size() /// /// // Equivalent to RandomAccessNDLocatorConcept::axis /// template <size_t D> struct axis { /// typename coord_t = point_t::axis<D>::coord_t; /// typename iterator; where RandomAccessTraversalConcept<iterator>; // iterator along D-th axis. /// where SameType<coord_t, iterator::difference_type>; /// where SameType<iterator::value_type,value_type>; /// }; /// /// // Defines the type of a view similar to this type, except it invokes Deref upon dereferencing /// template <PixelDereferenceAdaptorConcept Deref> struct add_deref { /// typename type; where RandomAccessNDImageViewConcept<type>; /// static type make(const View& v, const Deref& deref); /// }; /// /// static const size_t num_dimensions = point_t::num_dimensions; /// /// // Create from a locator at the top-left corner and dimensions /// View::View(const locator&, const point_type&); /// /// size_type View::size() const; // total number of elements /// reference operator[](View, const difference_type&) const; // 1-dimensional reference /// iterator View::begin() const; /// iterator View::end() const; /// reverse_iterator View::rbegin() const; /// reverse_iterator View::rend() const; /// iterator View::at(const point_t&); /// point_t View::dimensions() const; // number of elements along each dimension /// bool View::is_1d_traversable() const; // can an iterator over the first dimension visit each value? I.e. are there gaps between values? /// /// // iterator along a given dimension starting at a given point /// template <size_t D> View::axis<D>::iterator View::axis_iterator(const point_t&) const; /// /// reference operator()(View,const point_t&) const; /// }; /// \endcode template <typename View> struct RandomAccessNDImageViewConcept { void constraints() { gil_function_requires<Regular<View>>(); using value_type = typename View::value_type; using reference = typename View::reference; // result of dereferencing using pointer = typename View::pointer; using difference_type = typename View::difference_type; // result of operator-(1d_iterator,1d_iterator) using const_t = typename View::const_t; // same as this type, but over const values using point_t = typename View::point_t; // N-dimensional point using locator = typename View::locator; // N-dimensional locator using iterator = typename View::iterator; using const_iterator = typename View::const_iterator; using reverse_iterator = typename View::reverse_iterator; using size_type = typename View::size_type; static const std::size_t N=View::num_dimensions; gil_function_requires<RandomAccessNDLocatorConcept<locator>>(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<iterator>>(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<reverse_iterator>>(); using first_it_type = typename View::template axis<0>::iterator; using last_it_type = typename View::template axis<N-1>::iterator; gil_function_requires<boost_concepts::RandomAccessTraversalConcept<first_it_type>>(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<last_it_type>>(); // static_assert(typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value, ""); // static_assert(typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t>::value, ""); // point_t must be an N-dimensional point, each dimension of which must have the same type as difference_type of the corresponding iterator gil_function_requires<PointNDConcept<point_t>>(); static_assert(point_t::num_dimensions == N, ""); static_assert(std::is_same < typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t >::value, ""); static_assert(std::is_same < typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t >::value, ""); point_t p; locator lc; iterator it; reverse_iterator rit; difference_type d; detail::initialize_it(d); ignore_unused_variable_warning(d); View(p,lc); // view must be constructible from a locator and a point p = view.dimensions(); lc = view.pixels(); size_type sz = view.size(); ignore_unused_variable_warning(sz); bool is_contiguous = view.is_1d_traversable(); ignore_unused_variable_warning(is_contiguous); it = view.begin(); it = view.end(); rit = view.rbegin(); rit = view.rend(); reference r1 = view[d]; ignore_unused_variable_warning(r1); // 1D access reference r2 = view(p); ignore_unused_variable_warning(r2); // 2D access // get 1-D iterator of any dimension at a given pixel location first_it_type fi = view.template axis_iterator<0>(p); ignore_unused_variable_warning(fi); last_it_type li = view.template axis_iterator<N-1>(p); ignore_unused_variable_warning(li); using deref_t = PixelDereferenceAdaptorArchetype<typename View::value_type>; using dtype = typename View::template add_deref<deref_t>::type; } View view; }; /// \ingroup ImageView2DConcept /// \brief 2-dimensional view over immutable values /// /// \code /// concept RandomAccess2DImageViewConcept<RandomAccessNDImageViewConcept View> { /// where num_dimensions==2; /// /// typename x_iterator = axis<0>::iterator; /// typename y_iterator = axis<1>::iterator; /// typename x_coord_t = axis<0>::coord_t; /// typename y_coord_t = axis<1>::coord_t; /// typename xy_locator = locator; /// /// x_coord_t View::width() const; /// y_coord_t View::height() const; /// /// // X-navigation /// x_iterator View::x_at(const point_t&) const; /// x_iterator View::row_begin(y_coord_t) const; /// x_iterator View::row_end (y_coord_t) const; /// /// // Y-navigation /// y_iterator View::y_at(const point_t&) const; /// y_iterator View::col_begin(x_coord_t) const; /// y_iterator View::col_end (x_coord_t) const; /// /// // navigating in 2D /// xy_locator View::xy_at(const point_t&) const; /// /// // (x,y) versions of all methods taking point_t /// View::View(x_coord_t,y_coord_t,const locator&); /// iterator View::at(x_coord_t,y_coord_t) const; /// reference operator()(View,x_coord_t,y_coord_t) const; /// xy_locator View::xy_at(x_coord_t,y_coord_t) const; /// x_iterator View::x_at(x_coord_t,y_coord_t) const; /// y_iterator View::y_at(x_coord_t,y_coord_t) const; /// }; /// \endcode template <typename View> struct RandomAccess2DImageViewConcept { void constraints() { gil_function_requires<RandomAccessNDImageViewConcept<View>>(); static_assert(View::num_dimensions == 2, ""); // TODO: This executes the requirements for RandomAccessNDLocatorConcept again. Fix it to improve compile time gil_function_requires<RandomAccess2DLocatorConcept<typename View::locator>>(); using dynamic_x_step_t = typename dynamic_x_step_type<View>::type; using dynamic_y_step_t = typename dynamic_y_step_type<View>::type; using transposed_t = typename transposed_type<View>::type; using x_iterator = typename View::x_iterator; using y_iterator = typename View::y_iterator; using x_coord_t = typename View::x_coord_t; using y_coord_t = typename View::y_coord_t; using xy_locator = typename View::xy_locator; x_coord_t xd = 0; ignore_unused_variable_warning(xd); y_coord_t yd = 0; ignore_unused_variable_warning(yd); x_iterator xit; y_iterator yit; typename View::point_t d; View(xd, yd, xy_locator()); // constructible with width, height, 2d_locator xy_locator lc = view.xy_at(xd, yd); lc = view.xy_at(d); typename View::reference r = view(xd, yd); ignore_unused_variable_warning(r); xd = view.width(); yd = view.height(); xit = view.x_at(d); xit = view.x_at(xd,yd); xit = view.row_begin(xd); xit = view.row_end(xd); yit = view.y_at(d); yit = view.y_at(xd,yd); yit = view.col_begin(xd); yit = view.col_end(xd); } View view; }; /// \brief GIL view as Collection. /// /// \see https://www.boost.org/libs/utility/Collection.html /// template <typename View> struct CollectionImageViewConcept { void constraints() { using value_type = typename View::value_type; using iterator = typename View::iterator; using const_iterator = typename View::const_iterator; using reference = typename View::reference; using const_reference = typename View::const_reference; using pointer = typename View::pointer; using difference_type = typename View::difference_type; using size_type= typename View::size_type; iterator i; i = view1.begin(); i = view2.end(); const_iterator ci; ci = view1.begin(); ci = view2.end(); size_type s; s = view1.size(); s = view2.size(); ignore_unused_variable_warning(s); view1.empty(); view1.swap(view2); } View view1; View view2; }; /// \brief GIL view as ForwardCollection. /// /// \see https://www.boost.org/libs/utility/Collection.html /// template <typename View> struct ForwardCollectionImageViewConcept { void constraints() { gil_function_requires<CollectionImageViewConcept<View>>(); using reference = typename View::reference; using const_reference = typename View::const_reference; reference r = view.front(); ignore_unused_variable_warning(r); const_reference cr = view.front(); ignore_unused_variable_warning(cr); } View view; }; /// \brief GIL view as ReversibleCollection. /// /// \see https://www.boost.org/libs/utility/Collection.html /// template <typename View> struct ReversibleCollectionImageViewConcept { void constraints() { gil_function_requires<CollectionImageViewConcept<View>>(); using reverse_iterator = typename View::reverse_iterator; using reference = typename View::reference; using const_reference = typename View::const_reference; reverse_iterator i; i = view.rbegin(); i = view.rend(); reference r = view.back(); ignore_unused_variable_warning(r); const_reference cr = view.back(); ignore_unused_variable_warning(cr); } View view; }; /// \ingroup PixelImageViewConcept /// \brief GIL's 2-dimensional view over immutable GIL pixels /// \code /// concept ImageViewConcept<RandomAccess2DImageViewConcept View> /// { /// where PixelValueConcept<value_type>; /// where PixelIteratorConcept<x_iterator>; /// where PixelIteratorConcept<y_iterator>; /// where x_coord_t == y_coord_t; /// /// typename coord_t = x_coord_t; /// /// std::size_t View::num_channels() const; /// }; /// \endcode template <typename View> struct ImageViewConcept { void constraints() { gil_function_requires<RandomAccess2DImageViewConcept<View>>(); // TODO: This executes the requirements for RandomAccess2DLocatorConcept again. Fix it to improve compile time gil_function_requires<PixelLocatorConcept<typename View::xy_locator>>(); static_assert(std::is_same<typename View::x_coord_t, typename View::y_coord_t>::value, ""); using coord_t = typename View::coord_t; // 1D difference type (same for all dimensions) std::size_t num_chan = view.num_channels(); ignore_unused_variable_warning(num_chan); } View view; }; namespace detail { /// \tparam View Models RandomAccessNDImageViewConcept template <typename View> struct RandomAccessNDImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<typename View::locator>>(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::iterator>>(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept < typename View::reverse_iterator >>(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept < typename View::template axis<0>::iterator >>(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept < typename View::template axis<View::num_dimensions - 1>::iterator >>(); typename View::difference_type diff; initialize_it(diff); ignore_unused_variable_warning(diff); typename View::point_t pt; typename View::value_type v; initialize_it(v); view[diff] = v; view(pt) = v; } View view; }; /// \tparam View Models RandomAccessNDImageViewConcept template <typename View> struct RandomAccess2DImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDImageViewIsMutableConcept<View>>(); typename View::x_coord_t xd = 0; ignore_unused_variable_warning(xd); typename View::y_coord_t yd = 0; ignore_unused_variable_warning(yd); typename View::value_type v; initialize_it(v); view(xd, yd) = v; } View view; }; /// \tparam View Models ImageViewConcept template <typename View> struct PixelImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccess2DImageViewIsMutableConcept<View>>(); } }; } // namespace detail /// \ingroup ImageViewNDConcept /// \brief N-dimensional view over mutable values /// /// \code /// concept MutableRandomAccessNDImageViewConcept<RandomAccessNDImageViewConcept View> /// { /// where Mutable<reference>; /// }; /// \endcode template <typename View> struct MutableRandomAccessNDImageViewConcept { void constraints() { gil_function_requires<RandomAccessNDImageViewConcept<View>>(); gil_function_requires<detail::RandomAccessNDImageViewIsMutableConcept<View>>(); } }; /// \ingroup ImageView2DConcept /// \brief 2-dimensional view over mutable values /// /// \code /// concept MutableRandomAccess2DImageViewConcept<RandomAccess2DImageViewConcept View> /// : MutableRandomAccessNDImageViewConcept<View> {}; /// \endcode template <typename View> struct MutableRandomAccess2DImageViewConcept { void constraints() { gil_function_requires<RandomAccess2DImageViewConcept<View>>(); gil_function_requires<detail::RandomAccess2DImageViewIsMutableConcept<View>>(); } }; /// \ingroup PixelImageViewConcept /// \brief GIL's 2-dimensional view over mutable GIL pixels /// /// \code /// concept MutableImageViewConcept<ImageViewConcept View> /// : MutableRandomAccess2DImageViewConcept<View> {}; /// \endcode template <typename View> struct MutableImageViewConcept { void constraints() { gil_function_requires<ImageViewConcept<View>>(); gil_function_requires<detail::PixelImageViewIsMutableConcept<View>>(); } }; /// \brief Returns whether two views are compatible /// /// Views are compatible if their pixels are compatible. /// Compatible views can be assigned and copy constructed from one another. /// /// \tparam V1 Models ImageViewConcept /// \tparam V2 Models ImageViewConcept /// template <typename V1, typename V2> struct views_are_compatible : pixels_are_compatible<typename V1::value_type, typename V2::value_type> { }; /// \ingroup ImageViewConcept /// \brief Views are compatible if they have the same color spaces and compatible channel values. /// /// Constness and layout are not important for compatibility. /// /// \code /// concept ViewsCompatibleConcept<ImageViewConcept V1, ImageViewConcept V2> /// { /// where PixelsCompatibleConcept<V1::value_type, P2::value_type>; /// }; /// \endcode template <typename V1, typename V2> struct ViewsCompatibleConcept { void constraints() { static_assert(views_are_compatible<V1, V2>::value, ""); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[�e��concepts/image.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_IMAGE_HPP #define BOOST_GIL_CONCEPTS_IMAGE_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/image_view.hpp> #include <boost/gil/concepts/point.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \ingroup ImageConcept /// \brief N-dimensional container of values /// /// \code /// concept RandomAccessNDImageConcept<typename Image> : Regular<Image> /// { /// typename view_t; where MutableRandomAccessNDImageViewConcept<view_t>; /// typename const_view_t = view_t::const_t; /// typename point_t = view_t::point_t; /// typename value_type = view_t::value_type; /// typename allocator_type; /// /// Image::Image(point_t dims, std::size_t alignment=1); /// Image::Image(point_t dims, value_type fill_value, std::size_t alignment); /// /// void Image::recreate(point_t new_dims, std::size_t alignment=1); /// void Image::recreate(point_t new_dims, value_type fill_value, std::size_t alignment); /// /// const point_t& Image::dimensions() const; /// const const_view_t& const_view(const Image&); /// const view_t& view(Image&); /// }; /// \endcode template <typename Image> struct RandomAccessNDImageConcept { void constraints() { gil_function_requires<Regular<Image>>(); using view_t = typename Image::view_t; gil_function_requires<MutableRandomAccessNDImageViewConcept<view_t>>(); using const_view_t = typename Image::const_view_t; using pixel_t = typename Image::value_type; using point_t = typename Image::point_t; gil_function_requires<PointNDConcept<point_t>>(); const_view_t cv = const_view(image); ignore_unused_variable_warning(cv); view_t v = view(image); ignore_unused_variable_warning(v); pixel_t fill_value; point_t pt = image.dimensions(); Image image1(pt); Image image2(pt, 1); Image image3(pt, fill_value, 1); image.recreate(pt); image.recreate(pt, 1); image.recreate(pt, fill_value, 1); } Image image; }; /// \ingroup ImageConcept /// \brief 2-dimensional container of values /// /// \code /// concept RandomAccess2DImageConcept<RandomAccessNDImageConcept Image> /// { /// typename x_coord_t = const_view_t::x_coord_t; /// typename y_coord_t = const_view_t::y_coord_t; /// /// Image::Image(x_coord_t width, y_coord_t height, std::size_t alignment=1); /// Image::Image(x_coord_t width, y_coord_t height, value_type fill_value, std::size_t alignment); /// /// x_coord_t Image::width() const; /// y_coord_t Image::height() const; /// /// void Image::recreate(x_coord_t width, y_coord_t height, std::size_t alignment=1); /// void Image::recreate(x_coord_t width, y_coord_t height, value_type fill_value, std::size_t alignment); /// }; /// \endcode template <typename Image> struct RandomAccess2DImageConcept { void constraints() { gil_function_requires<RandomAccessNDImageConcept<Image>>(); using x_coord_t = typename Image::x_coord_t; using y_coord_t = typename Image::y_coord_t; using value_t = typename Image::value_type; gil_function_requires<MutableRandomAccess2DImageViewConcept<typename Image::view_t>>(); x_coord_t w=image.width(); y_coord_t h=image.height(); value_t fill_value; Image im1(w,h); Image im2(w,h,1); Image im3(w,h,fill_value,1); image.recreate(w,h); image.recreate(w,h,1); image.recreate(w,h,fill_value,1); } Image image; }; /// \ingroup ImageConcept /// \brief 2-dimensional image whose value type models PixelValueConcept /// /// \code /// concept ImageConcept<RandomAccess2DImageConcept Image> /// { /// where MutableImageViewConcept<view_t>; /// typename coord_t = view_t::coord_t; /// }; /// \endcode template <typename Image> struct ImageConcept { void constraints() { gil_function_requires<RandomAccess2DImageConcept<Image>>(); gil_function_requires<MutableImageViewConcept<typename Image::view_t>>(); using coord_t = typename Image::coord_t; static_assert(num_channels<Image>::value == mp11::mp_size<typename color_space_type<Image>::type>::value, ""); static_assert(std::is_same<coord_t, typename Image::x_coord_t>::value, ""); static_assert(std::is_same<coord_t, typename Image::y_coord_t>::value, ""); } Image image; }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[�]vg}��}��concepts/concept_check.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_CONCEPTS_CHECK_HPP #define BOOST_GIL_CONCEPTS_CONCEPTS_CHECK_HPP #include <boost/config.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wconversion" #pragma clang diagnostic ignored "-Wfloat-equal" #pragma clang diagnostic ignored "-Wuninitialized" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wfloat-equal" #pragma GCC diagnostic ignored "-Wuninitialized" #endif #include <boost/concept_check.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif // TODO: Document BOOST_GIL_USE_CONCEPT_CHECK here namespace boost { namespace gil { // TODO: What is BOOST_GIL_CLASS_REQUIRE for; Why not use BOOST_CLASS_REQUIRE? // TODO: What is gil_function_requires for; Why not function_requires? #ifdef BOOST_GIL_USE_CONCEPT_CHECK #define BOOST_GIL_CLASS_REQUIRE(type_var, ns, concept) \ BOOST_CLASS_REQUIRE(type_var, ns, concept); template <typename Concept> void gil_function_requires() { function_requires<Concept>(); } #else #define BOOST_GIL_CLASS_REQUIRE(type_var, ns, concept) template <typename C> void gil_function_requires() {} #endif }} // namespace boost::gil: #endif PK��p�[�U��s��s��concepts/detail/type_traits.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_DETAIL_TYPE_TRAITS_HPP #define BOOST_GIL_CONCEPTS_DETAIL_TYPE_TRAITS_HPP #include <type_traits> namespace boost { namespace gil { namespace detail { // TODO: C++20: deprecate and replace with std::std_remove_cvref template <typename T> struct remove_const_and_reference : std::remove_const<typename std::remove_reference<T>::type> { }; }}} // namespace boost::gil::detail #endif PK��p�[�I��concepts/detail/utility.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_DETAIL_UTILITY_HPP #define BOOST_GIL_CONCEPTS_DETAIL_UTILITY_HPP namespace boost { namespace gil { namespace detail { // TODO: Remove, replace with ignore_unised? template <typename T> void initialize_it(T&) {} }}} // namespace boost::gil::detail #endif PK��p�[�8�hf-��f-��concepts/color_base.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_COLOR_BASE_HPP #define BOOST_GIL_CONCEPTS_COLOR_BASE_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/color.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/core/ignore_unused.hpp> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { // Forward declarations of at_c namespace detail { template <typename Element, typename Layout, int K> struct homogeneous_color_base; } // namespace detail template <int K, typename E, typename L, int N> auto at_c(detail::homogeneous_color_base<E, L, N>& p) -> typename std::add_lvalue_reference<E>::type; template <int K, typename E, typename L, int N> auto at_c(detail::homogeneous_color_base<E, L, N> const& p) -> typename std::add_lvalue_reference<typename std::add_const<E>::type>::type; template <typename P, typename C, typename L> struct packed_pixel; template <int K, typename P, typename C, typename L> auto at_c(packed_pixel<P, C, L>& p) -> typename kth_element_reference_type<packed_pixel<P, C, L>, K>::type; template <int K, typename P, typename C, typename L> auto at_c(packed_pixel<P, C, L> const& p) -> typename kth_element_const_reference_type<packed_pixel<P, C, L>, K>::type; template <typename B, typename C, typename L, bool M> struct bit_aligned_pixel_reference; template <int K, typename B, typename C, typename L, bool M> inline auto at_c(bit_aligned_pixel_reference<B, C, L, M> const& p) -> typename kth_element_reference_type < bit_aligned_pixel_reference<B, C, L, M>, K >::type; // Forward declarations of semantic_at_c template <int K, typename ColorBase> auto semantic_at_c(ColorBase& p) -> typename std::enable_if < !std::is_const<ColorBase>::value, typename kth_semantic_element_reference_type<ColorBase, K>::type >::type; template <int K, typename ColorBase> auto semantic_at_c(ColorBase const& p) -> typename kth_semantic_element_const_reference_type<ColorBase, K>::type; /// \ingroup ColorBaseConcept /// \brief A color base is a container of color elements (such as channels, channel references or channel pointers). /// /// The most common use of color base is in the implementation of a pixel, /// in which case the color elements are channel values. The color base concept, /// however, can be used in other scenarios. For example, a planar pixel has /// channels that are not contiguous in memory. Its reference is a proxy class /// that uses a color base whose elements are channel references. Its iterator /// uses a color base whose elements are channel iterators. /// /// A color base must have an associated layout (which consists of a color space, /// as well as an ordering of the channels). /// There are two ways to index the elements of a color base: A physical index /// corresponds to the way they are ordered in memory, and a semantic index /// corresponds to the way the elements are ordered in their color space. /// For example, in the RGB color space the elements are ordered as /// {red_t, green_t, blue_t}. For a color base with a BGR layout, the first element /// in physical ordering is the blue element, whereas the first semantic element /// is the red one. /// Models of \p ColorBaseConcept are required to provide the \p at_c<K>(ColorBase) /// function, which allows for accessing the elements based on their physical order. /// GIL provides a \p semantic_at_c<K>(ColorBase) function (described later) /// which can operate on any model of ColorBaseConcept and returns the corresponding /// semantic element. /// /// \code /// concept ColorBaseConcept<typename T> : CopyConstructible<T>, EqualityComparable<T> /// { /// // a GIL layout (the color space and element permutation) /// typename layout_t; /// /// // The type of K-th element /// template <int K> /// struct kth_element_type; /// where Metafunction<kth_element_type>; /// /// // The result of at_c /// template <int K> /// struct kth_element_const_reference_type; /// where Metafunction<kth_element_const_reference_type>; /// /// template <int K> /// kth_element_const_reference_type<T,K>::type at_c(T); /// /// // Copy-constructible and equality comparable with other compatible color bases /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> } /// T::T(T2); /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> } /// bool operator==(const T&, const T2&); /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> } /// bool operator!=(const T&, const T2&); /// }; /// \endcode template <typename ColorBase> struct ColorBaseConcept { void constraints() { gil_function_requires<CopyConstructible<ColorBase>>(); gil_function_requires<EqualityComparable<ColorBase>>(); using color_space_t = typename ColorBase::layout_t::color_space_t; gil_function_requires<ColorSpaceConcept<color_space_t>>(); using channel_mapping_t = typename ColorBase::layout_t::channel_mapping_t; // TODO: channel_mapping_t must be an Boost.MP11-compatible random access sequence static const int num_elements = size<ColorBase>::value; using TN = typename kth_element_type<ColorBase, num_elements - 1>::type; using RN = typename kth_element_const_reference_type<ColorBase, num_elements - 1>::type; RN r = gil::at_c<num_elements - 1>(cb); boost::ignore_unused(r); // functions that work for every pixel (no need to require them) semantic_at_c<0>(cb); semantic_at_c<num_elements-1>(cb); // also static_max(cb), static_min(cb), static_fill(cb,value), // and all variations of static_for_each(), static_generate(), static_transform() } ColorBase cb; }; /// \ingroup ColorBaseConcept /// \brief Color base which allows for modifying its elements /// \code /// concept MutableColorBaseConcept<ColorBaseConcept T> : Assignable<T>, Swappable<T> /// { /// template <int K> /// struct kth_element_reference_type; where Metafunction<kth_element_reference_type>; /// /// template <int K> /// kth_element_reference_type<kth_element_type<T,K>::type>::type at_c(T); /// /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> } /// T& operator=(T&, const T2&); /// }; /// \endcode template <typename ColorBase> struct MutableColorBaseConcept { void constraints() { gil_function_requires<ColorBaseConcept<ColorBase>>(); gil_function_requires<Assignable<ColorBase>>(); gil_function_requires<Swappable<ColorBase>>(); using R0 = typename kth_element_reference_type<ColorBase, 0>::type; R0 r = gil::at_c<0>(cb); gil::at_c<0>(cb) = r; } ColorBase cb; }; /// \ingroup ColorBaseConcept /// \brief Color base that also has a default-constructor. Refines Regular /// \code /// concept ColorBaseValueConcept<typename T> : MutableColorBaseConcept<T>, Regular<T> /// { /// }; /// \endcode template <typename ColorBase> struct ColorBaseValueConcept { void constraints() { gil_function_requires<MutableColorBaseConcept<ColorBase>>(); gil_function_requires<Regular<ColorBase>>(); } }; /// \ingroup ColorBaseConcept /// \brief Color base whose elements all have the same type /// \code /// concept HomogeneousColorBaseConcept<ColorBaseConcept CB> /// { /// // For all K in [0 ... size<C1>::value-1): /// // where SameType<kth_element_type<CB,K>::type, kth_element_type<CB,K+1>::type>; /// kth_element_const_reference_type<CB,0>::type dynamic_at_c(CB const&, std::size_t n) const; /// }; /// \endcode template <typename ColorBase> struct HomogeneousColorBaseConcept { void constraints() { gil_function_requires<ColorBaseConcept<ColorBase>>(); static const int num_elements = size<ColorBase>::value; using T0 = typename kth_element_type<ColorBase, 0>::type; using TN = typename kth_element_type<ColorBase, num_elements - 1>::type; static_assert(std::is_same<T0, TN>::value, ""); // better than nothing using R0 = typename kth_element_const_reference_type<ColorBase, 0>::type; R0 r = dynamic_at_c(cb, 0); boost::ignore_unused(r); } ColorBase cb; }; /// \ingroup ColorBaseConcept /// \brief Homogeneous color base that allows for modifying its elements /// \code /// concept MutableHomogeneousColorBaseConcept<ColorBaseConcept CB> /// : HomogeneousColorBaseConcept<CB> /// { /// kth_element_reference_type<CB, 0>::type dynamic_at_c(CB&, std::size_t n); /// }; /// \endcode template <typename ColorBase> struct MutableHomogeneousColorBaseConcept { void constraints() { gil_function_requires<ColorBaseConcept<ColorBase>>(); gil_function_requires<HomogeneousColorBaseConcept<ColorBase>>(); using R0 = typename kth_element_reference_type<ColorBase, 0>::type; R0 r = dynamic_at_c(cb, 0); boost::ignore_unused(r); dynamic_at_c(cb, 0) = dynamic_at_c(cb, 0); } ColorBase cb; }; /// \ingroup ColorBaseConcept /// \brief Homogeneous color base that also has a default constructor. /// Refines Regular. /// /// \code /// concept HomogeneousColorBaseValueConcept<typename T> /// : MutableHomogeneousColorBaseConcept<T>, Regular<T> /// { /// }; /// \endcode template <typename ColorBase> struct HomogeneousColorBaseValueConcept { void constraints() { gil_function_requires<MutableHomogeneousColorBaseConcept<ColorBase>>(); gil_function_requires<Regular<ColorBase>>(); } }; /// \ingroup ColorBaseConcept /// \brief Two color bases are compatible if they have the same color space and their elements are compatible, semantic-pairwise. /// \code /// concept ColorBasesCompatibleConcept<ColorBaseConcept C1, ColorBaseConcept C2> /// { /// where SameType<C1::layout_t::color_space_t, C2::layout_t::color_space_t>; /// // also, for all K in [0 ... size<C1>::value): /// // where Convertible<kth_semantic_element_type<C1,K>::type, kth_semantic_element_type<C2,K>::type>; /// // where Convertible<kth_semantic_element_type<C2,K>::type, kth_semantic_element_type<C1,K>::type>; /// }; /// \endcode template <typename ColorBase1, typename ColorBase2> struct ColorBasesCompatibleConcept { void constraints() { static_assert(std::is_same < typename ColorBase1::layout_t::color_space_t, typename ColorBase2::layout_t::color_space_t >::value, ""); // using e1 = typename kth_semantic_element_type<ColorBase1,0>::type; // using e2 = typename kth_semantic_element_type<ColorBase2,0>::type; // "e1 is convertible to e2" } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�['�wb��b��concepts/dynamic_step.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_DYNAMIC_STEP_HPP #define BOOST_GIL_CONCEPTS_DYNAMIC_STEP_HPP #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/concept_check.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \ingroup PixelIteratorConcept /// \brief Concept for iterators, locators and views that can define a type just like the given /// iterator, locator or view, except it supports runtime specified step along the X navigation. /// /// \code /// concept HasDynamicXStepTypeConcept<typename T> /// { /// typename dynamic_x_step_type<T>; /// where Metafunction<dynamic_x_step_type<T> >; /// }; /// \endcode template <typename T> struct HasDynamicXStepTypeConcept { void constraints() { using type = typename dynamic_x_step_type<T>::type; ignore_unused_variable_warning(type{}); } }; /// \ingroup PixelLocatorConcept /// \brief Concept for locators and views that can define a type just like the given locator or view, /// except it supports runtime specified step along the Y navigation /// \code /// concept HasDynamicYStepTypeConcept<typename T> /// { /// typename dynamic_y_step_type<T>; /// where Metafunction<dynamic_y_step_type<T> >; /// }; /// \endcode template <typename T> struct HasDynamicYStepTypeConcept { void constraints() { using type = typename dynamic_y_step_type<T>::type; ignore_unused_variable_warning(type{}); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[:X�=}��}��concepts/basic.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_BASIC_HPP #define BOOST_GIL_CONCEPTS_BASIC_HPP #include <boost/config.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #pragma clang diagnostic ignored "-Wuninitialized" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #pragma GCC diagnostic ignored "-Wuninitialized" #endif #include <boost/gil/concepts/concept_check.hpp> #include <type_traits> #include <utility> // std::swap namespace boost { namespace gil { /// \brief Concept of default construction requirement. /// \code /// auto concept DefaultConstructible<typename T> /// { /// T::T(); /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct DefaultConstructible { void constraints() { function_requires<boost::DefaultConstructibleConcept<T>>(); } }; /// \brief Concept of copy construction requirement. /// \code /// auto concept CopyConstructible<typename T> /// { /// T::T(T); /// T::~T(); /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct CopyConstructible { void constraints() { function_requires<boost::CopyConstructibleConcept<T>>(); } }; /// \brief Concept of copy assignment requirement. /// \code /// auto concept Assignable<typename T, typename U = T> /// { /// typename result_type; /// result_type operator=(T&, U); /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct Assignable { void constraints() { function_requires<boost::AssignableConcept<T>>(); } }; /// \brief Concept of == and != comparability requirement. /// \code /// auto concept EqualityComparable<typename T, typename U = T> /// { /// bool operator==(T x, T y); /// bool operator!=(T x, T y) { return !(x==y); } /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct EqualityComparable { void constraints() { function_requires<boost::EqualityComparableConcept<T>>(); } }; /// \brief Concept of swap operation requirement. /// \code /// auto concept Swappable<typename T> /// { /// void swap(T&,T&); /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct Swappable { void constraints() { using std::swap; swap(x,y); } T x,y; }; /// \brief Concept for type regularity requirement. /// \code /// auto concept Regular<typename T> /// : DefaultConstructible<T> /// , CopyConstructible<T> /// , EqualityComparable<T> /// , Assignable<T> /// , Swappable<T> /// {}; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct Regular { void constraints() { gil_function_requires< boost::DefaultConstructibleConcept<T>>(); gil_function_requires< boost::CopyConstructibleConcept<T>>(); gil_function_requires< boost::EqualityComparableConcept<T>>(); // ==, != gil_function_requires< boost::AssignableConcept<T>>(); gil_function_requires< Swappable<T>>(); } }; /// \brief Concept for type as metafunction requirement. /// \code /// auto concept Metafunction<typename T> /// { /// typename type; /// }; /// \endcode /// \ingroup BasicConcepts /// template <typename T> struct Metafunction { void constraints() { using type = typename T::type; } }; /// \brief Concept of types equivalence requirement. /// \code /// auto concept SameType<typename T, typename U>; // unspecified /// \endcode /// \ingroup BasicConcepts /// template <typename T, typename U> struct SameType { void constraints() { static_assert(std::is_same<T, U>::value, ""); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[��!��!��concepts/pixel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_PIXEL_HPP #define BOOST_GIL_CONCEPTS_PIXEL_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/channel.hpp> #include <boost/gil/concepts/color.hpp> #include <boost/gil/concepts/color_base.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/pixel_based.hpp> #include <boost/gil/concepts/detail/type_traits.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \brief Pixel concept - A color base whose elements are channels /// \ingroup PixelConcept /// \code /// concept PixelConcept<typename P> : ColorBaseConcept<P>, PixelBasedConcept<P> /// { /// where is_pixel<P>::value == true; /// // where for each K [0..size<P>::value - 1]: /// // ChannelConcept<kth_element_type<P, K>>; /// /// typename P::value_type; /// where PixelValueConcept<value_type>; /// typename P::reference; /// where PixelConcept<reference>; /// typename P::const_reference; /// where PixelConcept<const_reference>; /// static const bool P::is_mutable; /// /// template <PixelConcept P2> where { PixelConcept<P, P2> } /// P::P(P2); /// template <PixelConcept P2> where { PixelConcept<P, P2> } /// bool operator==(const P&, const P2&); /// template <PixelConcept P2> where { PixelConcept<P, P2> } /// bool operator!=(const P&, const P2&); /// }; /// \endcode template <typename P> struct PixelConcept { void constraints() { gil_function_requires<ColorBaseConcept<P>>(); gil_function_requires<PixelBasedConcept<P>>(); static_assert(is_pixel<P>::value, ""); static const bool is_mutable = P::is_mutable; ignore_unused_variable_warning(is_mutable); using value_type = typename P::value_type; // TODO: Is the cyclic dependency intentional? --mloskot // gil_function_requires<PixelValueConcept<value_type>>(); using reference = typename P::reference; gil_function_requires<PixelConcept < typename detail::remove_const_and_reference<reference>::type >>(); using const_reference = typename P::const_reference; gil_function_requires<PixelConcept < typename detail::remove_const_and_reference<const_reference>::type >>(); } }; /// \brief Pixel concept that allows for changing its channels /// \ingroup PixelConcept /// \code /// concept MutablePixelConcept<PixelConcept P> : MutableColorBaseConcept<P> /// { /// where is_mutable==true; /// }; /// \endcode template <typename P> struct MutablePixelConcept { void constraints() { gil_function_requires<PixelConcept<P>>(); static_assert(P::is_mutable, ""); } }; /// \brief Homogeneous pixel concept /// \ingroup PixelConcept /// \code /// concept HomogeneousPixelConcept<PixelConcept P> /// : HomogeneousColorBaseConcept<P>, HomogeneousPixelBasedConcept<P> /// { /// P::template element_const_reference_type<P>::type operator[](P p, std::size_t i) const /// { /// return dynamic_at_c(p,i); /// } /// }; /// \endcode template <typename P> struct HomogeneousPixelConcept { void constraints() { gil_function_requires<PixelConcept<P>>(); gil_function_requires<HomogeneousColorBaseConcept<P>>(); gil_function_requires<HomogeneousPixelBasedConcept<P>>(); p[0]; } P p; }; /// \brief Homogeneous pixel concept that allows for changing its channels /// \ingroup PixelConcept /// \code /// concept MutableHomogeneousPixelConcept<HomogeneousPixelConcept P> /// : MutableHomogeneousColorBaseConcept<P> /// { /// P::template element_reference_type<P>::type operator[](P p, std::size_t i) /// { /// return dynamic_at_c(p, i); /// } /// }; /// \endcode template <typename P> struct MutableHomogeneousPixelConcept { void constraints() { gil_function_requires<HomogeneousPixelConcept<P>>(); gil_function_requires<MutableHomogeneousColorBaseConcept<P>>(); p[0] = v; v = p[0]; } typename P::template element_type<P>::type v; P p; }; /// \brief Pixel concept that is a Regular type /// \ingroup PixelConcept /// \code /// concept PixelValueConcept<PixelConcept P> : Regular<P> /// { /// where SameType<value_type,P>; /// }; /// \endcode template <typename P> struct PixelValueConcept { void constraints() { gil_function_requires<PixelConcept<P>>(); gil_function_requires<Regular<P>>(); } }; /// \brief Homogeneous pixel concept that is a Regular type /// \ingroup PixelConcept /// \code /// concept HomogeneousPixelValueConcept<HomogeneousPixelConcept P> : Regular<P> /// { /// where SameType<value_type,P>; /// }; /// \endcode template <typename P> struct HomogeneousPixelValueConcept { void constraints() { gil_function_requires<HomogeneousPixelConcept<P>>(); gil_function_requires<Regular<P>>(); static_assert(std::is_same<P, typename P::value_type>::value, ""); } }; namespace detail { template <typename P1, typename P2, int K> struct channels_are_pairwise_compatible : mp11::mp_and < channels_are_pairwise_compatible<P1, P2, K - 1>, channels_are_compatible < typename kth_semantic_element_reference_type<P1, K>::type, typename kth_semantic_element_reference_type<P2, K>::type > > { }; template <typename P1, typename P2> struct channels_are_pairwise_compatible<P1, P2, -1> : std::true_type {}; } // namespace detail /// \ingroup PixelAlgorithm /// \brief Returns whether two pixels are compatible /// Pixels are compatible if their channels and color space types are compatible. /// Compatible pixels can be assigned and copy constructed from one another. /// \tparam P1 Models PixelConcept /// \tparam P2 Models PixelConcept template <typename P1, typename P2> struct pixels_are_compatible : mp11::mp_and < typename color_spaces_are_compatible < typename color_space_type<P1>::type, typename color_space_type<P2>::type >::type, detail::channels_are_pairwise_compatible < P1, P2, num_channels<P1>::value - 1 > > { }; /// \ingroup PixelConcept /// \brief Concept for pixel compatibility /// Pixels are compatible if their channels and color space types are compatible. /// Compatible pixels can be assigned and copy constructed from one another. /// \tparam P1 Models PixelConcept /// \tparam P2 Models PixelConcept /// \code /// concept PixelsCompatibleConcept<PixelConcept P1, PixelConcept P2> /// : ColorBasesCompatibleConcept<P1,P2> { /// // where for each K [0..size<P1>::value): /// // ChannelsCompatibleConcept<kth_semantic_element_type<P1,K>::type, kth_semantic_element_type<P2,K>::type>; /// }; /// \endcode template <typename P1, typename P2> struct PixelsCompatibleConcept { void constraints() { static_assert(pixels_are_compatible<P1, P2>::value, ""); } }; /// \ingroup PixelConcept /// \brief Pixel convertible concept /// Convertibility is non-symmetric and implies that one pixel /// can be converted to another, approximating the color. /// Conversion is explicit and sometimes lossy. /// \code /// template <PixelConcept SrcPixel, MutablePixelConcept DstPixel> /// concept PixelConvertibleConcept /// { /// void color_convert(const SrcPixel&, DstPixel&); /// }; /// \endcode template <typename SrcP, typename DstP> struct PixelConvertibleConcept { void constraints() { gil_function_requires<PixelConcept<SrcP>>(); gil_function_requires<MutablePixelConcept<DstP>>(); color_convert(src, dst); } SrcP src; DstP dst; }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[T�8��concepts/pixel_based.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_PIXEL_BASED_HPP #define BOOST_GIL_CONCEPTS_PIXEL_BASED_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/channel.hpp> #include <boost/gil/concepts/color.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <cstddef> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { /// \ingroup PixelBasedConcept /// \brief Concept for all pixel-based GIL constructs. /// /// Pixel-based constructs include pixels, iterators, locators, views and /// images whose value type is a pixel. /// /// \code /// concept PixelBasedConcept<typename T> /// { /// typename color_space_type<T>; /// where Metafunction<color_space_type<T> >; /// where ColorSpaceConcept<color_space_type<T>::type>; /// typename channel_mapping_type<T>; /// where Metafunction<channel_mapping_type<T> >; /// where ChannelMappingConcept<channel_mapping_type<T>::type>; /// typename is_planar<T>; /// where Metafunction<is_planar<T> >; /// where SameType<is_planar<T>::type, bool>; /// }; /// \endcode template <typename P> struct PixelBasedConcept { void constraints() { using color_space_t = typename color_space_type<P>::type; gil_function_requires<ColorSpaceConcept<color_space_t>>(); using channel_mapping_t = typename channel_mapping_type<P>::type ; gil_function_requires<ChannelMappingConcept<channel_mapping_t>>(); static const bool planar = is_planar<P>::value; ignore_unused_variable_warning(planar); // This is not part of the concept, but should still work static const std::size_t nc = num_channels<P>::value; ignore_unused_variable_warning(nc); } }; /// \brief Concept for homogeneous pixel-based GIL constructs /// \ingroup PixelBasedConcept /// \code /// concept HomogeneousPixelBasedConcept<PixelBasedConcept T> /// { /// typename channel_type<T>; /// where Metafunction<channel_type<T>>; /// where ChannelConcept<channel_type<T>::type>; /// }; /// \endcode template <typename P> struct HomogeneousPixelBasedConcept { void constraints() { gil_function_requires<PixelBasedConcept<P>>(); using channel_t = typename channel_type<P>::type; gil_function_requires<ChannelConcept<channel_t>>(); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[H��/��/��concepts/pixel_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_PIXEL_ITERATOR_HPP #define BOOST_GIL_CONCEPTS_PIXEL_ITERATOR_HPP #include <boost/gil/concepts/channel.hpp> #include <boost/gil/concepts/color.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <boost/gil/concepts/fwd.hpp> #include <boost/gil/concepts/pixel.hpp> #include <boost/gil/concepts/pixel_based.hpp> #include <boost/iterator/iterator_concepts.hpp> #include <cstddef> #include <iterator> #include <type_traits> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { // Forward declarations template <typename It> struct const_iterator_type; template <typename It> struct iterator_is_mutable; template <typename It> struct is_iterator_adaptor; template <typename It, typename NewBaseIt> struct iterator_adaptor_rebind; template <typename It> struct iterator_adaptor_get_base; // These iterator mutability concepts are taken from Boost concept_check.hpp. // Isolating mutability to result in faster compile time namespace detail { // Preconditions: TT Models boost_concepts::ForwardTraversalConcept template <class TT> struct ForwardIteratorIsMutableConcept { void constraints() { auto const tmp = i; i++ = tmp; // require postincrement and assignment } TT i; }; // Preconditions: TT Models boost::BidirectionalIteratorConcept template <class TT> struct BidirectionalIteratorIsMutableConcept { void constraints() { gil_function_requires< ForwardIteratorIsMutableConcept<TT>>(); auto const tmp = i; i-- = tmp; // require postdecrement and assignment } TT i; }; // Preconditions: TT Models boost_concepts::RandomAccessTraversalConcept template <class TT> struct RandomAccessIteratorIsMutableConcept { void constraints() { gil_function_requires<BidirectionalIteratorIsMutableConcept<TT>>(); typename std::iterator_traits<TT>::difference_type n = 0; ignore_unused_variable_warning(n); i[n] = i; // require element access and assignment } TT i; }; // Iterators that can be used as the base of memory_based_step_iterator require some additional functions // \tparam Iterator Models boost_concepts::RandomAccessTraversalConcept template <typename Iterator> struct RandomAccessIteratorIsMemoryBasedConcept { void constraints() { std::ptrdiff_t bs = memunit_step(it); ignore_unused_variable_warning(bs); it = memunit_advanced(it, 3); std::ptrdiff_t bd = memunit_distance(it, it); ignore_unused_variable_warning(bd); memunit_advance(it,3); // for performace you may also provide a customized implementation of memunit_advanced_ref } Iterator it; }; /// \tparam Iterator Models PixelIteratorConcept template <typename Iterator> struct PixelIteratorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<Iterator>>(); using ref_t = typename std::remove_reference < typename std::iterator_traits<Iterator>::reference >::type; using channel_t = typename element_type<ref_t>::type; gil_function_requires<detail::ChannelIsMutableConcept<channel_t>>(); } }; } // namespace detail /// \ingroup PixelLocatorConcept /// \brief Concept for locators and views that can define a type just like the given locator or view, except X and Y is swapped /// \code /// concept HasTransposedTypeConcept<typename T> /// { /// typename transposed_type<T>; /// where Metafunction<transposed_type<T> >; /// }; /// \endcode template <typename T> struct HasTransposedTypeConcept { void constraints() { using type = typename transposed_type<T>::type; ignore_unused_variable_warning(type{}); } }; /// \defgroup PixelIteratorConceptPixelIterator PixelIteratorConcept /// \ingroup PixelIteratorConcept /// \brief STL iterator over pixels /// \ingroup PixelIteratorConceptPixelIterator /// \brief An STL random access traversal iterator over a model of PixelConcept. /// /// GIL's iterators must also provide the following metafunctions: /// - \p const_iterator_type<Iterator>: Returns a read-only equivalent of \p Iterator /// - \p iterator_is_mutable<Iterator>: Returns whether the given iterator is read-only or mutable /// - \p is_iterator_adaptor<Iterator>: Returns whether the given iterator is an adaptor over another iterator. See IteratorAdaptorConcept for additional requirements of adaptors. /// /// \code /// concept PixelIteratorConcept<typename Iterator> /// : boost_concepts::RandomAccessTraversalConcept<Iterator>, PixelBasedConcept<Iterator> /// { /// where PixelValueConcept<value_type>; /// typename const_iterator_type<It>::type; /// where PixelIteratorConcept<const_iterator_type<It>::type>; /// static const bool iterator_is_mutable<It>::value; /// static const bool is_iterator_adaptor<It>::value; // is it an iterator adaptor /// }; /// \endcode template <typename Iterator> struct PixelIteratorConcept { void constraints() { gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator>>(); gil_function_requires<PixelBasedConcept<Iterator>>(); using value_type = typename std::iterator_traits<Iterator>::value_type; gil_function_requires<PixelValueConcept<value_type>>(); using const_t = typename const_iterator_type<Iterator>::type; static bool const is_mutable = iterator_is_mutable<Iterator>::value; ignore_unused_variable_warning(is_mutable); // immutable iterator must be constructible from (possibly mutable) iterator const_t const_it(it); ignore_unused_variable_warning(const_it); check_base(typename is_iterator_adaptor<Iterator>::type()); } void check_base(std::false_type) {} void check_base(std::true_type) { using base_t = typename iterator_adaptor_get_base<Iterator>::type; gil_function_requires<PixelIteratorConcept<base_t>>(); } Iterator it; }; /// \brief Pixel iterator that allows for changing its pixel /// \ingroup PixelIteratorConceptPixelIterator /// \code /// concept MutablePixelIteratorConcept<PixelIteratorConcept Iterator> /// : MutableRandomAccessIteratorConcept<Iterator> {}; /// \endcode template <typename Iterator> struct MutablePixelIteratorConcept { void constraints() { gil_function_requires<PixelIteratorConcept<Iterator>>(); gil_function_requires<detail::PixelIteratorIsMutableConcept<Iterator>>(); } }; /// \defgroup PixelIteratorConceptStepIterator StepIteratorConcept /// \ingroup PixelIteratorConcept /// \brief Iterator that advances by a specified step /// \ingroup PixelIteratorConceptStepIterator /// \brief Concept of a random-access iterator that can be advanced in memory units (bytes or bits) /// \code /// concept MemoryBasedIteratorConcept<boost_concepts::RandomAccessTraversalConcept Iterator> /// { /// typename byte_to_memunit<Iterator>; where metafunction<byte_to_memunit<Iterator> >; /// std::ptrdiff_t memunit_step(const Iterator&); /// std::ptrdiff_t memunit_distance(const Iterator& , const Iterator&); /// void memunit_advance(Iterator&, std::ptrdiff_t diff); /// Iterator memunit_advanced(const Iterator& p, std::ptrdiff_t diff) { Iterator tmp; memunit_advance(tmp,diff); return tmp; } /// Iterator::reference memunit_advanced_ref(const Iterator& p, std::ptrdiff_t diff) { return memunit_advanced(p,diff); } /// }; /// \endcode template <typename Iterator> struct MemoryBasedIteratorConcept { void constraints() { gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator>>(); gil_function_requires<detail::RandomAccessIteratorIsMemoryBasedConcept<Iterator>>(); } }; /// \ingroup PixelIteratorConceptStepIterator /// \brief Step iterator concept /// /// Step iterators are iterators that have a set_step method /// \code /// concept StepIteratorConcept<boost_concepts::ForwardTraversalConcept Iterator> /// { /// template <Integral D> /// void Iterator::set_step(D step); /// }; /// \endcode template <typename Iterator> struct StepIteratorConcept { void constraints() { gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator>>(); it.set_step(0); } Iterator it; }; /// \ingroup PixelIteratorConceptStepIterator /// \brief Step iterator that allows for modifying its current value /// \code /// concept MutableStepIteratorConcept<Mutable_ForwardIteratorConcept Iterator> /// : StepIteratorConcept<Iterator> {}; /// \endcode template <typename Iterator> struct MutableStepIteratorConcept { void constraints() { gil_function_requires<StepIteratorConcept<Iterator>>(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator>>(); } }; /// \defgroup PixelIteratorConceptIteratorAdaptor IteratorAdaptorConcept /// \ingroup PixelIteratorConcept /// \brief Adaptor over another iterator /// \ingroup PixelIteratorConceptIteratorAdaptor /// \brief Iterator adaptor is a forward iterator adapting another forward iterator. /// /// In addition to GIL iterator requirements, /// GIL iterator adaptors must provide the following metafunctions: /// - \p is_iterator_adaptor<Iterator>: Returns \p std::true_type /// - \p iterator_adaptor_get_base<Iterator>: Returns the base iterator type /// - \p iterator_adaptor_rebind<Iterator,NewBase>: Replaces the base iterator with the new one /// /// The adaptee can be obtained from the iterator via the "base()" method. /// /// \code /// concept IteratorAdaptorConcept<boost_concepts::ForwardTraversalConcept Iterator> /// { /// where SameType<is_iterator_adaptor<Iterator>::type, std::true_type>; /// /// typename iterator_adaptor_get_base<Iterator>; /// where Metafunction<iterator_adaptor_get_base<Iterator> >; /// where boost_concepts::ForwardTraversalConcept<iterator_adaptor_get_base<Iterator>::type>; /// /// typename another_iterator; /// typename iterator_adaptor_rebind<Iterator,another_iterator>::type; /// where boost_concepts::ForwardTraversalConcept<another_iterator>; /// where IteratorAdaptorConcept<iterator_adaptor_rebind<Iterator,another_iterator>::type>; /// /// const iterator_adaptor_get_base<Iterator>::type& Iterator::base() const; /// }; /// \endcode template <typename Iterator> struct IteratorAdaptorConcept { void constraints() { gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator>>(); using base_t = typename iterator_adaptor_get_base<Iterator>::type; gil_function_requires<boost_concepts::ForwardTraversalConcept<base_t>>(); static_assert(is_iterator_adaptor<Iterator>::value, ""); using rebind_t = typename iterator_adaptor_rebind<Iterator, void>::type; base_t base = it.base(); ignore_unused_variable_warning(base); } Iterator it; }; /// \brief Iterator adaptor that is mutable /// \ingroup PixelIteratorConceptIteratorAdaptor /// \code /// concept MutableIteratorAdaptorConcept<Mutable_ForwardIteratorConcept Iterator> /// : IteratorAdaptorConcept<Iterator> {}; /// \endcode template <typename Iterator> struct MutableIteratorAdaptorConcept { void constraints() { gil_function_requires<IteratorAdaptorConcept<Iterator>>(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator>>(); } }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[r� B��concepts/point.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CONCEPTS_POINT_HPP #define BOOST_GIL_CONCEPTS_POINT_HPP #include <boost/gil/concepts/basic.hpp> #include <boost/gil/concepts/concept_check.hpp> #include <cstddef> #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wunused-local-typedefs" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-local-typedefs" #endif namespace boost { namespace gil { // Forward declarations template <typename T> class point; template <std::size_t K, typename T> T const& axis_value(point<T> const& p); template <std::size_t K, typename T> T& axis_value(point<T>& p); /// \brief N-dimensional point concept /// \code /// concept PointNDConcept<typename T> : Regular<T> /// { /// // the type of a coordinate along each axis /// template <size_t K> /// struct axis; where Metafunction<axis>; /// /// const size_t num_dimensions; /// /// // accessor/modifier of the value of each axis. /// /// template <size_t K> /// typename axis<K>::type const& T::axis_value() const; /// /// template <size_t K> /// typename axis<K>::type& T::axis_value(); /// }; /// \endcode /// \ingroup PointConcept /// template <typename P> struct PointNDConcept { void constraints() { gil_function_requires<Regular<P>>(); using value_type = typename P::value_type; ignore_unused_variable_warning(value_type{}); static const std::size_t N = P::num_dimensions; ignore_unused_variable_warning(N); using FT = typename P::template axis<0>::coord_t; using LT = typename P::template axis<N - 1>::coord_t; FT ft = gil::axis_value<0>(point); axis_value<0>(point) = ft; LT lt = axis_value<N - 1>(point); axis_value<N - 1>(point) = lt; //value_type v=point[0]; //ignore_unused_variable_warning(v); } P point; }; /// \brief 2-dimensional point concept /// \code /// concept Point2DConcept<typename T> : PointNDConcept<T> /// { /// where num_dimensions == 2; /// where SameType<axis<0>::type, axis<1>::type>; /// /// typename value_type = axis<0>::type; /// /// value_type const& operator[](T const&, size_t i); /// value_type& operator[](T&, size_t i); /// /// value_type x,y; /// }; /// \endcode /// \ingroup PointConcept /// template <typename P> struct Point2DConcept { void constraints() { gil_function_requires<PointNDConcept<P>>(); static_assert(P::num_dimensions == 2, ""); point.x = point.y; point[0] = point[1]; } P point; }; }} // namespace boost::gil #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif PK��p�[+k�&��&�� pixel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_PIXEL_HPP #define BOOST_GIL_PIXEL_HPP #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/color_base_algorithm.hpp> #include <boost/gil/concepts.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/gil/utilities.hpp> #include <boost/gil/detail/mp11.hpp> #include <functional> #include <type_traits> namespace boost { namespace gil { // Forward-declare gray_t struct gray_color_t; using gray_t = mp11::mp_list<gray_color_t>; template <typename PixelBased> struct color_space_type; template <typename PixelBased> struct channel_mapping_type; template <typename PixelBased> struct channel_type; template <typename PixelBased> struct is_planar; template <typename PixelBased> struct color_space_type<PixelBased const> : color_space_type<PixelBased> {}; template <typename PixelBased> struct channel_mapping_type<PixelBased const> : channel_mapping_type<PixelBased> {}; template <typename PixelBased> struct channel_type<PixelBased const> : channel_type<PixelBased> {}; template <typename PixelBased> struct is_planar : std::false_type {}; template <typename PixelBased> struct is_planar<PixelBased const> : is_planar<PixelBased> {}; template <typename T> struct is_pixel : std::false_type {}; template <typename T> struct is_pixel<T const> : is_pixel<T> {}; /// \ingroup PixelBasedAlgorithm /// \brief Returns the number of channels of a pixel-based GIL construct template <typename PixelBased> struct num_channels : mp11::mp_size<typename color_space_type<PixelBased>::type>::type {}; /** \addtogroup PixelBasedAlgorithm Example: \code static_assert(num_channels<rgb8_view_t>::value == 3, ""); static_assert(num_channels<cmyk16_planar_ptr_t>::value == 4, ""); static_assert(is_planar<rgb16_planar_image_t>::value)); static_assert(std::is_same<color_space_type<rgb8_planar_ref_t>::type, rgb_t>::value, ""); static_assert(std::is_same<channel_mapping_type<cmyk8_pixel_t>::type, channel_mapping_type<rgba8_pixel_t>::type>::value, ""); static_assert(std::is_same<channel_type<bgr8_pixel_t>::type, uint8_t>::value, ""); \endcode / /// \defgroup ColorBaseModelPixel pixel /// \ingroup ColorBaseModel /// \brief A homogeneous color base whose element is a channel value. Models HomogeneousColorBaseValueConcept /// \defgroup PixelModelPixel pixel /// \ingroup PixelModel /// \brief A homogeneous pixel value. Models HomogeneousPixelValueConcept /// \ingroup PixelModelPixel ColorBaseModelPixel PixelBasedModel /// \brief Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept /// /// A pixel is a set of channels defining the color at a given point in an image. Conceptually, a pixel is little more than a color base whose elements /// model \p ChannelConcept. The class \p pixel defines a simple, homogeneous pixel value. It is used to store /// the value of a color. The built-in C++ references to \p pixel, \p pixel& and \p const \p pixel& are used to represent a reference to a pixel /// inside an interleaved image view (a view in which all channels are together in memory). Similarly, built-in pointer types \p pixel and \p const \p pixel* /// are used as the standard iterator over a row of interleaved homogeneous pixels. /// /// Since \p pixel inherits the properties of color base, assigning, equality comparison and copy-construcion are allowed between compatible pixels. /// This means that an 8-bit RGB pixel may be assigned to an 8-bit BGR pixel, or to an 8-bit planar reference. The channels are properly paired semantically. /// /// The single-channel (grayscale) instantiation of the class pixel, (i.e. \p pixel<T,gray_layout_t>) is also convertible to/from a channel value. /// This allows grayscale pixels to be used in simpler expressions like gray_pix1 = gray_pix2 instead of more complicated at_c<0>(gray_pix1) = at_c<0>(gray_pix2) /// or get_color<gray_color_t>(gray_pix1) = get_color<gray_color_t>(gray_pix2) /// /// \tparam ChannelValue TODO /// \tparam Layout mp11::make_integer_sequence<int, ColorSpace::size> template <typename ChannelValue, typename Layout> struct pixel : detail::homogeneous_color_base < ChannelValue, Layout, mp11::mp_size<typename Layout::color_space_t>::value > { private: using channel_t = ChannelValue; using parent_t = detail::homogeneous_color_base < ChannelValue, Layout, mp11::mp_size<typename Layout::color_space_t>::value >; public: using value_type = pixel<ChannelValue, Layout>; using reference = value_type&; using const_reference = value_type const&; static constexpr bool is_mutable = channel_traits<channel_t>::is_mutable; pixel() = default; explicit pixel(channel_t v) : parent_t(v) {} // sets all channels to v pixel(channel_t v0, channel_t v1) : parent_t(v0, v1) {} pixel(channel_t v0, channel_t v1, channel_t v2) : parent_t(v0, v1, v2) {} pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3) : parent_t(v0, v1, v2, v3) {} pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3, channel_t v4) : parent_t(v0, v1, v2, v3, v4) {} pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3, channel_t v4, channel_t v5) : parent_t(v0, v1, v2, v3, v4, v5) {} pixel(const pixel& p) : parent_t(p) {} pixel& operator=(pixel const& p) { static_copy(p,this); return this; } // Construct from another compatible pixel type template <typename Pixel> pixel(Pixel const& p, typename std::enable_if<is_pixel<Pixel>::value>::type* /dummy/ = nullptr) : parent_t(p) { check_compatible<Pixel>(); } template <typename Pixel> pixel& operator=(Pixel const& p) { assign(p, is_pixel<Pixel>()); return this; } template <typename Pixel> bool operator==(Pixel const& p) const { return equal(p, is_pixel<Pixel>()); } template <typename Pixel> bool operator!=(Pixel const& p) const { return !(this == p); } // homogeneous pixels have operator[] auto operator[](std::size_t index) -> typename channel_traits<channel_t>::reference { return dynamic_at_c(this, index); } auto operator[](std::size_t index) const -> typename channel_traits<channel_t>::const_reference { return dynamic_at_c(this, index); } private: template <typename Pixel> void assign(Pixel const& p, std::true_type) { check_compatible<Pixel>(); static_copy(p, this); } template <typename Pixel> bool equal(Pixel const& p, std::true_type) const { check_compatible<Pixel>(); return static_equal(this, p); } template <typename Pixel> void check_compatible() const { gil_function_requires<PixelsCompatibleConcept<Pixel, pixel>>(); } // Support for assignment/equality comparison of a channel with a grayscale pixel private: static void check_gray() { static_assert(std::is_same<typename Layout::color_space_t, gray_t>::value, ""); } template <typename Channel> void assign(Channel const& channel, std::false_type) { check_gray(); gil::at_c<0>(this) = channel; } template <typename Channel> bool equal (Channel const& channel, std::false_type) const { check_gray(); return gil::at_c<0>(this) == channel; } public: pixel& operator= (channel_t channel) { check_gray(); gil::at_c<0>(this) = channel; return this; } bool operator==(channel_t channel) const { check_gray(); return gil::at_c<0>(this) == channel; } }; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template <typename ChannelValue, typename Layout, int K> struct kth_element_type<pixel<ChannelValue,Layout>, K> { using type = ChannelValue; }; template <typename ChannelValue, typename Layout, int K> struct kth_element_reference_type<pixel<ChannelValue,Layout>, K> { using type = typename channel_traits<ChannelValue>::reference; }; template <typename ChannelValue, typename Layout, int K> struct kth_element_reference_type<const pixel<ChannelValue,Layout>, K> { using type = typename channel_traits<ChannelValue>::const_reference; }; template <typename ChannelValue, typename Layout, int K> struct kth_element_const_reference_type<pixel<ChannelValue,Layout>, K> { using type = typename channel_traits<ChannelValue>::const_reference; }; ///////////////////////////// // PixelConcept ///////////////////////////// template <typename ChannelValue, typename Layout> struct is_pixel<pixel<ChannelValue,Layout>> : std::true_type {}; ///////////////////////////// // HomogeneousPixelBasedConcept ///////////////////////////// template <typename ChannelValue, typename Layout> struct color_space_type<pixel<ChannelValue, Layout>> { using type = typename Layout::color_space_t; }; template <typename ChannelValue, typename Layout> struct channel_mapping_type<pixel<ChannelValue, Layout>> { using type = typename Layout::channel_mapping_t; }; template <typename ChannelValue, typename Layout> struct is_planar<pixel<ChannelValue, Layout>> : std::false_type {}; template <typename ChannelValue, typename Layout> struct channel_type<pixel<ChannelValue, Layout>> { using type = ChannelValue; }; }} // namespace boost::gil #endif PK��p�[k7��S'��S'��io/read_and_convert_view.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_READ_AND_CONVERT_VIEW_HPP #define BOOST_GIL_IO_READ_AND_CONVERT_VIEW_HPP #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// \ingroup IO /// \brief Reads and color-converts an image view. No memory is allocated. /// \param reader An image reader. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename Reader, typename View> inline void read_and_convert_view(Reader& reader, View const& view, typename std::enable_if < mp11::mp_and < detail::is_reader<Reader>, is_format_tag<typename Reader::format_tag_t> >::value >::type /dummy/ = nullptr) { reader.check_image_size(view.dimensions()); reader.init_view(view, reader._settings); reader.apply(view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename Device, typename View, typename ColorConverter, typename FormatTag> inline void read_and_convert_view( Device& device, View const& view, image_read_settings<FormatTag> const& settings, ColorConverter const& cc, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, settings, read_and_convert_t{cc}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename String, typename View, typename ColorConverter, typename FormatTag> inline void read_and_convert_view( String const& file_name, View const& view, image_read_settings<FormatTag> const& settings, ColorConverter const& cc, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, settings, read_and_convert_t{cc}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param cc Color converter function object. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename View, typename ColorConverter, typename FormatTag> inline void read_and_convert_view( String const& file_name, View const& view, ColorConverter const& cc, FormatTag const& tag, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, tag, read_and_convert_t{cc}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param view The image view in which the data is read into. /// \param cc Color converter function object. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename View, typename ColorConverter, typename FormatTag> inline void read_and_convert_view( Device& device, View const& view, ColorConverter const& cc, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, tag, read_and_convert_t{cc}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename String, typename View, typename FormatTag> inline void read_and_convert_view( String const& file_name, View const& view, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, settings, read_and_convert_t{}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Device, typename View, typename FormatTag> inline void read_and_convert_view( Device& device, View const& view, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, settings, read_and_convert_t{}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename View, typename FormatTag> inline void read_and_convert_view( String const& file_name, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, tag, read_and_convert_t{}); read_and_convert_view(reader, view); } /// \brief Reads and color-converts an image view. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param view The image view in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename View, typename FormatTag> inline void read_and_convert_view( Device& device, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, tag, read_and_convert_t{}); read_and_convert_view(reader, view); } }} // namespace boost::gill #endif PK��p�[k6]� �� io/base.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_BASE_HPP #define BOOST_GIL_IO_BASE_HPP #include <boost/gil/extension/toolbox/toolbox.hpp> #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <boost/gil/bit_aligned_pixel_iterator.hpp> #include <boost/gil/color_convert.hpp> #include <boost/gil/utilities.hpp> #include <boost/gil/io/error.hpp> #include <boost/gil/io/typedefs.hpp> #include <istream> #include <ostream> #include <type_traits> #include <vector> namespace boost { namespace gil { struct format_tag {}; template< typename Property > struct property_base { using type = Property; }; template<typename FormatTag> struct is_format_tag : std::is_base_of<format_tag, FormatTag> {}; struct image_read_settings_base { protected: image_read_settings_base() : _top_left( 0, 0 ) , _dim ( 0, 0 ) {} image_read_settings_base( const point_t& top_left , const point_t& dim ) : _top_left( top_left ) , _dim ( dim ) {} public: void set( const point_t& top_left , const point_t& dim ) { _top_left = top_left; _dim = dim; } public: point_t _top_left; point_t _dim; }; /** * Boolean meta function, std::true_type if the pixel type \a PixelType is supported * by the image format identified with \a FormatTag. * \todo the name is_supported is to generic, pick something more IO realted. / // Depending on image type the parameter Pixel can be a reference type // for bit_aligned images or a pixel for byte images. template< typename Pixel, typename FormatTag > struct is_read_supported {}; template< typename Pixel, typename FormatTag > struct is_write_supported {}; namespace detail { template< typename Property > struct property_base { using type = Property; }; } // namespace detail struct read_support_true { static constexpr bool is_supported = true; }; struct read_support_false { static constexpr bool is_supported = false; }; struct write_support_true { static constexpr bool is_supported = true; }; struct write_support_false{ static constexpr bool is_supported = false; }; class no_log {}; template< typename Device, typename FormatTag > struct reader_backend; template< typename Device, typename FormatTag > struct writer_backend; template< typename FormatTag > struct image_read_info; template< typename FormatTag > struct image_read_settings; template< typename FormatTag, typename Log = no_log > struct image_write_info; } // namespace gil } // namespace boost #endif PK��p�[Nk�\��\��io/get_reader.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_GET_READER_HPP #define BOOST_GIL_IO_GET_READER_HPP #include <boost/gil/io/get_read_device.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost { namespace gil { /// \brief Helper metafunction to generate image reader type. template < typename T, typename FormatTag, typename ConversionPolicy, class Enable = void > struct get_reader {}; template <typename String, typename FormatTag, typename ConversionPolicy> struct get_reader < String, FormatTag, ConversionPolicy, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<String, FormatTag>::type; using type = reader<device_t, FormatTag, ConversionPolicy>; }; template <typename Device, typename FormatTag, typename ConversionPolicy> struct get_reader < Device, FormatTag, ConversionPolicy, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<Device, FormatTag>::type; using type = reader<device_t, FormatTag, ConversionPolicy>; }; /// \brief Helper metafunction to generate dynamic image reader type. template <typename T, typename FormatTag, class Enable = void> struct get_dynamic_image_reader { }; template <typename String, typename FormatTag> struct get_dynamic_image_reader < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<String, FormatTag>::type; using type = dynamic_image_reader<device_t, FormatTag>; }; template <typename Device, typename FormatTag> struct get_dynamic_image_reader < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<Device, FormatTag>::type; using type = dynamic_image_reader<device_t, FormatTag>; }; /// \brief Helper metafunction to generate image backend type. template <typename T, typename FormatTag, class Enable = void> struct get_reader_backend { }; template <typename String, typename FormatTag> struct get_reader_backend < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<String, FormatTag>::type; using type = reader_backend<device_t, FormatTag>; }; template <typename Device, typename FormatTag> struct get_reader_backend < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_read_device<Device, FormatTag>::type; using type = reader_backend<device_t, FormatTag>; }; /// \brief Helper metafunction to generate image scanline_reader type. template <typename T, typename FormatTag> struct get_scanline_reader { using device_t = typename get_read_device<T, FormatTag>::type; using type = scanline_reader<device_t, FormatTag>; }; } // namespace gil } // namespace boost #endif PK��p�[��io/typedefs.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_IO_TYPEDEFS_HPP #define BOOST_GIL_IO_TYPEDEFS_HPP #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA #include <boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp> #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA #include <boost/gil/image.hpp> #include <boost/gil/point.hpp> #include <boost/gil/utilities.hpp> #include <type_traits> #include <vector> namespace boost { namespace gil { struct double_zero { static double apply() { return 0.0; } }; struct double_one { static double apply() { return 1.0; } }; using byte_t = unsigned char; using byte_vector_t = std::vector<byte_t>; }} // namespace boost::gil namespace boost { template<> struct is_floating_point<gil::float32_t> : std::true_type {}; template<> struct is_floating_point<gil::float64_t> : std::true_type {}; } // namespace boost namespace boost { namespace gil { ///@todo We should use boost::preprocessor here. /// TODO: NO! Please do not use preprocessor here! --mloskot using gray1_image_t = bit_aligned_image1_type<1, gray_layout_t>::type; using gray2_image_t = bit_aligned_image1_type<2, gray_layout_t>::type; using gray4_image_t = bit_aligned_image1_type<4, gray_layout_t>::type; using gray6_image_t = bit_aligned_image1_type<6, gray_layout_t>::type; using gray10_image_t = bit_aligned_image1_type<10, gray_layout_t>::type; using gray12_image_t = bit_aligned_image1_type<12, gray_layout_t>::type; using gray14_image_t = bit_aligned_image1_type<14, gray_layout_t>::type; using gray24_image_t = bit_aligned_image1_type<24, gray_layout_t>::type; using gray64f_pixel_t = pixel<double, gray_layout_t>; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA using gray_alpha8_pixel_t = pixel<uint8_t, gray_alpha_layout_t>; using gray_alpha16_pixel_t = pixel<uint16_t, gray_alpha_layout_t>; using gray_alpha64f_pixel_t = pixel<double, gray_alpha_layout_t>; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA using rgb64f_pixel_t = pixel<double, rgb_layout_t>; using rgba64f_pixel_t = pixel<double, rgba_layout_t>; using gray64f_image_t = image<gray64f_pixel_t, false>; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA using gray_alpha8_image_t = image<gray_alpha8_pixel_t, false>; using gray_alpha16_image_t = image<gray_alpha16_pixel_t, false>; using gray_alpha32f_image_t = image<gray_alpha32f_pixel_t, false>; using gray_alpha32f_planar_image_t = image<gray_alpha32f_pixel_t, true>; using gray_alpha64f_image_t = image<gray_alpha64f_pixel_t, false>; using gray_alpha64f_planar_image_t = image<gray_alpha64f_pixel_t, true>; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA using rgb64f_image_t = image<rgb64f_pixel_t, false>; using rgb64f_planar_image_t = image<rgb64f_pixel_t, true>; using rgba64f_image_t = image<rgba64f_pixel_t, false>; using rgba64f_planar_image_t = image<rgba64f_pixel_t, true>; }} // namespace boost::gil #endif PK��p�[��M��io/read_image_info.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_READ_IMAGE_INFO_HPP #define BOOST_GIL_IO_READ_IMAGE_INFO_HPP #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// \ingroup IO /// \brief Returns the image format backend. Backend is format specific. /// \param file It's a device. Must satisfy is_adaptable_input_device metafunction. /// \param settings Specifies read settings depending on the image format. /// \return image_read_info object dependent on the image format. /// \throw std::ios_base::failure template <typename Device, typename FormatTag> inline auto read_image_info(Device& file, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type /dummy/ = nullptr) -> typename get_reader_backend<Device, FormatTag>::type { return make_reader_backend(file, settings); } /// \brief Returns the image format backend. Backend is format specific. /// \param file It's a device. Must satisfy is_adaptable_input_device metafunction. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \return image_read_info object dependent on the image format. /// \throw std::ios_base::failure template <typename Device, typename FormatTag> inline auto read_image_info(Device& file, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<Device, FormatTag>::type { return read_image_info(file, image_read_settings<FormatTag>()); } /// \brief Returns the image format backend. Backend is format specific. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param settings Specifies read settings depending on the image format. /// \return image_read_info object dependent on the image format. /// \throw std::ios_base::failure template <typename String, typename FormatTag> inline auto read_image_info( String const& file_name, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<String, FormatTag>::type { return make_reader_backend(file_name, settings); } /// \brief Returns the image format backend. Backend is format specific. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \return image_read_info object dependent on the image format. /// \throw std::ios_base::failure template <typename String, typename FormatTag> inline auto read_image_info(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<String, FormatTag>::type { return read_image_info(file_name, image_read_settings<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[kC4��io/make_backend.hppnu��[��// // // Copyright 2012 Christian Henning // // 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_IO_MAKE_BACKEND_HPP #define BOOST_GIL_IO_MAKE_BACKEND_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_reader.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag> inline auto make_reader_backend( String const& file_name, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<String, FormatTag>::type { using device_t = typename get_read_device<String, FormatTag>::type; device_t device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::read_tag()); return reader_backend<device_t, FormatTag>(device, settings); } template <typename FormatTag> inline auto make_reader_backend( std::wstring const& file_name, image_read_settings<FormatTag> const& settings) -> typename get_reader_backend<std::wstring, FormatTag>::type { char const* str = detail::convert_to_native_string(file_name); using device_t = typename get_read_device<std::wstring, FormatTag>::type; device_t device(str, typename detail::file_stream_device<FormatTag>::read_tag()); delete[] str; // TODO: RAII return reader_backend<device_t, FormatTag>(device, settings); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename FormatTag> inline auto make_reader_backend( filesystem::path const& path, image_read_settings<FormatTag> const& settings) -> typename get_reader_backend<std::wstring, FormatTag>::type { return make_reader_backend(path.wstring(), settings); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_reader_backend(Device& io_dev, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<Device, FormatTag>::type { using device_t = typename get_read_device<Device, FormatTag>::type; device_t device(io_dev); return reader_backend<device_t, FormatTag>(device, settings); } template <typename String, typename FormatTag> inline auto make_reader_backend(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<String, FormatTag>::type { return make_reader_backend(file_name, image_read_settings<FormatTag>()); } template <typename Device, typename FormatTag> inline auto make_reader_backend(Device& io_dev, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader_backend<Device, FormatTag>::type { return make_reader_backend(io_dev, image_read_settings<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[�HQ1A��1A�� io/device.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny // // 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_IO_DEVICE_HPP #define BOOST_GIL_IO_DEVICE_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/base.hpp> #include <cstdio> #include <memory> #include <type_traits> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { template < typename T > struct buff_item { static const unsigned int size = sizeof( T ); }; template <> struct buff_item< void > { static const unsigned int size = 1; }; /! Implements the IODevice concept c.f. to \ref IODevice required by Image libraries like * libjpeg and libpng. * * \todo switch to a sane interface as soon as there is * something good in boost. I.E. the IOChains library * would fit very well here. * * This implementation is based on FILE. / template< typename FormatTag > class file_stream_device { public: using format_tag_t = FormatTag; public: /// Used to overload the constructor. struct read_tag {}; struct write_tag {}; /// /// Constructor /// file_stream_device( const std::string& file_name , read_tag tag = read_tag() ) : file_stream_device(file_name.c_str(), tag) {} /// /// Constructor /// file_stream_device( const char* file_name , read_tag = read_tag() ) { FILE* file = nullptr; io_error_if( ( file = fopen( file_name, "rb" )) == nullptr , "file_stream_device: failed to open file for reading" ); _file = file_ptr_t( file , file_deleter ); } /// /// Constructor /// file_stream_device( const std::string& file_name , write_tag tag ) : file_stream_device(file_name.c_str(), tag) {} /// /// Constructor /// file_stream_device( const char* file_name , write_tag ) { FILE* file = nullptr; io_error_if( ( file = fopen( file_name, "wb" )) == nullptr , "file_stream_device: failed to open file for writing" ); _file = file_ptr_t( file , file_deleter ); } /// /// Constructor /// file_stream_device( FILE* file ) : _file( file , file_deleter ) {} FILE* get() { return _file.get(); } const FILE* get() const { return _file.get(); } int getc_unchecked() { return std::getc( get() ); } char getc() { int ch; io_error_if( ( ch = std::getc( get() )) == EOF , "file_stream_device: unexpected EOF" ); return ( char ) ch; } ///@todo: change byte_t* to void* std::size_t read( byte_t* data , std::size_t count ) { std::size_t num_elements = fread( data , 1 , static_cast<int>( count ) , get() ); ///@todo: add compiler symbol to turn error checking on and off. io_error_if( ferror( get() ) , "file_stream_device: file read error" ); //libjpeg sometimes reads blocks in 4096 bytes even when the file is smaller than that. //return value indicates how much was actually read //returning less than "count" is not an error return num_elements; } /// Reads array template< typename T , int N > void read( T (&buf)[N] ) { io_error_if( read( buf, N ) < N , "file_stream_device: file read error" ); } /// Reads byte uint8_t read_uint8() { byte_t m[1]; read( m ); return m[0]; } /// Reads 16 bit little endian integer uint16_t read_uint16() { byte_t m[2]; read( m ); return (m[1] << 8) \| m[0]; } /// Reads 32 bit little endian integer uint32_t read_uint32() { byte_t m[4]; read( m ); return (m[3] << 24) \| (m[2] << 16) \| (m[1] << 8) \| m[0]; } /// Writes number of elements from a buffer template < typename T > std::size_t write( const T* buf , std::size_t count ) { std::size_t num_elements = fwrite( buf , buff_item<T>::size , count , get() ); //return value indicates how much was actually written //returning less than "count" is not an error return num_elements; } /// Writes array template < typename T , std::size_t N > void write( const T (&buf)[N] ) { io_error_if( write( buf, N ) < N , "file_stream_device: file write error" ); return ; } /// Writes byte void write_uint8( uint8_t x ) { byte_t m[1] = { x }; write(m); } /// Writes 16 bit little endian integer void write_uint16( uint16_t x ) { byte_t m[2]; m[0] = byte_t( x >> 0 ); m[1] = byte_t( x >> 8 ); write( m ); } /// Writes 32 bit little endian integer void write_uint32( uint32_t x ) { byte_t m[4]; m[0] = byte_t( x >> 0 ); m[1] = byte_t( x >> 8 ); m[2] = byte_t( x >> 16 ); m[3] = byte_t( x >> 24 ); write( m ); } void seek( long count, int whence = SEEK_SET ) { io_error_if( fseek( get() , count , whence ) != 0 , "file_stream_device: file seek error" ); } long int tell() { long int pos = ftell( get() ); io_error_if( pos == -1L , "file_stream_device: file position error" ); return pos; } void flush() { fflush( get() ); } /// Prints formatted ASCII text void print_line( const std::string& line ) { std::size_t num_elements = fwrite( line.c_str() , sizeof( char ) , line.size() , get() ); io_error_if( num_elements < line.size() , "file_stream_device: line print error" ); } int error() { return ferror( get() ); } private: static void file_deleter( FILE* file ) { if( file ) { fclose( file ); } } private: using file_ptr_t = std::shared_ptr<FILE> ; file_ptr_t _file; }; /** * Input stream device / template< typename FormatTag > class istream_device { public: istream_device( std::istream& in ) : _in( in ) { // does the file exists? io_error_if( !in , "istream_device: Stream is not valid." ); } int getc_unchecked() { return _in.get(); } char getc() { int ch; io_error_if( ( ch = _in.get() ) == EOF , "istream_device: unexpected EOF" ); return ( char ) ch; } std::size_t read( byte_t data , std::size_t count ) { std::streamsize cr = 0; do { _in.peek(); std::streamsize c = _in.readsome( reinterpret_cast< char* >( data ) , static_cast< std::streamsize >( count )); count -= static_cast< std::size_t >( c ); data += c; cr += c; } while( count && _in ); return static_cast< std::size_t >( cr ); } /// Reads array template<typename T, int N> void read(T (&buf)[N]) { read(buf, N); } /// Reads byte uint8_t read_uint8() { byte_t m[1]; read( m ); return m[0]; } /// Reads 16 bit little endian integer uint16_t read_uint16() { byte_t m[2]; read( m ); return (m[1] << 8) \| m[0]; } /// Reads 32 bit little endian integer uint32_t read_uint32() { byte_t m[4]; read( m ); return (m[3] << 24) \| (m[2] << 16) \| (m[1] << 8) \| m[0]; } void seek( long count, int whence = SEEK_SET ) { _in.seekg( count , whence == SEEK_SET ? std::ios::beg :( whence == SEEK_CUR ? std::ios::cur : std::ios::end ) ); } void write(const byte_t, std::size_t) { io_error( "istream_device: Bad io error." ); } void flush() {} private: std::istream& _in; }; /* * Output stream device / template< typename FormatTag > class ostream_device { public: ostream_device( std::ostream & out ) : _out( out ) { } std::size_t read(byte_t , std::size_t) { io_error( "ostream_device: Bad io error." ); return 0; } void seek( long count, int whence ) { _out.seekp( count , whence == SEEK_SET ? std::ios::beg : ( whence == SEEK_CUR ?std::ios::cur :std::ios::end ) ); } void write( const byte_t* data , std::size_t count ) { _out.write( reinterpret_cast<char const>( data ) , static_cast<std::streamsize>( count ) ); } /// Writes array template < typename T , std::size_t N > void write( const T (&buf)[N] ) { write( buf, N ); } /// Writes byte void write_uint8( uint8_t x ) { byte_t m[1] = { x }; write(m); } /// Writes 16 bit little endian integer void write_uint16( uint16_t x ) { byte_t m[2]; m[0] = byte_t( x >> 0 ); m[1] = byte_t( x >> 8 ); write( m ); } /// Writes 32 bit little endian integer void write_uint32( uint32_t x ) { byte_t m[4]; m[0] = byte_t( x >> 0 ); m[1] = byte_t( x >> 8 ); m[2] = byte_t( x >> 16 ); m[3] = byte_t( x >> 24 ); write( m ); } void flush() { _out << std::flush; } /// Prints formatted ASCII text void print_line( const std::string& line ) { _out << line; } private: std::ostream& _out; }; /* * Metafunction to detect input devices. * Should be replaced by an external facility in the future. / template< typename IODevice > struct is_input_device : std::false_type{}; template< typename FormatTag > struct is_input_device< file_stream_device< FormatTag > > : std::true_type{}; template< typename FormatTag > struct is_input_device< istream_device< FormatTag > > : std::true_type{}; template< typename FormatTag , typename T , typename D = void > struct is_adaptable_input_device : std::false_type{}; template <typename FormatTag, typename T> struct is_adaptable_input_device < FormatTag, T, typename std::enable_if < mp11::mp_or < std::is_base_of<std::istream, T>, std::is_same<std::istream, T> >::value >::type > : std::true_type { using device_type = istream_device<FormatTag>; }; template< typename FormatTag > struct is_adaptable_input_device< FormatTag , FILE , void > : std::true_type { using device_type = file_stream_device<FormatTag>; }; /// /// Metafunction to decide if a given type is an acceptable read device type. /// template< typename FormatTag , typename T , typename D = void > struct is_read_device : std::false_type {}; template <typename FormatTag, typename T> struct is_read_device < FormatTag, T, typename std::enable_if < mp11::mp_or < is_input_device<FormatTag>, is_adaptable_input_device<FormatTag, T> >::value >::type > : std::true_type { }; /** * Metafunction to detect output devices. * Should be replaced by an external facility in the future. / template<typename IODevice> struct is_output_device : std::false_type{}; template< typename FormatTag > struct is_output_device< file_stream_device< FormatTag > > : std::true_type{}; template< typename FormatTag > struct is_output_device< ostream_device < FormatTag > > : std::true_type{}; template< typename FormatTag , typename IODevice , typename D = void > struct is_adaptable_output_device : std::false_type {}; template <typename FormatTag, typename T> struct is_adaptable_output_device < FormatTag, T, typename std::enable_if < mp11::mp_or < std::is_base_of<std::ostream, T>, std::is_same<std::ostream, T> >::value >::type > : std::true_type { using device_type = ostream_device<FormatTag>; }; template<typename FormatTag> struct is_adaptable_output_device<FormatTag,FILE,void> : std::true_type { using device_type = file_stream_device<FormatTag>; }; /// /// Metafunction to decide if a given type is an acceptable read device type. /// template< typename FormatTag , typename T , typename D = void > struct is_write_device : std::false_type {}; template <typename FormatTag, typename T> struct is_write_device < FormatTag, T, typename std::enable_if < mp11::mp_or < is_output_device<FormatTag>, is_adaptable_output_device<FormatTag, T> >::value >::type > : std::true_type { }; } // namespace detail template< typename Device, typename FormatTag > class scanline_reader; template< typename Device, typename FormatTag, typename ConversionPolicy > class reader; template< typename Device, typename FormatTag, typename Log = no_log > class writer; template< typename Device, typename FormatTag > class dynamic_image_reader; template< typename Device, typename FormatTag, typename Log = no_log > class dynamic_image_writer; namespace detail { template< typename T > struct is_reader : std::false_type {}; template< typename Device , typename FormatTag , typename ConversionPolicy > struct is_reader< reader< Device , FormatTag , ConversionPolicy > > : std::true_type {}; template< typename T > struct is_dynamic_image_reader : std::false_type {}; template< typename Device , typename FormatTag > struct is_dynamic_image_reader< dynamic_image_reader< Device , FormatTag > > : std::true_type {}; template< typename T > struct is_writer : std::false_type {}; template< typename Device , typename FormatTag > struct is_writer< writer< Device , FormatTag > > : std::true_type {}; template< typename T > struct is_dynamic_image_writer : std::false_type {}; template< typename Device , typename FormatTag > struct is_dynamic_image_writer< dynamic_image_writer< Device , FormatTag > > : std::true_type {}; } // namespace detail #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[�n�� io/get_writer.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_GET_WRITER_HPP #define BOOST_GIL_IO_GET_WRITER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_write_device.hpp> #include <type_traits> namespace boost { namespace gil { /// \brief Helper metafunction to generate writer type. template <typename T, typename FormatTag, class Enable = void> struct get_writer {}; template <typename String, typename FormatTag> struct get_writer < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_write_device<String, FormatTag>::type; using type = writer<device_t, FormatTag>; }; template <typename Device, typename FormatTag> struct get_writer < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_adaptable_output_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_write_device<Device, FormatTag>::type; using type = writer<device_t, FormatTag>; }; /// \brief Helper metafunction to generate dynamic image writer type. template <typename T, typename FormatTag, class Enable = void> struct get_dynamic_image_writer {}; template <typename String, typename FormatTag> struct get_dynamic_image_writer < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_write_device<String, FormatTag>::type; using type = dynamic_image_writer<device_t, FormatTag>; }; template <typename Device, typename FormatTag> struct get_dynamic_image_writer < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_write_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using device_t = typename get_write_device<Device, FormatTag>::type; using type = dynamic_image_writer<device_t, FormatTag>; }; }} // namespace boost::gil #endif PK��p�[�9�� io/make_dynamic_image_writer.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_MAKE_DYNAMIC_IMAGE_WRITER_HPP #define BOOST_GIL_IO_MAKE_DYNAMIC_IMAGE_WRITER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_writer.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag> inline auto make_dynamic_image_writer( String const& file_name, image_write_info<FormatTag> const& info, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_writer<String, FormatTag>::type { using deveice_t = typename get_write_device<String, FormatTag>::type; deveice_t device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::write_tag()); return typename get_dynamic_image_writer<String, FormatTag>::type(device, info); } template< typename FormatTag > inline typename get_dynamic_image_writer< std::wstring , FormatTag >::type make_dynamic_image_writer( const std::wstring& file_name , const image_write_info< FormatTag >& info ) { const char* str = detail::convert_to_native_string( file_name ); typename get_write_device< std::wstring , FormatTag >::type device( str , typename detail::file_stream_device< FormatTag >::write_tag() ); delete[] str; // TODO: RAII return typename get_dynamic_image_writer< std::wstring , FormatTag >::type( device , info ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag > inline typename get_dynamic_image_writer< std::wstring , FormatTag >::type make_dynamic_image_writer( const filesystem::path& path , const image_write_info< FormatTag >& info ) { return make_dynamic_image_writer( path.wstring() , info ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_dynamic_image_writer(Device& file, image_write_info<FormatTag> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_adaptable_output_device<FormatTag, Device>::type, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_writer<Device, FormatTag>::type { typename get_write_device<Device, FormatTag>::type device(file); return typename get_dynamic_image_writer<Device, FormatTag>::type(device, info); } // no image_write_info template <typename String, typename FormatTag> inline auto make_dynamic_image_writer(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_writer<String, FormatTag>::type { return make_dynamic_image_writer(file_name, image_write_info<FormatTag>()); } template< typename FormatTag > inline typename get_dynamic_image_writer< std::wstring , FormatTag >::type make_dynamic_image_writer( const std::wstring& file_name , const FormatTag& ) { return make_dynamic_image_writer( file_name , image_write_info< FormatTag >() ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag > inline typename get_dynamic_image_writer< std::wstring , FormatTag >::type make_dynamic_image_writer( const filesystem::path& path , const FormatTag& ) { return make_dynamic_image_writer( path.wstring() , image_write_info< FormatTag >() ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_dynamic_image_writer(Device& file, FormatTag const&, typename std::enable_if < mp11::mp_and < typename detail::is_adaptable_output_device<FormatTag, Device>::type, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_writer<Device, FormatTag>::type { return make_dynamic_image_writer(file, image_write_info<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[F�Pa��io/dynamic_io_new.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_IO_DYNAMIC_IO_NEW_HPP #define BOOST_GIL_IO_DYNAMIC_IO_NEW_HPP #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/error.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template <long N> struct construct_matched_t { template <typename ...Images,typename Pred> static bool apply(any_image<Images...>& img, Pred pred) { if (pred.template apply<mp11::mp_at_c<any_image<Images...>, N-1>>()) { using image_t = mp11::mp_at_c<any_image<Images...>, N-1>; image_t x; img = std::move(x); return true; } else return construct_matched_t<N-1>::apply(img, pred); } }; template <> struct construct_matched_t<0> { template <typename ...Images,typename Pred> static bool apply(any_image<Images...>&,Pred) { return false; } }; // A function object that can be passed to apply_operation. // Given a predicate IsSupported taking a view type and returning an boolean integral coonstant, // calls the apply method of OpClass with the view if the given view IsSupported, or throws an exception otherwise template <typename IsSupported, typename OpClass> class dynamic_io_fnobj { private: OpClass* _op; template <typename View> void apply(View const& view, std::true_type) { _op->apply(view); } template <typename View, typename Info> void apply(View const& view, Info const & info, const std::true_type) { _op->apply(view, info); } template <typename View> void apply(View const& /* view /, std::false_type) { io_error("dynamic_io: unsupported view type for the given file format"); } template <typename View, typename Info > void apply(View const& / view /, Info const& / info /, const std::false_type) { io_error("dynamic_io: unsupported view type for the given file format"); } public: dynamic_io_fnobj(OpClass op) : _op(op) {} using result_type = void; template <typename View> void operator()(View const& view) { apply(view, typename IsSupported::template apply<View>::type()); } template< typename View, typename Info > void operator()(View const& view, Info const& info) { apply(view, info, typename IsSupported::template apply<View>::type()); } }; } // namespace detail /// \brief Within the any_image, constructs an image with the given dimensions /// and a type that satisfies the given predicate template <typename ...Images,typename Pred> inline bool construct_matched(any_image<Images...>& img, Pred pred) { constexpr auto size = mp11::mp_size<any_image<Images...>>::value; return detail::construct_matched_t<size>::apply(img, pred); } } } // namespace boost::gil #endif PK��p�[ g�j'��j'��io/read_image.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_READ_IMAGE_HPP #define BOOST_GIL_IO_READ_IMAGE_HPP #include <boost/gil/extension/toolbox/dynamic_images.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost { namespace gil { /// \ingroup IO /// \brief Reads an image without conversion. Image memory is allocated. /// \param reader An image reader. /// \param img The image in which the data is read into. Must satisfy is_read_supported metafunction. /// \throw std::ios_base::failure template <typename Reader, typename Image> inline void read_image(Reader reader, Image& img, typename std::enable_if < mp11::mp_and < detail::is_reader<Reader>, is_format_tag<typename Reader::format_tag_t>, is_read_supported < typename get_pixel_type<typename Image::view_t>::type, typename Reader::format_tag_t > >::value >::type* /dummy/ = nullptr) { reader.init_image(img, reader._settings); reader.apply(view(img)); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction. /// \param img The image in which the data is read into. Must satisfy is_read_supported metafunction. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Device, typename Image, typename FormatTag> inline void read_image( Device& file, Image& img, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag>, is_read_supported < typename get_pixel_type<typename Image::view_t>::type, FormatTag > >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<Device, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file, settings, detail::read_and_no_convert()); read_image(reader, img); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction. /// \param img The image in which the data is read into. Must satisfy is_read_supported metafunction. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename Image, typename FormatTag> inline void read_image(Device& file, Image& img, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag>, is_read_supported < typename get_pixel_type<typename Image::view_t>::type, FormatTag > >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<Device, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file, tag, detail::read_and_no_convert()); read_image(reader, img); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. Must satisfy is_read_supported metafunction. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename String, typename Image, typename FormatTag> inline void read_image( String const& file_name, Image& img, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag>, is_read_supported < typename get_pixel_type<typename Image::view_t>::type, FormatTag > >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<String, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file_name, settings, detail::read_and_no_convert()); read_image(reader, img); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. Must satisfy is_read_supported metafunction. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename Image, typename FormatTag> inline void read_image(String const& file_name, Image& img, FormatTag const& tag, typename std::enable_if < mp11::mp_and<detail::is_supported_path_spec<String>, is_format_tag<FormatTag>, is_read_supported < typename get_pixel_type<typename Image::view_t>::type, FormatTag > >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<String, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file_name, tag, detail::read_and_no_convert()); read_image(reader, img); } /// template <typename Reader, typename ...Images> inline void read_image(Reader& reader, any_image<Images...>& images, typename std::enable_if < mp11::mp_and < detail::is_dynamic_image_reader<Reader>, is_format_tag<typename Reader::format_tag_t> >::value >::type* /dummy/ = nullptr) { reader.apply(images); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file It's a device. Must satisfy is_adaptable_input_device metafunction. /// \param images Dynamic image (mp11::mp_list). See boost::gil::dynamic_image extension. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Device, typename ...Images, typename FormatTag> inline void read_image( Device& file, any_image<Images...>& images, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_dynamic_image_reader<Device, FormatTag>::type; reader_t reader = make_dynamic_image_reader(file, settings); read_image(reader, images); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file It's a device. Must satisfy is_adaptable_input_device metafunction. /// \param images Dynamic image (mp11::mp_list). See boost::gil::dynamic_image extension. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename ...Images, typename FormatTag> inline void read_image(Device& file, any_image<Images...>& images, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_dynamic_image_reader<Device, FormatTag>::type; reader_t reader = make_dynamic_image_reader(file, tag); read_image(reader, images); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param images Dynamic image (mp11::mp_list). See boost::gil::dynamic_image extension. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename String, typename ...Images, typename FormatTag> inline void read_image( String const& file_name, any_image<Images...>& images, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_dynamic_image_reader<String, FormatTag>::type; reader_t reader = make_dynamic_image_reader(file_name, settings); read_image(reader, images); } /// \brief Reads an image without conversion. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param images Dynamic image (mp11::mp_list). See boost::gil::dynamic_image extension. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename ...Images, typename FormatTag> inline void read_image(String const& file_name, any_image<Images...>& images, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_dynamic_image_reader<String, FormatTag>::type; reader_t reader = make_dynamic_image_reader(file_name, tag); read_image(reader, images); } }} // namespace boost::gil #endif PK��p�[4�=�C��C��io/error.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_ERROR_HPP #define BOOST_GIL_IO_ERROR_HPP #include <ios> namespace boost { namespace gil { inline void io_error(const char* descr) { throw std::ios_base::failure(descr); } inline void io_error_if(bool expr, const char* descr) { if (expr) io_error(descr); } } // namespace gil } // namespace boost #endif PK��p�[��7$��$��io/make_scanline_reader.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_MAKE_SCANLINE_READER_HPP #define BOOST_GIL_IO_MAKE_SCANLINE_READER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_reader.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag> inline auto make_scanline_reader(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_scanline_reader<String, FormatTag>::type { using device_t = typename get_read_device<String, FormatTag>::type; device_t device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::read_tag()); return typename get_scanline_reader<String, FormatTag>::type( device, image_read_settings<FormatTag>()); } template< typename FormatTag > inline typename get_scanline_reader< std::wstring , FormatTag >::type make_scanline_reader( const std::wstring& file_name , FormatTag const& ) { const char* str = detail::convert_to_native_string( file_name ); typename get_read_device< std::wstring , FormatTag >::type device( str , typename detail::file_stream_device< FormatTag >::read_tag() ); delete[] str; return typename get_scanline_reader< std::wstring , FormatTag >::type( device , image_read_settings< FormatTag >() ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag > inline typename get_scanline_reader< std::wstring , FormatTag >::type make_scanline_reader( const filesystem::path& path , FormatTag const& ) { return make_scanline_reader( path.wstring() , image_read_settings< FormatTag >() ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_scanline_reader(Device& io_dev, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_scanline_reader<Device, FormatTag>::type { return make_scanline_reader(io_dev, image_read_settings<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[��i��i��io/read_view.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_READ_VIEW_HPP #define BOOST_GIL_IO_READ_VIEW_HPP #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost { namespace gil { /// \ingroup IO /// \brief Reads an image view without conversion. No memory is allocated. /// \param reader An image reader. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Reader, typename View> inline void read_view(Reader reader, View const& view, typename std::enable_if < mp11::mp_and < detail::is_reader<Reader>, typename is_format_tag<typename Reader::format_tag_t>::type, typename is_read_supported < typename get_pixel_type<View>::type, typename Reader::format_tag_t >::type >::value >::type* /dummy/ = nullptr) { reader.check_image_size(view.dimensions()); reader.init_view(view, reader._settings); reader.apply(view); } /// \brief Reads an image view without conversion. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Device, typename View, typename FormatTag> inline void read_view( Device& file, View const& view, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, typename is_format_tag<FormatTag>::type, typename is_read_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<Device, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file, settings, detail::read_and_no_convert()); read_view(reader, view); } /// \brief Reads an image view without conversion. No memory is allocated. /// \param file It's a device. Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param view The image view in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename View, typename FormatTag> inline void read_view(Device& file, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename is_format_tag<FormatTag>::type, detail::is_read_device<FormatTag, Device>, typename is_read_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value>::type* /dummy/ = nullptr) { using reader_t = typename get_reader<Device, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file, tag, detail::read_and_no_convert()); read_view(reader, view); } /// \brief Reads an image view without conversion. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename String, typename View, typename FormatTag> inline void read_view( String const& file_name, View const& view, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type, typename is_read_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<String, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file_name, settings, detail::read_and_no_convert()); read_view(reader, view); } /// \brief Reads an image view without conversion. No memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param view The image view in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename View, typename FormatTag> inline void read_view(String const& file_name, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type, typename is_read_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type* /dummy/ = nullptr) { using reader_t = typename get_reader<String, FormatTag, detail::read_and_no_convert>::type; reader_t reader = make_reader(file_name, tag, detail::read_and_no_convert()); read_view(reader, view); } }} // namespace boost::gil #endif PK��p�[�� io/reader_base.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_IO_READER_BASE_HPP #define BOOST_GIL_IO_READER_BASE_HPP #include <boost/gil/io/base.hpp> #include <boost/assert.hpp> namespace boost { namespace gil { /// Reader Base Class /// /// It provides some basic functionality which is shared for all readers. /// For instance, it recreates images when necessary. It checks whether /// user supplied coordinates are valid. /// /// @tparam FormatTag A format tag, like jpeg_tag. /// @tparam ConversionPolicy Conversion policy, see coversion_policies.hpp. template< typename FormatTag , typename ConversionPolicy > struct reader_base { public: /// /// Default Constructor /// reader_base() :_cc_policy() {} /// /// Constructor /// reader_base( const ConversionPolicy& cc ) :_cc_policy( cc ) {} /// Initializes an image. But also does some check ups. /// /// @tparam Image Image which implements boost::gil's ImageConcept. /// /// @param img The image. /// @param info The image read info. template< typename Image > void init_image( Image& img , const image_read_settings< FormatTag >& settings ) { //setup( backend._settings._dim ); BOOST_ASSERT(settings._dim.x && settings._dim.y); img.recreate( settings._dim.x , settings._dim.y ); } template< typename View > void init_view( const View& view , const image_read_settings< FormatTag >& ) { setup( view.dimensions() ); } private: void setup( const point_t& /* dim / ) { //check_coordinates( dim ); //if( dim == point_t( 0, 0 )) //{ // _settings._dim.x = _info._width; // _settings._dim.y = _info._height; //} //else //{ // _settings._dim = dim; //} } void check_coordinates( const point_t& / dim / ) { //using int_t = point_t::value_type; //int_t width = static_cast< int_t >( _info._width ); //int_t height = static_cast< int_t >( _info._height ); //io_error_if( ( _settings._top_left.x < 0 // \|\| _settings._top_left.y < 0 // \|\| dim.x < 0 // \|\| dim.y < 0 // ) // , "User provided view has incorrect size." ); //io_error_if( ( ( width ) < _settings._top_left.x // && ( width ) <= dim.x // && ( height ) < _settings._top_left.y // && ( height ) <= dim.y ) // , "User provided view has incorrect size." ); //io_error_if( ( ( _settings._top_left.x + dim.x ) > width // \|\| ( _settings._top_left.y + dim.y ) > height // ) // , "User provided view has incorrect size." ); } protected: ConversionPolicy _cc_policy; }; } // namespace gil } // namespace boost #endif PK��p�[Y��T��T�� io/make_dynamic_image_reader.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_MAKE_DYNAMIC_IMAGE_READER_HPP #define BOOST_GIL_IO_MAKE_DYNAMIC_IMAGE_READER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_reader.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag> inline auto make_dynamic_image_reader( String const& file_name, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type /dummy/ = nullptr) -> typename get_dynamic_image_reader<String, FormatTag>::type { using device_t = typename get_read_device<String, FormatTag>::type; device_t device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::read_tag()); return typename get_dynamic_image_reader<String, FormatTag>::type(device, settings); } template <typename FormatTag> inline auto make_dynamic_image_reader( std::wstring const& file_name, image_read_settings<FormatTag> const& settings) -> typename get_dynamic_image_reader<std::wstring, FormatTag>::type { char const* str = detail::convert_to_native_string(file_name); using device_t = typename get_read_device<std::wstring, FormatTag>::type; device_t device(str, typename detail::file_stream_device<FormatTag>::read_tag()); delete[] str; // TODO: RAII return typename get_dynamic_image_reader<std::wstring, FormatTag>::type(device, settings); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename FormatTag> inline auto make_dynamic_image_reader( filesystem::path const& path, image_read_settings<FormatTag> const& settings) -> typename get_dynamic_image_reader<std::wstring, FormatTag>::type { return make_dynamic_image_reader(path.wstring(), settings); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_dynamic_image_reader( Device& file, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_reader<Device, FormatTag>::type { typename get_read_device<Device, FormatTag>::type device(file); return typename get_dynamic_image_reader<Device, FormatTag>::type(device, settings); } // without image_read_settings template <typename String, typename FormatTag> inline auto make_dynamic_image_reader(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_reader<String, FormatTag>::type { return make_dynamic_image_reader(file_name, image_read_settings<FormatTag>()); } template <typename FormatTag> inline auto make_dynamic_image_reader(std::wstring const& file_name, FormatTag const&) -> typename get_dynamic_image_reader<std::wstring, FormatTag>::type { return make_dynamic_image_reader(file_name, image_read_settings<FormatTag>()); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename FormatTag> inline auto make_dynamic_image_reader(filesystem::path const& path, FormatTag const&) -> typename get_dynamic_image_reader<std::wstring, FormatTag>::type { return make_dynamic_image_reader(path.wstring(), image_read_settings<FormatTag>()); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_dynamic_image_reader(Device& file, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_dynamic_image_reader<Device, FormatTag>::type { return make_dynamic_image_reader(file, image_read_settings<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[�k:�3��3�� io/io.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny // // 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_IO_IO_HPP #define BOOST_GIL_IO_IO_HPP /! \page iobackend Adding a new io backend * \section Overview of backend requirements * To add support for a new IO backend the following is required: * - a format tag, to identify the image format, derived from boost::gil::format_tag * - boolean meta function is_supported<PixelType,FormatTag> must be implemented for * the new format tag * - explicit specialisation of image_read_info<FormatTag> must be provided, containing * runtime information available before/at reading the image * - explicit specialisation of image_write_info<FormatTag> must be provided, containing * runtime encoding parameters for writing an image * - An image reader must be specialized: * \code * template<typename IODevice, typename ConversionPolicy> * struct boost::gil::reader<IODevice,FormatTag,ConversionPolicy> * { * reader( IODevice & device ) * reader( IODevice & device, typename ConversionPolicy::color_converter_type const& cc ) * image_read_info<FormatTag> get_info(); * template<typename Image> * void read_image( Image &, point_t const& top_left ); * template<typename View> * void read_view( View &, point_t const& top_left ); * }; * \endcode * - An image writer must be specialized: * \code * \template <typename IODevice> * struct boost::gil::writer<IODevice,FormatTag> * { * writer( IODevice & device ) * template<typename View> * void apply( View const&, point_t const& top_left ); * template<typename View> * void apply( View const&, point_t const& top_left, image_write_info<FormatTag> const& ); * }; * \endcode * * Or instead of the items above implement overloads of read_view, read_and_convert_view, read_image, * read_and_convert_image, write_view and read_image_info. * * \section ConversionPolicy Interface of the ConversionPolicy * There are two different conversion policies in use, when reading images: * read_and_convert<ColorConverter> and read_and_no_convert. ColorConverter * can be a user defined color converter. * * \code * struct ConversionPolicy * { * template<typename InputIterator,typename OutputIterator> * void read( InputIterator in_begin, InputIterator in_end, * OutputIterator out_end ); * }; * \endcode * * Methods like read_view and read_image are supposed to bail out with an * exception instead of converting the image * * \section IODevice Concept of IO Device * A Device is simply an object used to read and write data to and from a stream. * The IODevice was added as a template paramter to be able to replace the file_name * access functionality. This is only an interim solution, as soon as boost provides * a good IO library, interfaces/constraints provided by that library could be used. * * \code * concept IODevice * { * void IODevice::read( unsigned char* data, int count ); * void IODevice::write( unsigned char* data, int count ); * void IODevice::seek(long count, int whence); * void IODevice::flush(); * }; * \endcode * * For the time being a boolean meta function must be specialized: * \code * namespace boost{namespace gil{namespace detail{ * template<typename Device> * struct detail::is_input_device; * }}} * \endcode * / #endif PK��p�[�}�d��d��io/path_spec.hppnu��[��// // Copyright 2007-2008 Andreas Pokorny, Christian Henning // // 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_IO_PATH_SPEC_HPP #define BOOST_GIL_IO_PATH_SPEC_HPP #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT // Disable warning: conversion to 'std::atomic<int>::__integral_type {aka int}' from 'long int' may alter its value #if defined(BOOST_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wshorten-64-to-32" #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif #define BOOST_FILESYSTEM_VERSION 3 #include <boost/filesystem/path.hpp> #if defined(BOOST_CLANG) #pragma clang diagnostic pop #endif #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) #pragma GCC diagnostic pop #endif #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT #include <cstdlib> #include <string> #include <type_traits> namespace boost { namespace gil { namespace detail { template<typename P> struct is_supported_path_spec : std::false_type {}; template<> struct is_supported_path_spec< std::string > : std::true_type {}; template<> struct is_supported_path_spec< const std::string > : std::true_type {}; template<> struct is_supported_path_spec< std::wstring > : std::true_type {}; template<> struct is_supported_path_spec< const std::wstring > : std::true_type {}; template<> struct is_supported_path_spec< const char > : std::true_type {}; template<> struct is_supported_path_spec< char* > : std::true_type {}; template<> struct is_supported_path_spec< const wchar_t* > : std::true_type {}; template<> struct is_supported_path_spec< wchar_t* > : std::true_type {}; template<int i> struct is_supported_path_spec<const char [i]> : std::true_type {}; template<int i> struct is_supported_path_spec<char [i]> : std::true_type {}; template<int i> struct is_supported_path_spec<const wchar_t [i]> : std::true_type {}; template<int i> struct is_supported_path_spec<wchar_t [i]> : std::true_type {}; #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template<> struct is_supported_path_spec< filesystem::path > : std::true_type {}; template<> struct is_supported_path_spec< const filesystem::path > : std::true_type {}; #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT /// /// convert_to_string /// inline std::string convert_to_string( std::string const& obj) { return obj; } inline std::string convert_to_string( std::wstring const& s ) { std::size_t len = wcslen( s.c_str() ); char* c = reinterpret_cast<char>( alloca( len )); wcstombs( c, s.c_str(), len ); return std::string( c, c + len ); } inline std::string convert_to_string( const char str ) { return std::string( str ); } inline std::string convert_to_string( char* str ) { return std::string( str ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT inline std::string convert_to_string( const filesystem::path& path ) { return convert_to_string( path.string() ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT /// /// convert_to_native_string /// inline const char* convert_to_native_string( char* str ) { return str; } inline const char* convert_to_native_string( const char* str ) { return str; } inline const char* convert_to_native_string( const std::string& str ) { return str.c_str(); } inline const char* convert_to_native_string( const wchar_t* str ) { std::size_t len = wcslen( str ) + 1; char* c = new char[len]; wcstombs( c, str, len ); return c; } inline const char* convert_to_native_string( const std::wstring& str ) { std::size_t len = wcslen( str.c_str() ) + 1; char* c = new char[len]; wcstombs( c, str.c_str(), len ); return c; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[��ۜ{��{��io/get_read_device.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_GET_READ_DEVICE_HPP #define BOOST_GIL_IO_GET_READ_DEVICE_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/path_spec.hpp> #include <type_traits> namespace boost { namespace gil { template< typename T , typename FormatTag , class Enable = void > struct get_read_device {}; template <typename Device, typename FormatTag> struct get_read_device < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using type = typename detail::is_adaptable_input_device < FormatTag, Device >::device_type; }; template <typename String, typename FormatTag> struct get_read_device < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using type = detail::file_stream_device<FormatTag>; }; } // namespace gil } // namespace boost #endif PK��p�[_g<L&��&��io/make_reader.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_MAKE_READER_HPP #define BOOST_GIL_IO_MAKE_READER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_reader.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag, typename ConversionPolicy> inline auto make_reader( String const&file_name, image_read_settings<FormatTag> const& settings, ConversionPolicy const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader<String, FormatTag, ConversionPolicy>::type { typename get_read_device<String, FormatTag>::type device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::read_tag()); return typename get_reader<String, FormatTag, ConversionPolicy>::type(device, settings); } template< typename FormatTag , typename ConversionPolicy > inline typename get_reader< std::wstring , FormatTag , ConversionPolicy >::type make_reader( const std::wstring& file_name , const image_read_settings< FormatTag >& settings , const ConversionPolicy& ) { const char* str = detail::convert_to_native_string( file_name ); typename get_read_device< std::wstring , FormatTag >::type device( str , typename detail::file_stream_device< FormatTag >::read_tag() ); delete[] str; // TODO: RAII return typename get_reader< std::wstring , FormatTag , ConversionPolicy >::type( device , settings ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag , typename ConversionPolicy > inline typename get_reader< std::wstring , FormatTag , ConversionPolicy >::type make_reader( const filesystem::path& path , const image_read_settings< FormatTag >& settings , const ConversionPolicy& cc ) { return make_reader( path.wstring() , settings , cc ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag, typename ConversionPolicy> inline auto make_reader( Device& file, image_read_settings<FormatTag> const& settings, ConversionPolicy const&, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader<Device, FormatTag, ConversionPolicy>::type { typename get_read_device<Device, FormatTag>::type device(file); return typename get_reader<Device, FormatTag, ConversionPolicy>::type(device, settings); } // no image_read_settings template <typename String, typename FormatTag, typename ConversionPolicy> inline auto make_reader( String const&file_name, FormatTag const&, ConversionPolicy const& cc, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader<String, FormatTag, ConversionPolicy>::type { return make_reader(file_name, image_read_settings<FormatTag>(), cc); } template< typename FormatTag , typename ConversionPolicy > inline typename get_reader< std::wstring , FormatTag , ConversionPolicy >::type make_reader( const std::wstring& file_name , const FormatTag& , const ConversionPolicy& cc ) { return make_reader( file_name , image_read_settings< FormatTag >() , cc ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag , typename ConversionPolicy > inline typename get_reader< std::wstring , FormatTag , ConversionPolicy >::type make_reader( const filesystem::path& path , const FormatTag& , const ConversionPolicy& cc ) { return make_reader( path.wstring() , image_read_settings< FormatTag >() , cc ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag, typename ConversionPolicy> inline auto make_reader( Device& file, FormatTag const&, ConversionPolicy const& cc, typename std::enable_if < mp11::mp_and < detail::is_adaptable_input_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_reader<Device, FormatTag, ConversionPolicy>::type { return make_reader(file, image_read_settings<FormatTag>(), cc); } }} // namespace boost::gil #endif PK��p�[��˷��io/write_view.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_WRITE_VIEW_HPP #define BOOST_GIL_IO_WRITE_VIEW_HPP #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_writer.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// \ingroup IO template<typename Writer, typename View> inline void write_view(Writer& writer, View const& view, typename std::enable_if < mp11::mp_and < typename detail::is_writer<Writer>::type, typename is_format_tag<typename Writer::format_tag_t>::type, typename is_write_supported < typename get_pixel_type<View>::type, typename Writer::format_tag_t >::type >::value >::type* /* ptr / = nullptr) { writer.apply(view); } /// \ingroup IO template<typename Device, typename View, typename FormatTag> inline void write_view(Device& device, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename detail::is_write_device<FormatTag, Device>::type, typename is_format_tag<FormatTag>::type, typename is_write_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_writer<Device, FormatTag>::type; writer_t writer = make_writer(device, tag); write_view(writer, view); } /// \ingroup IO template<typename String, typename View, typename FormatTag> inline void write_view(String const& file_name, View const& view, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type, typename is_write_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_writer<String, FormatTag>::type; writer_t writer = make_writer(file_name, tag); write_view(writer, view); } /// \ingroup IO template<typename Device, typename View, typename FormatTag, typename Log> inline void write_view( Device& device, View const& view, image_write_info<FormatTag, Log> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_write_device<FormatTag, Device>::type, typename is_format_tag<FormatTag>::type, typename is_write_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_writer<Device, FormatTag>::type; writer_t writer = make_writer(device, info); write_view(writer, view); } /// \ingroup IO template<typename String, typename View, typename FormatTag, typename Log> inline void write_view( String const& file_name, View const& view, image_write_info<FormatTag, Log> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type, typename is_write_supported < typename get_pixel_type<View>::type, FormatTag >::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_writer<String, FormatTag>::type; writer_t writer = make_writer(file_name, info); write_view(writer, view); } ////////////////////////////////////// dynamic_image // without image_write_info template <typename Writer, typename ...Views> inline void write_view(Writer& writer, any_image_view<Views...> const& view, typename std::enable_if < mp11::mp_and < typename detail::is_dynamic_image_writer<Writer>::type, typename is_format_tag<typename Writer::format_tag_t>::type >::value >::type /* ptr / = nullptr) { writer.apply(view); } // without image_write_info template <typename Device, typename ...Views, typename FormatTag> inline void write_view( Device& device, any_image_view<Views...> const& views, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename detail::is_write_device<FormatTag, Device>::type, typename is_format_tag<FormatTag>::type >::value >::type /* ptr / = 0) { using writer_t = typename get_dynamic_image_writer<Device, FormatTag>::type; writer_t writer = make_dynamic_image_writer(device, tag); write_view(writer, views); } template <typename String, typename ...Views, typename FormatTag> inline void write_view( String const& file_name, any_image_view<Views...> const& views, FormatTag const& tag, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_dynamic_image_writer<String, FormatTag>::type; writer_t writer = make_dynamic_image_writer(file_name, tag); write_view(writer, views); } // with image_write_info /// \ingroup IO template <typename Device, typename ...Views, typename FormatTag, typename Log> inline void write_view( Device& device, any_image_view<Views...> const& views, image_write_info<FormatTag, Log> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_write_device<FormatTag, Device>::type, typename is_format_tag<FormatTag>::type >::value >::type /* ptr / = 0) { using writer_t = typename get_dynamic_image_writer<Device, FormatTag>::type; writer_t writer = make_dynamic_image_writer(device, info); write_view(writer, views); } template <typename String, typename ...Views, typename FormatTag, typename Log> inline void write_view( String const& file_name, any_image_view<Views...> const& views, image_write_info<FormatTag, Log> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_supported_path_spec<String>::type, typename is_format_tag<FormatTag>::type >::value >::type /* ptr / = nullptr) { using writer_t = typename get_dynamic_image_writer<String, FormatTag>::type; writer_t writer = make_dynamic_image_writer(file_name, info); write_view(writer, views); } }} // namespace boost::gil #endif PK��p�[�c��io/make_writer.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_MAKE_WRITER_HPP #define BOOST_GIL_IO_MAKE_WRITER_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/get_writer.hpp> #include <type_traits> namespace boost { namespace gil { template <typename String, typename FormatTag> inline auto make_writer(String const& file_name, image_write_info<FormatTag> const& info, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value>::type /dummy/ = nullptr) -> typename get_writer<String, FormatTag>::type { typename get_write_device<String, FormatTag>::type device( detail::convert_to_native_string(file_name), typename detail::file_stream_device<FormatTag>::write_tag()); return typename get_writer<String, FormatTag>::type(device, info); } template< typename FormatTag > inline typename get_writer< std::wstring , FormatTag >::type make_writer( const std::wstring& file_name , const image_write_info< FormatTag >& info ) { const char* str = detail::convert_to_native_string( file_name ); typename get_write_device< std::wstring , FormatTag >::type device( str , typename detail::file_stream_device< FormatTag >::write_tag() ); delete[] str; return typename get_writer< std::wstring , FormatTag >::type( device , info ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag > inline typename get_writer< std::wstring , FormatTag >::type make_writer( const filesystem::path& path , const image_write_info< FormatTag >& info ) { return make_writer( path.wstring() , info ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_writer(Device& file, image_write_info<FormatTag> const& info, typename std::enable_if < mp11::mp_and < typename detail::is_adaptable_output_device<FormatTag, Device>::type, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_writer<Device, FormatTag>::type { typename get_write_device<Device, FormatTag>::type device(file); return typename get_writer<Device, FormatTag>::type(device, info); } // no image_write_info template <typename String, typename FormatTag> inline auto make_writer(String const& file_name, FormatTag const&, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_writer<String, FormatTag>::type { return make_writer(file_name, image_write_info<FormatTag>()); } template< typename FormatTag > inline typename get_writer< std::wstring , FormatTag >::type make_writer( const std::wstring& file_name , const FormatTag& ) { return make_writer( file_name , image_write_info< FormatTag >() ); } #ifdef BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template< typename FormatTag > inline typename get_writer< std::wstring , FormatTag >::type make_writer( const filesystem::path& path , const FormatTag& tag ) { return make_writer( path.wstring() , tag ); } #endif // BOOST_GIL_IO_ADD_FS_PATH_SUPPORT template <typename Device, typename FormatTag> inline auto make_writer(Device& file, FormatTag const&, typename std::enable_if < mp11::mp_and < typename detail::is_adaptable_output_device<FormatTag, Device>::type, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) -> typename get_writer<Device, FormatTag>::type { return make_writer(file, image_write_info<FormatTag>()); } }} // namespace boost::gil #endif PK��p�[.��4��4��io/row_buffer_helper.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_IO_ROW_BUFFER_HELPER_HPP #define BOOST_GIL_IO_ROW_BUFFER_HELPER_HPP // TODO: Shall we move toolbox to core? #include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp> #include <boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/typedefs.hpp> #include <cstddef> #include <type_traits> #include <vector> namespace boost { namespace gil { namespace detail { template< typename Pixel , typename DummyT = void > struct row_buffer_helper { using element_t = Pixel; using buffer_t = std::vector<element_t>; using iterator_t = typename buffer_t::iterator; row_buffer_helper( std::size_t width , bool ) : _row_buffer( width ) {} element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return _row_buffer.begin(); } iterator_t end() { return _row_buffer.end(); } buffer_t& buffer() { return _row_buffer; } private: buffer_t _row_buffer; }; template <typename Pixel> struct row_buffer_helper < Pixel, typename std::enable_if < is_bit_aligned<Pixel>::value >::type > { using element_t = byte_t; using buffer_t = std::vector<element_t>; using pixel_type = Pixel; using iterator_t = bit_aligned_pixel_iterator<pixel_type>; row_buffer_helper(std::size_t width, bool in_bytes) : _c{( width * pixel_bit_size< pixel_type >::value) >> 3} , _r{width * pixel_bit_size< pixel_type >::value - (_c << 3)} { if (in_bytes) { _row_buffer.resize(width); } else { // add one byte if there are remaining bits _row_buffer.resize(_c + (_r != 0)); } } element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return iterator_t( &_row_buffer.front(),0 ); } iterator_t end() { return _r == 0 ? iterator_t( &_row_buffer.back() + 1, 0 ) : iterator_t( &_row_buffer.back() , (int) _r ); } buffer_t& buffer() { return _row_buffer; } private: // For instance 25 pixels of rgb2 type would be: // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits // c = 18 bytes // r = 6 bits std::size_t _c; // number of full bytes std::size_t _r; // number of remaining bits buffer_t _row_buffer; }; template<typename Pixel> struct row_buffer_helper < Pixel, typename std::enable_if < mp11::mp_and < typename is_bit_aligned<Pixel>::type, typename is_homogeneous<Pixel>::type >::value > > { using element_t = byte_t; using buffer_t = std::vector<element_t>; using pixel_type = Pixel; using iterator_t = bit_aligned_pixel_iterator<pixel_type>; row_buffer_helper( std::size_t width , bool in_bytes ) : _c( ( width * num_channels< pixel_type >::value * channel_type< pixel_type >::type::num_bits ) >> 3 ) , _r( width * num_channels< pixel_type >::value * channel_type< pixel_type >::type::num_bits - ( _c << 3 ) ) { if( in_bytes ) { _row_buffer.resize( width ); } else { // add one byte if there are remaining bits _row_buffer.resize( _c + ( _r!=0 )); } } element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return iterator_t( &_row_buffer.front(),0 ); } iterator_t end() { return _r == 0 ? iterator_t( &_row_buffer.back() + 1, 0 ) : iterator_t( &_row_buffer.back() , (int) _r ); } buffer_t& buffer() { return _row_buffer; } private: // For instance 25 pixels of rgb2 type would be: // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits // c = 18 bytes // r = 6 bits std::size_t _c; // number of full bytes std::size_t _r; // number of remaining bits buffer_t _row_buffer; }; template <typename View, typename D = void> struct row_buffer_helper_view : row_buffer_helper<typename View::value_type> { row_buffer_helper_view(std::size_t width, bool in_bytes) : row_buffer_helper<typename View::value_type>(width, in_bytes) {} }; template <typename View> struct row_buffer_helper_view < View, typename std::enable_if < is_bit_aligned<typename View::value_type>::value >::type > : row_buffer_helper<typename View::reference> { row_buffer_helper_view(std::size_t width, bool in_bytes) : row_buffer_helper<typename View::reference>(width, in_bytes) {} }; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[��[D��io/bit_operations.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_BIT_OPERATIONS_HPP #define BOOST_GIL_IO_BIT_OPERATIONS_HPP #include <boost/gil/io/typedefs.hpp> #include <array> #include <cstddef> #include <type_traits> namespace boost { namespace gil { namespace detail { // 1110 1100 -> 0011 0111 template <typename Buffer, typename IsBitAligned> struct mirror_bits { mirror_bits(bool) {}; void operator()(Buffer&) {} void operator()(byte_t, std::size_t){} }; // The functor will generate a lookup table since the // mirror operation is quite costly. template <typename Buffer> struct mirror_bits<Buffer, std::true_type> { mirror_bits(bool apply_operation = true) : apply_operation_(apply_operation) { if(apply_operation_) { byte_t i = 0; do { lookup_[i] = mirror(i); } while (i++ != 255); } } void operator()(Buffer& buffer) { if (apply_operation_) for_each(buffer.begin(), buffer.end(), [this](byte_t& c) { lookup(c); }); } void operator()(byte_t dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { lookup(dst); ++dst; } } private: void lookup(byte_t& c) { c = lookup_[c]; } static byte_t mirror(byte_t c) { byte_t result = 0; for (int i = 0; i < 8; ++i) { result = result << 1; result \|= (c & 1); c = c >> 1; } return result; } std::array<byte_t, 256> lookup_; bool apply_operation_; }; // 0011 1111 -> 1100 0000 template <typename Buffer, typename IsBitAligned> struct negate_bits { void operator()(Buffer&) {}; }; template <typename Buffer> struct negate_bits<Buffer, std::true_type> { void operator()(Buffer& buffer) { for_each(buffer.begin(), buffer.end(), negate_bits<Buffer, std::true_type>::negate); } void operator()(byte_t dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { negate(dst); ++dst; } } private: static void negate(byte_t& b) { b = ~b; } }; // 11101100 -> 11001110 template <typename Buffer, typename IsBitAligned> struct swap_half_bytes { void operator()(Buffer&) {}; }; template <typename Buffer> struct swap_half_bytes<Buffer, std::true_type> { void operator()(Buffer& buffer) { for_each(buffer.begin(), buffer.end(), swap_half_bytes<Buffer, std::true_type>::swap); } void operator()(byte_t dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { swap(dst); ++dst; } } private: static void swap(byte_t& c) { c = ((c << 4) & 0xF0) \| ((c >> 4) & 0x0F); } }; template <typename Buffer> struct do_nothing { do_nothing() = default; void operator()(Buffer&) {} }; /// Count consecutive zeros on the right template <typename T> inline unsigned int trailing_zeros(T x) noexcept { unsigned int n = 0; x = ~x & (x - 1); while (x) { n = n + 1; x = x >> 1; } return n; } /// Counts ones in a bit-set template <typename T> inline unsigned int count_ones(T x) noexcept { unsigned int n = 0; while (x) { // clear the least significant bit set x &= x - 1; ++n; } return n; } }}} // namespace boost::gil::detail #endif PK��p�[t�7��7��io/get_write_device.hppnu��[��// // Copyright 2012 Christian Henning // // 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_IO_GET_WRITE_DEVICE_HPP #define BOOST_GIL_IO_GET_WRITE_DEVICE_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/path_spec.hpp> #include <type_traits> namespace boost { namespace gil { template <typename T, typename FormatTag, class Enable = void> struct get_write_device {}; template <typename Device, typename FormatTag> struct get_write_device < Device, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_adaptable_output_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type > { using type = typename detail::is_adaptable_output_device<FormatTag, Device>::device_type; }; template <typename String, typename FormatTag> struct get_write_device < String, FormatTag, typename std::enable_if < mp11::mp_and < detail::is_supported_path_spec<String>, is_format_tag<FormatTag> >::value >::type > { using type = detail::file_stream_device<FormatTag>; }; }} // namespace boost::gil #endif PK��p�[��P��io/conversion_policies.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny // // 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_IO_CONVERSION_POLICIES_HPP #define BOOST_GIL_IO_CONVERSION_POLICIES_HPP #include <boost/gil/image_view_factory.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/error.hpp> #include <algorithm> #include <iterator> #include <type_traits> namespace boost{ namespace gil { namespace detail { struct read_and_no_convert { public: using color_converter_type = void ; template <typename InIterator, typename OutIterator> void read( InIterator const& /begin/, InIterator const& /end/ , OutIterator /out/, typename std::enable_if < mp11::mp_not < pixels_are_compatible < typename std::iterator_traits<InIterator>::value_type, typename std::iterator_traits<OutIterator>::value_type > >::value >::type* /dummy/ = nullptr) { io_error("Data cannot be copied because the pixels are incompatible."); } template <typename InIterator, typename OutIterator> void read(InIterator const& begin, InIterator const& end, OutIterator out, typename std::enable_if < pixels_are_compatible < typename std::iterator_traits<InIterator>::value_type, typename std::iterator_traits<OutIterator>::value_type >::value >::type* /dummy/ = nullptr) { std::copy(begin, end, out); } }; template<typename CC> struct read_and_convert { public: using color_converter_type = default_color_converter; CC _cc; read_and_convert() {} read_and_convert( const color_converter_type& cc ) : _cc( cc ) {} template< typename InIterator , typename OutIterator > void read( const InIterator& begin , const InIterator& end , OutIterator out ) { using deref_t = color_convert_deref_fn<typename std::iterator_traits<InIterator>::reference , typename std::iterator_traits<OutIterator>::value_type //reference? , CC >; std::transform( begin , end , out , deref_t( _cc ) ); } }; /// is_read_only metafunction /// \brief Determines if reader type is read only ( no conversion ). template< typename Conversion_Policy > struct is_read_only : std::false_type {}; template<> struct is_read_only<detail::read_and_no_convert> : std::true_type {}; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[ͼ�Y.'��.'��io/read_and_convert_image.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_IO_READ_AND_CONVERT_IMAGE_HPP #define BOOST_GIL_IO_READ_AND_CONVERT_IMAGE_HPP #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/path_spec.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// \ingroup IO /// \brief Reads and color-converts an image. Image memory is allocated. /// \param reader An image reader. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename Reader, typename Image> inline void read_and_convert_image(Reader& reader, Image& img, typename std::enable_if < mp11::mp_and < detail::is_reader<Reader>, is_format_tag<typename Reader::format_tag_t> >::value >::type* /dummy/ = nullptr) { reader.init_image(img, reader._settings); reader.apply(view(img)); } /// \brief Reads and color-converts an image. Image memory is allocated. /// \param device Must satisfy is_input_device metafunction. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename Device, typename Image, typename ColorConverter, typename FormatTag> inline void read_and_convert_image( Device& device, Image& img, image_read_settings<FormatTag> const& settings, ColorConverter const& cc, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, settings, read_and_convert_t{cc}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \param cc Color converter function object. /// \throw std::ios_base::failure template <typename String, typename Image, typename ColorConverter, typename FormatTag> inline void read_and_convert_image( String const& file_name, Image& img, image_read_settings<FormatTag> const& settings, ColorConverter const& cc, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, settings, read_and_convert_t{cc}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. /// \param cc Color converter function object. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename Image, typename ColorConverter, typename FormatTag> inline void read_and_convert_image( String const& file_name, Image& img, ColorConverter const& cc, FormatTag const& tag, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, tag, read_and_convert_t{cc}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. /// \param device Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param img The image in which the data is read into. /// \param cc Color converter function object. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename Image, typename ColorConverter, typename FormatTag> inline void read_and_convert_image( Device& device, Image& img, ColorConverter const& cc, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<ColorConverter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, tag, read_and_convert_t{cc}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. Default color converter is used. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename String, typename Image, typename FormatTag> inline void read_and_convert_image( String const& file_name, Image& img, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, settings, read_and_convert_t{}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. Default color converter is used. /// \param device It's a device. Must satisfy is_input_device metafunction or is_adaptable_input_device. /// \param img The image in which the data is read into. /// \param settings Specifies read settings depending on the image format. /// \throw std::ios_base::failure template <typename Device, typename Image, typename FormatTag> inline void read_and_convert_image( Device& device, Image& img, image_read_settings<FormatTag> const& settings, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, settings, read_and_convert_t{}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. Default color converter is used. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename String, typename Image, typename FormatTag> inline void read_and_convert_image( String const& file_name, Image& img, FormatTag const& tag, typename std::enable_if < mp11::mp_and < is_format_tag<FormatTag>, detail::is_supported_path_spec<String> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<String, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(file_name, tag, read_and_convert_t{}); read_and_convert_image(reader, img); } /// \brief Reads and color-converts an image. Image memory is allocated. Default color converter is used. /// \param file_name File name. Must satisfy is_supported_path_spec metafunction. /// \param img The image in which the data is read into. /// \param tag Defines the image format. Must satisfy is_format_tag metafunction. /// \throw std::ios_base::failure template <typename Device, typename Image, typename FormatTag> inline void read_and_convert_image( Device& device, Image& img, FormatTag const& tag, typename std::enable_if < mp11::mp_and < detail::is_read_device<FormatTag, Device>, is_format_tag<FormatTag> >::value >::type* /dummy/ = nullptr) { using read_and_convert_t = detail::read_and_convert<default_color_converter>; using reader_t = typename get_reader<Device, FormatTag, read_and_convert_t>::type; reader_t reader = make_reader(device, tag, read_and_convert_t{}); read_and_convert_image(reader, img); } }} // namespace boost::gil #endif PK��p�[YT� �� io/scanline_read_iterator.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_IO_SCANLINE_READ_ITERATOR_HPP #define BOOST_GIL_IO_SCANLINE_READ_ITERATOR_HPP #include <boost/gil/io/error.hpp> #include <boost/gil/io/typedefs.hpp> #include <boost/iterator/iterator_facade.hpp> #include <iterator> #include <memory> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// Input iterator to read images. template <typename Reader> class scanline_read_iterator : public boost::iterator_facade<scanline_read_iterator<Reader>, byte_t, std::input_iterator_tag> { private: using base_t = boost::iterator_facade < scanline_read_iterator<Reader>, byte_t, std::input_iterator_tag >; public: scanline_read_iterator(Reader& reader, int pos = 0) : reader_(reader), pos_(pos) { buffer_ = std::make_shared<buffer_t>(buffer_t(reader_._scanline_length)); buffer_start_ = &buffer_->front(); } private: friend class boost::iterator_core_access; void increment() { if (skip_scanline_) { reader_.skip(buffer_start_, pos_); } ++pos_; skip_scanline_ = true; read_scanline_ = true; } bool equal(scanline_read_iterator const& rhs) const { return pos_ == rhs.pos_; } typename base_t::reference dereference() const { if (read_scanline_) { reader_.read(buffer_start_, pos_); } skip_scanline_ = false; read_scanline_ = false; return buffer_start_; } private: Reader& reader_; mutable int pos_ = 0; mutable bool read_scanline_ = true; mutable bool skip_scanline_ = true; using buffer_t = std::vector<byte_t>; using buffer_ptr_t = std::shared_ptr<buffer_t>; buffer_ptr_t buffer_; mutable byte_t* buffer_start_ = nullptr; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[��~k��k��gray.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_GRAY_HPP #define BOOST_GIL_GRAY_HPP #include <boost/gil/utilities.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost { namespace gil { /// \ingroup ColorNameModel /// \brief Gray struct gray_color_t {}; /// \ingroup ColorSpaceModel using gray_t = mp11::mp_list<gray_color_t>; /// \ingroup LayoutModel using gray_layout_t = layout<gray_t>; }} // namespace boost::gil #endif PK��p�[P��L6��6��color_convert.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_COLOR_CONVERT_HPP #define BOOST_GIL_COLOR_CONVERT_HPP #include <boost/gil/channel_algorithm.hpp> #include <boost/gil/cmyk.hpp> #include <boost/gil/color_base_algorithm.hpp> #include <boost/gil/gray.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/gil/pixel.hpp> #include <boost/gil/rgb.hpp> #include <boost/gil/rgba.hpp> #include <boost/gil/utilities.hpp> #include <algorithm> #include <functional> #include <type_traits> namespace boost { namespace gil { /// Support for fast and simple color conversion. /// Accurate color conversion using color profiles can be supplied separately in a dedicated module. // Forward-declare template <typename P> struct channel_type; //////////////////////////////////////////////////////////////////////////////////////// /// /// COLOR SPACE CONVERSION /// //////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ColorConvert /// \brief Color Convertion function object. To be specialized for every src/dst color space template <typename C1, typename C2> struct default_color_converter_impl { static_assert( std::is_same<C1, C2>::value, "default_color_converter_impl not specialized for given color spaces"); }; /// \ingroup ColorConvert /// \brief When the color space is the same, color convertion performs channel depth conversion template <typename C> struct default_color_converter_impl<C,C> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { static_for_each(src,dst,default_channel_converter()); } }; namespace detail { /// red * .3 + green * .59 + blue * .11 + .5 // The default implementation of to_luminance uses float0..1 as the intermediate channel type template <typename RedChannel, typename GreenChannel, typename BlueChannel, typename GrayChannelValue> struct rgb_to_luminance_fn { GrayChannelValue operator()(const RedChannel& red, const GreenChannel& green, const BlueChannel& blue) const { return channel_convert<GrayChannelValue>(float32_t( channel_convert<float32_t>(red )0.30f + channel_convert<float32_t>(green)0.59f + channel_convert<float32_t>(blue )0.11f) ); } }; // performance specialization for unsigned char template <typename GrayChannelValue> struct rgb_to_luminance_fn<uint8_t,uint8_t,uint8_t, GrayChannelValue> { GrayChannelValue operator()(uint8_t red, uint8_t green, uint8_t blue) const { return channel_convert<GrayChannelValue>(uint8_t( ((uint32_t(red )4915 + uint32_t(green)9667 + uint32_t(blue )1802) + 8192) >> 14)); } }; template <typename GrayChannel, typename RedChannel, typename GreenChannel, typename BlueChannel> typename channel_traits<GrayChannel>::value_type rgb_to_luminance(const RedChannel& red, const GreenChannel& green, const BlueChannel& blue) { return rgb_to_luminance_fn<RedChannel,GreenChannel,BlueChannel, typename channel_traits<GrayChannel>::value_type>()(red,green,blue); } } // namespace detail /// \ingroup ColorConvert /// \brief Gray to RGB template <> struct default_color_converter_impl<gray_t,rgb_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,red_t()) = channel_convert<typename color_element_type<P2, red_t >::type>(get_color(src,gray_color_t())); get_color(dst,green_t())= channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t())); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2, blue_t >::type>(get_color(src,gray_color_t())); } }; /// \ingroup ColorConvert /// \brief Gray to CMYK /// \todo FIXME: Where does this calculation come from? Shouldn't gray be inverted? /// Currently, white becomes black and black becomes white. template <> struct default_color_converter_impl<gray_t,cmyk_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,cyan_t())= channel_traits<typename color_element_type<P2, cyan_t >::type>::min_value(); get_color(dst,magenta_t())= channel_traits<typename color_element_type<P2, magenta_t>::type>::min_value(); get_color(dst,yellow_t())= channel_traits<typename color_element_type<P2, yellow_t >::type>::min_value(); get_color(dst,black_t())= channel_convert<typename color_element_type<P2, black_t >::type>(get_color(src,gray_color_t())); } }; /// \ingroup ColorConvert /// \brief RGB to Gray template <> struct default_color_converter_impl<rgb_t,gray_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,gray_color_t()) = detail::rgb_to_luminance<typename color_element_type<P2,gray_color_t>::type>( get_color(src,red_t()), get_color(src,green_t()), get_color(src,blue_t()) ); } }; /// \ingroup ColorConvert /// \brief RGB to CMYK (not the fastest code in the world) /// /// k = min(1 - r, 1 - g, 1 - b) /// c = (1 - r - k) / (1 - k) /// m = (1 - g - k) / (1 - k) /// y = (1 - b - k) / (1 - k) /// where `1` denotes max value of channel type of destination pixel. /// /// The conversion from RGB to CMYK is based on CMY->CMYK (Version 2) /// from the Principles of Digital Image Processing - Fundamental Techniques /// by Burger, Wilhelm, Burge, Mark J. /// and it is a gross approximation not precise enough for professional work. /// /// \todo FIXME: The original implementation did not handle properly signed CMYK pixels as destination /// template <> struct default_color_converter_impl<rgb_t, cmyk_t> { template <typename SrcPixel, typename DstPixel> void operator()(SrcPixel const& src, DstPixel& dst) const { using src_t = typename channel_type<SrcPixel>::type; src_t const r = get_color(src, red_t()); src_t const g = get_color(src, green_t()); src_t const b = get_color(src, blue_t()); using dst_t = typename channel_type<DstPixel>::type; dst_t const c = channel_invert(channel_convert<dst_t>(r)); // c = 1 - r dst_t const m = channel_invert(channel_convert<dst_t>(g)); // m = 1 - g dst_t const y = channel_invert(channel_convert<dst_t>(b)); // y = 1 - b dst_t const k = (std::min)(c, (std::min)(m, y)); // k = minimum(c, m, y) // Apply color correction, strengthening, reducing non-zero components by // s = 1 / (1 - k) for k < 1, where 1 denotes dst_t max, otherwise s = 1 (literal). dst_t const dst_max = channel_traits<dst_t>::max_value(); dst_t const s_div = dst_max - k; if (s_div != 0) { double const s = dst_max / static_cast<double>(s_div); get_color(dst, cyan_t()) = static_cast<dst_t>((c - k) * s); get_color(dst, magenta_t()) = static_cast<dst_t>((m - k) * s); get_color(dst, yellow_t()) = static_cast<dst_t>((y - k) * s); } else { // Black only for k = 1 (max of dst_t) get_color(dst, cyan_t()) = channel_traits<dst_t>::min_value(); get_color(dst, magenta_t()) = channel_traits<dst_t>::min_value(); get_color(dst, yellow_t()) = channel_traits<dst_t>::min_value(); } get_color(dst, black_t()) = k; } }; /// \ingroup ColorConvert /// \brief CMYK to RGB (not the fastest code in the world) /// /// r = 1 - min(1, c(1-k)+k) /// g = 1 - min(1, m(1-k)+k) /// b = 1 - min(1, y(1-k)+k) template <> struct default_color_converter_impl<cmyk_t,rgb_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { using T1 = typename channel_type<P1>::type; get_color(dst,red_t()) = channel_convert<typename color_element_type<P2,red_t>::type>( channel_invert<T1>( (std::min)(channel_traits<T1>::max_value(), T1(channel_multiply(get_color(src,cyan_t()),channel_invert(get_color(src,black_t())))+get_color(src,black_t()))))); get_color(dst,green_t())= channel_convert<typename color_element_type<P2,green_t>::type>( channel_invert<T1>( (std::min)(channel_traits<T1>::max_value(), T1(channel_multiply(get_color(src,magenta_t()),channel_invert(get_color(src,black_t())))+get_color(src,black_t()))))); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2,blue_t>::type>( channel_invert<T1>( (std::min)(channel_traits<T1>::max_value(), T1(channel_multiply(get_color(src,yellow_t()),channel_invert(get_color(src,black_t())))+get_color(src,black_t()))))); } }; /// \ingroup ColorConvert /// \brief CMYK to Gray /// /// gray = (1 - 0.212c - 0.715m - 0.0722y) (1 - k) template <> struct default_color_converter_impl<cmyk_t,gray_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,gray_color_t())= channel_convert<typename color_element_type<P2,gray_color_t>::type>( channel_multiply( channel_invert( detail::rgb_to_luminance<typename color_element_type<P1,black_t>::type>( get_color(src,cyan_t()), get_color(src,magenta_t()), get_color(src,yellow_t()) ) ), channel_invert(get_color(src,black_t())))); } }; namespace detail { template <typename Pixel> auto alpha_or_max_impl(Pixel const& p, std::true_type) -> typename channel_type<Pixel>::type { return get_color(p,alpha_t()); } template <typename Pixel> auto alpha_or_max_impl(Pixel const&, std::false_type) -> typename channel_type<Pixel>::type { return channel_traits<typename channel_type<Pixel>::type>::max_value(); } } // namespace detail // Returns max_value if the pixel has no alpha channel. Otherwise returns the alpha. template <typename Pixel> auto alpha_or_max(Pixel const& p) -> typename channel_type<Pixel>::type { return detail::alpha_or_max_impl( p, mp11::mp_contains<typename color_space_type<Pixel>::type, alpha_t>()); } /// \ingroup ColorConvert /// \brief Converting any pixel type to RGBA. Note: Supports homogeneous pixels only. template <typename C1> struct default_color_converter_impl<C1,rgba_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { using T2 = typename channel_type<P2>::type; pixel<T2,rgb_layout_t> tmp; default_color_converter_impl<C1,rgb_t>()(src,tmp); get_color(dst,red_t()) =get_color(tmp,red_t()); get_color(dst,green_t())=get_color(tmp,green_t()); get_color(dst,blue_t()) =get_color(tmp,blue_t()); get_color(dst,alpha_t())=channel_convert<T2>(alpha_or_max(src)); } }; /// \ingroup ColorConvert /// \brief Converting RGBA to any pixel type. Note: Supports homogeneous pixels only. /// /// Done by multiplying the alpha to get to RGB, then converting the RGB to the target pixel type /// Note: This may be slower if the compiler doesn't optimize out constructing/destructing a temporary RGB pixel. /// Consider rewriting if performance is an issue template <typename C2> struct default_color_converter_impl<rgba_t,C2> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { using T1 = typename channel_type<P1>::type; default_color_converter_impl<rgb_t,C2>()( pixel<T1,rgb_layout_t>(channel_multiply(get_color(src,red_t()), get_color(src,alpha_t())), channel_multiply(get_color(src,green_t()),get_color(src,alpha_t())), channel_multiply(get_color(src,blue_t()), get_color(src,alpha_t()))) ,dst); } }; /// \ingroup ColorConvert /// \brief Unfortunately RGBA to RGBA must be explicitly provided - otherwise we get ambiguous specialization error. template <> struct default_color_converter_impl<rgba_t,rgba_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { static_for_each(src,dst,default_channel_converter()); } }; /// @defgroup ColorConvert Color Space Converion /// \ingroup ColorSpaces /// \brief Support for conversion between pixels of different color spaces and channel depths /// \ingroup PixelAlgorithm ColorConvert /// \brief class for color-converting one pixel to another struct default_color_converter { template <typename SrcP, typename DstP> void operator()(const SrcP& src,DstP& dst) const { using SrcColorSpace = typename color_space_type<SrcP>::type; using DstColorSpace = typename color_space_type<DstP>::type; default_color_converter_impl<SrcColorSpace,DstColorSpace>()(src,dst); } }; /// \ingroup PixelAlgorithm /// \brief helper function for converting one pixel to another using GIL default color-converters /// where ScrP models HomogeneousPixelConcept /// DstP models HomogeneousPixelValueConcept template <typename SrcP, typename DstP> inline void color_convert(const SrcP& src, DstP& dst) { default_color_converter()(src,dst); } } } // namespace boost::gil #endif PK��p�[�ܩ �� image_processing/harris.hppnu��[��// // Copyright 2019 Olzhas Zhumabek <anonymous.from.applecity@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_HARRIS_HPP #define BOOST_GIL_IMAGE_PROCESSING_HARRIS_HPP #include <boost/gil/image_view.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/extension/numeric/kernel.hpp> namespace boost { namespace gil { /// \defgroup CornerDetectionAlgorithms /// \brief Algorithms that are used to find corners in an image /// /// These algorithms are used to find spots from which /// sliding the window will produce large intensity change /// \brief function to record Harris responses /// \ingroup CornerDetectionAlgorithms /// /// This algorithm computes Harris responses /// for structure tensor represented by m11, m12_21, m22 views. /// Note that m12_21 represents both entries (1, 2) and (2, 1). /// Window length represents size of a window which is slided around /// to compute sum of corresponding entries. k is a discrimination /// constant against edges (usually in range 0.04 to 0.06). /// harris_response is an out parameter that will contain the Harris responses. template <typename T, typename Allocator> void compute_harris_responses( boost::gil::gray32f_view_t m11, boost::gil::gray32f_view_t m12_21, boost::gil::gray32f_view_t m22, boost::gil::detail::kernel_2d<T, Allocator> weights, float k, boost::gil::gray32f_view_t harris_response) { if (m11.dimensions() != m12_21.dimensions() \|\| m12_21.dimensions() != m22.dimensions()) { throw std::invalid_argument("m prefixed arguments must represent" " tensor from the same image"); } auto const window_length = weights.size(); auto const width = m11.width(); auto const height = m11.height(); auto const half_length = window_length / 2; for (auto y = half_length; y < height - half_length; ++y) { for (auto x = half_length; x < width - half_length; ++x) { float ddxx = 0; float dxdy = 0; float ddyy = 0; for (gil::gray32f_view_t::coord_t y_kernel = 0; y_kernel < window_length; ++y_kernel) { for (gil::gray32f_view_t::coord_t x_kernel = 0; x_kernel < window_length; ++x_kernel) { ddxx += m11(x + x_kernel - half_length, y + y_kernel - half_length) .at(std::integral_constant<int, 0>{}) * weights.at(x_kernel, y_kernel); dxdy += m12_21(x + x_kernel - half_length, y + y_kernel - half_length) .at(std::integral_constant<int, 0>{}) * weights.at(x_kernel, y_kernel); ddyy += m22(x + x_kernel - half_length, y + y_kernel - half_length) .at(std::integral_constant<int, 0>{}) * weights.at(x_kernel, y_kernel); } } auto det = (ddxx * ddyy) - dxdy * dxdy; auto trace = ddxx + ddyy; auto harris_value = det - k * trace * trace; harris_response(x, y).at(std::integral_constant<int, 0>{}) = harris_value; } } } }} //namespace boost::gil #endif PK��p�[zxc��c��image_processing/hessian.hppnu��[��#ifndef BOOST_GIL_IMAGE_PROCESSING_HESSIAN_HPP #define BOOST_GIL_IMAGE_PROCESSING_HESSIAN_HPP #include <boost/gil/image_view.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/extension/numeric/kernel.hpp> #include <stdexcept> namespace boost { namespace gil { /// \brief Computes Hessian response /// /// Computes Hessian response based on computed entries of Hessian matrix, e.g. second order /// derivates in x and y, and derivatives in both x, y. /// d stands for derivative, and x or y stand for derivative direction. For example, /// ddxx means taking two derivatives (gradients) in horizontal direction. /// Weights change perception of surroinding pixels. /// Additional filtering is strongly advised. template <typename GradientView, typename T, typename Allocator, typename OutputView> inline void compute_hessian_responses( GradientView ddxx, GradientView dxdy, GradientView ddyy, const detail::kernel_2d<T, Allocator>& weights, OutputView dst) { if (ddxx.dimensions() != ddyy.dimensions() \|\| ddyy.dimensions() != dxdy.dimensions() \|\| dxdy.dimensions() != dst.dimensions() \|\| weights.center_x() != weights.center_y()) { throw std::invalid_argument("dimensions of views are not the same" " or weights don't have equal width and height" " or weights' dimensions are not odd"); } // Use pixel type of output, as values will be written to output using pixel_t = typename std::remove_reference<decltype(std::declval<OutputView>()(0, 0))>::type; using channel_t = typename std::remove_reference < decltype(std::declval<pixel_t>().at(std::integral_constant<int, 0>{})) >::type; auto center = weights.center_y(); for (auto y = center; y < dst.height() - center; ++y) { for (auto x = center; x < dst.width() - center; ++x) { auto ddxx_i = channel_t(); auto ddyy_i = channel_t(); auto dxdy_i = channel_t(); for (typename OutputView::coord_t w_y = 0; w_y < weights.size(); ++w_y) { for (typename OutputView::coord_t w_x = 0; w_x < weights.size(); ++w_x) { ddxx_i += ddxx(x + w_x - center, y + w_y - center) .at(std::integral_constant<int, 0>{}) * weights.at(w_x, w_y); ddyy_i += ddyy(x + w_x - center, y + w_y - center) .at(std::integral_constant<int, 0>{}) * weights.at(w_x, w_y); dxdy_i += dxdy(x + w_x - center, y + w_y - center) .at(std::integral_constant<int, 0>{}) * weights.at(w_x, w_y); } } auto determinant = ddxx_i * ddyy_i - dxdy_i * dxdy_i; dst(x, y).at(std::integral_constant<int, 0>{}) = determinant; } } } }} // namespace boost::gil #endif PK��p�[oa��image_processing/filter.hppnu��[��// // Copyright 2019 Miral Shah <miralshah2211@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_FILTER_HPP #define BOOST_GIL_IMAGE_PROCESSING_FILTER_HPP #include <boost/gil/extension/numeric/algorithm.hpp> #include <boost/gil/extension/numeric/kernel.hpp> #include <boost/gil/extension/numeric/convolve.hpp> #include <boost/gil/image.hpp> #include <boost/gil/image_view.hpp> #include <cstddef> #include <vector> namespace boost { namespace gil { template <typename SrcView, typename DstView> void box_filter( SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size, long int anchor = -1, bool normalize=true, boundary_option option = boundary_option::extend_zero ) { gil_function_requires<ImageViewConcept<SrcView>>(); gil_function_requires<MutableImageViewConcept<DstView>>(); static_assert(color_spaces_are_compatible < typename color_space_type<SrcView>::type, typename color_space_type<DstView>::type >::value, "Source and destination views must have pixels with the same color space"); std::vector<float> kernel_values; if (normalize) { kernel_values.resize(kernel_size, 1.0f / float(kernel_size)); } else { kernel_values.resize(kernel_size, 1.0f); } if (anchor == -1) anchor = static_cast<int>(kernel_size / 2); kernel_1d<float> kernel(kernel_values.begin(), kernel_size, anchor); detail::convolve_1d < pixel<float, typename SrcView::value_type::layout_t> >(src_view, kernel, dst_view, option); } template <typename SrcView, typename DstView> void blur( SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size, long int anchor = -1, boundary_option option = boundary_option::extend_zero ) { box_filter(src_view, dst_view, kernel_size, anchor, true, option); } namespace detail { template <typename SrcView, typename DstView> void filter_median_impl(SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size) { std::size_t half_kernel_size = kernel_size / 2; // deciding output channel type and creating functor using src_channel_t = typename channel_type<SrcView>::type; std::vector<src_channel_t> values; values.reserve(kernel_size * kernel_size); for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename DstView::x_iterator dst_it = dst_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { auto sub_view = subimage_view( src_view, x - half_kernel_size, y - half_kernel_size, kernel_size, kernel_size ); values.assign(sub_view.begin(), sub_view.end()); std::nth_element(values.begin(), values.begin() + (values.size() / 2), values.end()); dst_it[x] = values[values.size() / 2]; } } } } // namespace detail template <typename SrcView, typename DstView> void median_filter(SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size) { static_assert(color_spaces_are_compatible < typename color_space_type<SrcView>::type, typename color_space_type<DstView>::type >::value, "Source and destination views must have pixels with the same color space"); std::size_t half_kernel_size = kernel_size / 2; auto extended_img = extend_boundary( src_view, half_kernel_size, boundary_option::extend_constant ); auto extended_view = subimage_view( view(extended_img), half_kernel_size, half_kernel_size, src_view.width(), src_view.height() ); for (std::size_t channel = 0; channel < extended_view.num_channels(); channel++) { detail::filter_median_impl( nth_channel_view(extended_view, channel), nth_channel_view(dst_view, channel), kernel_size ); } } }} //namespace boost::gil #endif // !BOOST_GIL_IMAGE_PROCESSING_FILTER_HPP PK��p�[��&?��&?��image_processing/threshold.hppnu��[��// // Copyright 2019 Miral Shah <miralshah2211@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP #define BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP #include <limits> #include <array> #include <type_traits> #include <cstddef> #include <algorithm> #include <vector> #include <cmath> #include <boost/assert.hpp> #include <boost/gil/image.hpp> #include <boost/gil/extension/numeric/kernel.hpp> #include <boost/gil/extension/numeric/convolve.hpp> #include <boost/gil/image_processing/numeric.hpp> namespace boost { namespace gil { namespace detail { template < typename SourceChannelT, typename ResultChannelT, typename SrcView, typename DstView, typename Operator > void threshold_impl(SrcView const& src_view, DstView const& dst_view, Operator const& threshold_op) { gil_function_requires<ImageViewConcept<SrcView>>(); gil_function_requires<MutableImageViewConcept<DstView>>(); static_assert(color_spaces_are_compatible < typename color_space_type<SrcView>::type, typename color_space_type<DstView>::type >::value, "Source and destination views must have pixels with the same color space"); //iterate over the image checking each pixel value for the threshold for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); typename DstView::x_iterator dst_it = dst_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { static_transform(src_it[x], dst_it[x], threshold_op); } } } } //namespace boost::gil::detail /// \addtogroup ImageProcessing /// @{ /// /// \brief Direction of image segmentation. /// The direction specifies which pixels are considered as corresponding to object /// and which pixels correspond to background. enum class threshold_direction { regular, ///< Consider values greater than threshold value inverse ///< Consider values less than or equal to threshold value }; /// \ingroup ImageProcessing /// \brief Method of optimal threshold value calculation. enum class threshold_optimal_value { otsu ///< \todo TODO }; /// \ingroup ImageProcessing /// \brief TODO enum class threshold_truncate_mode { threshold, ///< \todo TODO zero ///< \todo TODO }; enum class threshold_adaptive_method { mean, gaussian }; /// \ingroup ImageProcessing /// \brief Applies fixed threshold to each pixel of image view. /// Performs image binarization by thresholding channel value of each /// pixel of given image view. /// \param src_view - TODO /// \param dst_view - TODO /// \param threshold_value - TODO /// \param max_value - TODO /// \param threshold_direction - if regular, values greater than threshold_value are /// set to max_value else set to 0; if inverse, values greater than threshold_value are /// set to 0 else set to max_value. template <typename SrcView, typename DstView> void threshold_binary( SrcView const& src_view, DstView const& dst_view, typename channel_type<DstView>::type threshold_value, typename channel_type<DstView>::type max_value, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using source_channel_t = typename channel_type<SrcView>::type; using result_channel_t = typename channel_type<DstView>::type; if (direction == threshold_direction::regular) { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value, max_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? max_value : 0; }); } else { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value, max_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? 0 : max_value; }); } } /// \ingroup ImageProcessing /// \brief Applies fixed threshold to each pixel of image view. /// Performs image binarization by thresholding channel value of each /// pixel of given image view. /// This variant of threshold_binary automatically deduces maximum value for each channel /// of pixel based on channel type. /// If direction is regular, values greater than threshold_value will be set to maximum /// numeric limit of channel else 0. /// If direction is inverse, values greater than threshold_value will be set to 0 else maximum /// numeric limit of channel. template <typename SrcView, typename DstView> void threshold_binary( SrcView const& src_view, DstView const& dst_view, typename channel_type<DstView>::type threshold_value, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using result_channel_t = typename channel_type<DstView>::type; result_channel_t max_value = (std::numeric_limits<result_channel_t>::max)(); threshold_binary(src_view, dst_view, threshold_value, max_value, direction); } /// \ingroup ImageProcessing /// \brief Applies truncating threshold to each pixel of image view. /// Takes an image view and performs truncating threshold operation on each chennel. /// If mode is threshold and direction is regular: /// values greater than threshold_value will be set to threshold_value else no change /// If mode is threshold and direction is inverse: /// values less than or equal to threshold_value will be set to threshold_value else no change /// If mode is zero and direction is regular: /// values less than or equal to threshold_value will be set to 0 else no change /// If mode is zero and direction is inverse: /// values more than threshold_value will be set to 0 else no change template <typename SrcView, typename DstView> void threshold_truncate( SrcView const& src_view, DstView const& dst_view, typename channel_type<DstView>::type threshold_value, threshold_truncate_mode mode = threshold_truncate_mode::threshold, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using source_channel_t = typename channel_type<SrcView>::type; using result_channel_t = typename channel_type<DstView>::type; std::function<result_channel_t(source_channel_t)> threshold_logic; if (mode == threshold_truncate_mode::threshold) { if (direction == threshold_direction::regular) { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? threshold_value : px; }); } else { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? px : threshold_value; }); } } else { if (direction == threshold_direction::regular) { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? px : 0; }); } else { detail::threshold_impl<source_channel_t, result_channel_t>(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? 0 : px; }); } } } namespace detail{ template <typename SrcView, typename DstView> void otsu_impl(SrcView const& src_view, DstView const& dst_view, threshold_direction direction) { //deciding output channel type and creating functor using source_channel_t = typename channel_type<SrcView>::type; std::array<std::size_t, 256> histogram{}; //initial value of min is set to maximum possible value to compare histogram data //initial value of max is set to minimum possible value to compare histogram data auto min = (std::numeric_limits<source_channel_t>::max)(), max = (std::numeric_limits<source_channel_t>::min)(); if (sizeof(source_channel_t) > 1 \|\| std::is_signed<source_channel_t>::value) { //iterate over the image to find the min and max pixel values for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { if (src_it[x] < min) min = src_it[x]; if (src_it[x] > min) min = src_it[x]; } } //making histogram for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { histogram[((src_it[x] - min) * 255) / (max - min)]++; } } } else { //making histogram for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { histogram[src_it[x]]++; } } } //histData = histogram data //sum = total (background + foreground) //sumB = sum background //wB = weight background //wf = weight foreground //varMax = tracking the maximum known value of between class variance //mB = mu background //mF = mu foreground //varBeetween = between class variance //http://www.labbookpages.co.uk/software/imgProc/otsuThreshold.html //https://www.ipol.im/pub/art/2016/158/ std::ptrdiff_t total_pixel = src_view.height() * src_view.width(); std::ptrdiff_t sum_total = 0, sum_back = 0; std::size_t weight_back = 0, weight_fore = 0, threshold = 0; double var_max = 0, mean_back, mean_fore, var_intra_class; for (std::size_t t = 0; t < 256; t++) { sum_total += t * histogram[t]; } for (int t = 0; t < 256; t++) { weight_back += histogram[t]; // Weight Background if (weight_back == 0) continue; weight_fore = total_pixel - weight_back; // Weight Foreground if (weight_fore == 0) break; sum_back += t * histogram[t]; mean_back = sum_back / weight_back; // Mean Background mean_fore = (sum_total - sum_back) / weight_fore; // Mean Foreground // Calculate Between Class Variance var_intra_class = weight_back * weight_fore * (mean_back - mean_fore) * (mean_back - mean_fore); // Check if new maximum found if (var_intra_class > var_max) { var_max = var_intra_class; threshold = t; } } if (sizeof(source_channel_t) > 1 && std::is_unsigned<source_channel_t>::value) { threshold_binary(src_view, dst_view, (threshold * (max - min) / 255) + min, direction); } else { threshold_binary(src_view, dst_view, threshold, direction); } } } //namespace detail template <typename SrcView, typename DstView> void threshold_optimal ( SrcView const& src_view, DstView const& dst_view, threshold_optimal_value mode = threshold_optimal_value::otsu, threshold_direction direction = threshold_direction::regular ) { if (mode == threshold_optimal_value::otsu) { for (std::size_t i = 0; i < src_view.num_channels(); i++) { detail::otsu_impl (nth_channel_view(src_view, i), nth_channel_view(dst_view, i), direction); } } } namespace detail { template < typename SourceChannelT, typename ResultChannelT, typename SrcView, typename DstView, typename Operator > void adaptive_impl ( SrcView const& src_view, SrcView const& convolved_view, DstView const& dst_view, Operator const& threshold_op ) { //template argument validation gil_function_requires<ImageViewConcept<SrcView>>(); gil_function_requires<MutableImageViewConcept<DstView>>(); static_assert(color_spaces_are_compatible < typename color_space_type<SrcView>::type, typename color_space_type<DstView>::type >::value, "Source and destination views must have pixels with the same color space"); //iterate over the image checking each pixel value for the threshold for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); typename SrcView::x_iterator convolved_it = convolved_view.row_begin(y); typename DstView::x_iterator dst_it = dst_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { static_transform(src_it[x], convolved_it[x], dst_it[x], threshold_op); } } } } //namespace boost::gil::detail template <typename SrcView, typename DstView> void threshold_adaptive ( SrcView const& src_view, DstView const& dst_view, typename channel_type<DstView>::type max_value, std::size_t kernel_size, threshold_adaptive_method method = threshold_adaptive_method::mean, threshold_direction direction = threshold_direction::regular, typename channel_type<DstView>::type constant = 0 ) { BOOST_ASSERT_MSG((kernel_size % 2 != 0), "Kernel size must be an odd number"); typedef typename channel_type<SrcView>::type source_channel_t; typedef typename channel_type<DstView>::type result_channel_t; image<typename SrcView::value_type> temp_img(src_view.width(), src_view.height()); typename image<typename SrcView::value_type>::view_t temp_view = view(temp_img); SrcView temp_conv(temp_view); if (method == threshold_adaptive_method::mean) { std::vector<float> mean_kernel_values(kernel_size, 1.0f/kernel_size); kernel_1d<float> kernel(mean_kernel_values.begin(), kernel_size, kernel_size/2); detail::convolve_1d < pixel<float, typename SrcView::value_type::layout_t> >(src_view, kernel, temp_view); } else if (method == threshold_adaptive_method::gaussian) { detail::kernel_2d<float> kernel = generate_gaussian_kernel(kernel_size, 1.0); convolve_2d(src_view, kernel, temp_view); } if (direction == threshold_direction::regular) { detail::adaptive_impl<source_channel_t, result_channel_t>(src_view, temp_conv, dst_view, [max_value, constant](source_channel_t px, source_channel_t threshold) -> result_channel_t { return px > (threshold - constant) ? max_value : 0; }); } else { detail::adaptive_impl<source_channel_t, result_channel_t>(src_view, temp_conv, dst_view, [max_value, constant](source_channel_t px, source_channel_t threshold) -> result_channel_t { return px > (threshold - constant) ? 0 : max_value; }); } } template <typename SrcView, typename DstView> void threshold_adaptive ( SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size, threshold_adaptive_method method = threshold_adaptive_method::mean, threshold_direction direction = threshold_direction::regular, int constant = 0 ) { //deciding output channel type and creating functor typedef typename channel_type<DstView>::type result_channel_t; result_channel_t max_value = (std::numeric_limits<result_channel_t>::max)(); threshold_adaptive(src_view, dst_view, max_value, kernel_size, method, direction, constant); } /// @} }} //namespace boost::gil #endif //BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP PK��p�[u�H(��H(��image_processing/numeric.hppnu��[��// // Copyright 2019 Olzhas Zhumabek <anonymous.from.applecity@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_NUMERIC_HPP #define BOOST_GIL_IMAGE_PROCESSING_NUMERIC_HPP #include <boost/gil/extension/numeric/kernel.hpp> #include <boost/gil/extension/numeric/convolve.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/math.hpp> // fixes ambigious call to std::abs, https://stackoverflow.com/a/30084734/4593721 #include <cstdlib> #include <cmath> namespace boost { namespace gil { /// \defgroup ImageProcessingMath /// \brief Math operations for IP algorithms /// /// This is mostly handful of mathemtical operations that are required by other /// image processing algorithms /// /// \brief Normalized cardinal sine /// \ingroup ImageProcessingMath /// /// normalized_sinc(x) = sin(pi * x) / (pi * x) /// inline double normalized_sinc(double x) { return std::sin(x * boost::gil::detail::pi) / (x * boost::gil::detail::pi); } /// \brief Lanczos response at point x /// \ingroup ImageProcessingMath /// /// Lanczos response is defined as: /// x == 0: 1 /// -a < x && x < a: 0 /// otherwise: normalized_sinc(x) / normalized_sinc(x / a) inline double lanczos(double x, std::ptrdiff_t a) { // means == but <= avoids compiler warning if (0 <= x && x <= 0) return 1; if (-a < x && x < a) return normalized_sinc(x) / normalized_sinc(x / static_cast<double>(a)); return 0; } #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4244) // 'argument': conversion from 'const Channel' to 'BaseChannelValue', possible loss of data #endif inline void compute_tensor_entries( boost::gil::gray16s_view_t dx, boost::gil::gray16s_view_t dy, boost::gil::gray32f_view_t m11, boost::gil::gray32f_view_t m12_21, boost::gil::gray32f_view_t m22) { for (std::ptrdiff_t y = 0; y < dx.height(); ++y) { for (std::ptrdiff_t x = 0; x < dx.width(); ++x) { auto dx_value = dx(x, y); auto dy_value = dy(x, y); m11(x, y) = dx_value * dx_value; m12_21(x, y) = dx_value * dy_value; m22(x, y) = dy_value * dy_value; } } } #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif /// \brief Generate mean kernel /// \ingroup ImageProcessingMath /// /// Fills supplied view with normalized mean /// in which all entries will be equal to /// \code 1 / (dst.size()) \endcode template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_normalized_mean(std::size_t side_length) { if (side_length % 2 != 1) throw std::invalid_argument("kernel dimensions should be odd and equal"); const float entry = 1.0f / static_cast<float>(side_length * side_length); detail::kernel_2d<T, Allocator> result(side_length, side_length / 2, side_length / 2); for (auto& cell: result) { cell = entry; } return result; } /// \brief Generate kernel with all 1s /// \ingroup ImageProcessingMath /// /// Fills supplied view with 1s (ones) template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_unnormalized_mean(std::size_t side_length) { if (side_length % 2 != 1) throw std::invalid_argument("kernel dimensions should be odd and equal"); detail::kernel_2d<T, Allocator> result(side_length, side_length / 2, side_length / 2); for (auto& cell: result) { cell = 1.0f; } return result; } /// \brief Generate Gaussian kernel /// \ingroup ImageProcessingMath /// /// Fills supplied view with values taken from Gaussian distribution. See /// https://en.wikipedia.org/wiki/Gaussian_blur template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_gaussian_kernel(std::size_t side_length, double sigma) { if (side_length % 2 != 1) throw std::invalid_argument("kernel dimensions should be odd and equal"); const double denominator = 2 * boost::gil::detail::pi * sigma * sigma; auto middle = side_length / 2; std::vector<T, Allocator> values(side_length * side_length); for (std::size_t y = 0; y < side_length; ++y) { for (std::size_t x = 0; x < side_length; ++x) { const auto delta_x = middle > x ? middle - x : x - middle; const auto delta_y = middle > y ? middle - y : y - middle; const double power = (delta_x * delta_x + delta_y * delta_y) / (2 * sigma * sigma); const double nominator = std::exp(-power); const float value = static_cast<float>(nominator / denominator); values[y * side_length + x] = value; } } return detail::kernel_2d<T, Allocator>(values.begin(), values.size(), middle, middle); } /// \brief Generates Sobel operator in horizontal direction /// \ingroup ImageProcessingMath /// /// Generates a kernel which will represent Sobel operator in /// horizontal direction of specified degree (no need to convolve multiple times /// to obtain the desired degree). /// https://www.researchgate.net/publication/239398674_An_Isotropic_3_3_Image_Gradient_Operator template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_dx_sobel(unsigned int degree = 1) { switch (degree) { case 0: { return detail::get_identity_kernel<T, Allocator>(); } case 1: { detail::kernel_2d<T, Allocator> result(3, 1, 1); std::copy(detail::dx_sobel.begin(), detail::dx_sobel.end(), result.begin()); return result; } default: throw std::logic_error("not supported yet"); } //to not upset compiler throw std::runtime_error("unreachable statement"); } /// \brief Generate Scharr operator in horizontal direction /// \ingroup ImageProcessingMath /// /// Generates a kernel which will represent Scharr operator in /// horizontal direction of specified degree (no need to convolve multiple times /// to obtain the desired degree). /// https://www.researchgate.net/profile/Hanno_Scharr/publication/220955743_Optimal_Filters_for_Extended_Optical_Flow/links/004635151972eda98f000000/Optimal-Filters-for-Extended-Optical-Flow.pdf template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_dx_scharr(unsigned int degree = 1) { switch (degree) { case 0: { return detail::get_identity_kernel<T, Allocator>(); } case 1: { detail::kernel_2d<T, Allocator> result(3, 1, 1); std::copy(detail::dx_scharr.begin(), detail::dx_scharr.end(), result.begin()); return result; } default: throw std::logic_error("not supported yet"); } //to not upset compiler throw std::runtime_error("unreachable statement"); } /// \brief Generates Sobel operator in vertical direction /// \ingroup ImageProcessingMath /// /// Generates a kernel which will represent Sobel operator in /// vertical direction of specified degree (no need to convolve multiple times /// to obtain the desired degree). /// https://www.researchgate.net/publication/239398674_An_Isotropic_3_3_Image_Gradient_Operator template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_dy_sobel(unsigned int degree = 1) { switch (degree) { case 0: { return detail::get_identity_kernel<T, Allocator>(); } case 1: { detail::kernel_2d<T, Allocator> result(3, 1, 1); std::copy(detail::dy_sobel.begin(), detail::dy_sobel.end(), result.begin()); return result; } default: throw std::logic_error("not supported yet"); } //to not upset compiler throw std::runtime_error("unreachable statement"); } /// \brief Generate Scharr operator in vertical direction /// \ingroup ImageProcessingMath /// /// Generates a kernel which will represent Scharr operator in /// vertical direction of specified degree (no need to convolve multiple times /// to obtain the desired degree). /// https://www.researchgate.net/profile/Hanno_Scharr/publication/220955743_Optimal_Filters_for_Extended_Optical_Flow/links/004635151972eda98f000000/Optimal-Filters-for-Extended-Optical-Flow.pdf template <typename T = float, typename Allocator = std::allocator<T>> inline detail::kernel_2d<T, Allocator> generate_dy_scharr(unsigned int degree = 1) { switch (degree) { case 0: { return detail::get_identity_kernel<T, Allocator>(); } case 1: { detail::kernel_2d<T, Allocator> result(3, 1, 1); std::copy(detail::dy_scharr.begin(), detail::dy_scharr.end(), result.begin()); return result; } default: throw std::logic_error("not supported yet"); } //to not upset compiler throw std::runtime_error("unreachable statement"); } /// \brief Compute xy gradient, and second order x and y gradients /// \ingroup ImageProcessingMath /// /// Hessian matrix is defined as a matrix of partial derivates /// for 2d case, it is [[ddxx, dxdy], [dxdy, ddyy]. /// d stands for derivative, and x or y stand for direction. /// For example, dx stands for derivative (gradient) in horizontal /// direction, and ddxx means second order derivative in horizon direction /// https://en.wikipedia.org/wiki/Hessian_matrix template <typename GradientView, typename OutputView> inline void compute_hessian_entries( GradientView dx, GradientView dy, OutputView ddxx, OutputView dxdy, OutputView ddyy) { auto sobel_x = generate_dx_sobel(); auto sobel_y = generate_dy_sobel(); detail::convolve_2d(dx, sobel_x, ddxx); detail::convolve_2d(dx, sobel_y, dxdy); detail::convolve_2d(dy, sobel_y, ddyy); } }} // namespace boost::gil #endif PK��p�[�jZ��image_processing/scaling.hppnu��[��// // Copyright 2019 Olzhas Zhumabek <anonymous.from.applecity@gmail.com> // // 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) // #ifndef BOOST_GIL_IMAGE_PROCESSING_SCALING_HPP #define BOOST_GIL_IMAGE_PROCESSING_SCALING_HPP #include <boost/gil/image_view.hpp> #include <boost/gil/rgb.hpp> #include <boost/gil/pixel.hpp> #include <boost/gil/image_processing/numeric.hpp> namespace boost { namespace gil { /// \defgroup ScalingAlgorithms /// \brief Algorthims suitable for rescaling /// /// These algorithms are used to improve image quality after image resizing is made. /// /// \defgroup DownScalingAlgorithms /// \ingroup ScalingAlgorithms /// \brief Algorthims suitable for downscaling /// /// These algorithms provide best results when used for downscaling. Using for upscaling will /// probably provide less than good results. /// /// \brief a single step of lanczos downscaling /// \ingroup DownScalingAlgorithms /// /// Use this algorithm to scale down source image into a smaller image with reasonable quality. /// Do note that having a look at the output once is a good idea, since it might have ringing /// artifacts. template <typename ImageView> void lanczos_at( ImageView input_view, ImageView output_view, typename ImageView::x_coord_t source_x, typename ImageView::y_coord_t source_y, typename ImageView::x_coord_t target_x, typename ImageView::y_coord_t target_y, std::ptrdiff_t a) { using x_coord_t = typename ImageView::x_coord_t; using y_coord_t = typename ImageView::y_coord_t; using pixel_t = typename std::remove_reference<decltype(std::declval<ImageView>()(0, 0))>::type; // C++11 doesn't allow auto in lambdas using channel_t = typename std::remove_reference < decltype(std::declval<pixel_t>().at(std::integral_constant<int, 0>{})) >::type; pixel_t result_pixel; static_transform(result_pixel, result_pixel, [](channel_t) { return static_cast<channel_t>(0); }); auto x_zero = static_cast<x_coord_t>(0); auto x_one = static_cast<x_coord_t>(1); auto y_zero = static_cast<y_coord_t>(0); auto y_one = static_cast<y_coord_t>(1); for (y_coord_t y_i = (std::max)(source_y - static_cast<y_coord_t>(a) + y_one, y_zero); y_i <= (std::min)(source_y + static_cast<y_coord_t>(a), input_view.height() - y_one); ++y_i) { for (x_coord_t x_i = (std::max)(source_x - static_cast<x_coord_t>(a) + x_one, x_zero); x_i <= (std::min)(source_x + static_cast<x_coord_t>(a), input_view.width() - x_one); ++x_i) { double lanczos_response = lanczos(source_x - x_i, a) * lanczos(source_y - y_i, a); auto op = [lanczos_response](channel_t prev, channel_t next) { return static_cast<channel_t>(prev + next * lanczos_response); }; static_transform(result_pixel, input_view(source_x, source_y), result_pixel, op); } } output_view(target_x, target_y) = result_pixel; } /// \brief Complete Lanczos algorithm /// \ingroup DownScalingAlgorithms /// /// This algorithm does full pass over resulting image and convolves pixels from /// original image. Do note that it might be a good idea to have a look at test /// output as there might be ringing artifacts. /// Based on wikipedia article: /// https://en.wikipedia.org/wiki/Lanczos_resampling /// with standardinzed cardinal sin (sinc) template <typename ImageView> void scale_lanczos(ImageView input_view, ImageView output_view, std::ptrdiff_t a) { double scale_x = (static_cast<double>(output_view.width())) / static_cast<double>(input_view.width()); double scale_y = (static_cast<double>(output_view.height())) / static_cast<double>(input_view.height()); using x_coord_t = typename ImageView::x_coord_t; using y_coord_t = typename ImageView::y_coord_t; for (y_coord_t y = 0; y < output_view.height(); ++y) { for (x_coord_t x = 0; x < output_view.width(); ++x) { lanczos_at(input_view, output_view, x / scale_x, y / scale_y, x, y, a); } } } }} // namespace boost::gil #endif PK��p�[S"��position_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_POSITION_ITERATOR_HPP #define BOOST_GIL_POSITION_ITERATOR_HPP #include <boost/gil/locator.hpp> #include <boost/iterator/iterator_facade.hpp> #include <type_traits> namespace boost { namespace gil { /// \defgroup PixelIteratorModelVirtual position_iterator /// \ingroup PixelIteratorModel /// \brief An iterator that remembers its current X,Y position and invokes a function object with it upon dereferencing. /// Models PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept. Used to create virtual image views. /// \brief An iterator that remembers its current X,Y position and invokes a function object with it upon dereferencing. /// Used to create virtual image views. /// Models: StepIteratorConcept, PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept /// \ingroup PixelIteratorModelVirtual PixelBasedModel /// \tparam Deref A function object that given a point returns a pixel reference. Models PixelDereferenceAdaptorConcept /// \tparam Dim Dimension to advance along template <typename Deref, int Dim> struct position_iterator : public iterator_facade<position_iterator<Deref,Dim>, typename Deref::value_type, std::random_access_iterator_tag, typename Deref::reference, typename Deref::argument_type::template axis<Dim>::coord_t> { using parent_t = iterator_facade<position_iterator<Deref,Dim>, typename Deref::value_type, std::random_access_iterator_tag, typename Deref::reference, typename Deref::argument_type::template axis<Dim>::coord_t>; using difference_type = typename parent_t::difference_type; using reference = typename parent_t::reference; using point_t = typename Deref::argument_type; position_iterator() {} position_iterator(const point_t& p, const point_t& step, const Deref& d) : _p(p), _step(step), _d(d) {} position_iterator(const position_iterator& p) : _p(p._p), _step(p._step), _d(p._d) {} template <typename D> position_iterator(const position_iterator<D,Dim>& p) : _p(p._p), _step(p._step), _d(p._d) {} position_iterator& operator=(const position_iterator& p) { _p=p._p; _d=p._d; _step=p._step; return this; } const point_t& pos() const { return _p; } const point_t& step() const { return _step; } const Deref& deref_fn() const { return _d; } void set_step(difference_type s) { _step[Dim]=s; } /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { point_t p=_p; p[Dim]+=d_step[Dim]; return _d(p); } private: point_t _p, _step; Deref _d; template <typename DE, int DI> friend struct position_iterator; friend class boost::iterator_core_access; reference dereference() const { return _d(_p); } void increment() { _p[Dim]+=_step[Dim]; } void decrement() { _p[Dim]-=_step[Dim]; } void advance(difference_type d) { _p[Dim]+=d_step[Dim]; } difference_type distance_to(const position_iterator& it) const { return (it._p[Dim]-_p[Dim])/_step[Dim]; } bool equal(const position_iterator& it) const { return _p==it._p; } }; template <typename Deref,int Dim> struct const_iterator_type<position_iterator<Deref,Dim> > { using type = position_iterator<typename Deref::const_t,Dim>; }; template <typename Deref, int Dim> struct iterator_is_mutable<position_iterator<Deref, Dim>> : std::integral_constant<bool, Deref::is_mutable> { }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename Deref,int Dim> struct color_space_type<position_iterator<Deref,Dim> > : public color_space_type<typename Deref::value_type> {}; template <typename Deref,int Dim> struct channel_mapping_type<position_iterator<Deref,Dim> > : public channel_mapping_type<typename Deref::value_type> {}; template <typename Deref,int Dim> struct is_planar<position_iterator<Deref, Dim>> : std::false_type {}; template <typename Deref,int Dim> struct channel_type<position_iterator<Deref,Dim> > : public channel_type<typename Deref::value_type> {}; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename Deref,int Dim> struct dynamic_x_step_type<position_iterator<Deref,Dim> > { using type = position_iterator<Deref,Dim>; }; } } // namespace boost::gil #endif PK��p�[�4��#��#��packed_pixel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_PACKED_PIXEL_HPP #define BOOST_GIL_PACKED_PIXEL_HPP #include <boost/gil/pixel.hpp> #include <boost/gil/detail/mp11.hpp> #include <functional> #include <type_traits> namespace boost { namespace gil { /// A model of a heterogeneous pixel whose channels are bit ranges. /// For example 16-bit RGB in '565' format. /// \defgroup ColorBaseModelPackedPixel packed_pixel /// \ingroup ColorBaseModel /// \brief A heterogeneous color base whose elements are reference proxies to channels in a pixel. Models ColorBaseValueConcept. This class is used to model packed pixels, such as 16-bit packed RGB. /// \defgroup PixelModelPackedPixel packed_pixel /// \ingroup PixelModel /// \brief A heterogeneous pixel used to represent packed pixels with non-byte-aligned channels. Models PixelValueConcept /// /// Example: /// \code /// using rgb565_pixel_t = packed_pixel_type<uint16_t, mp11::mp_list-c<unsigned,5,6,5>, rgb_layout_t>::type; /// static_assert(sizeof(rgb565_pixel_t) == 2, ""); /// /// rgb565_pixel_t r565; /// get_color(r565,red_t()) = 31; /// get_color(r565,green_t()) = 63; /// get_color(r565,blue_t()) = 31; /// assert(r565 == rgb565_pixel_t((uint16_t)0xFFFF)); /// \endcode /// \ingroup ColorBaseModelPackedPixel PixelModelPackedPixel PixelBasedModel /// \brief Heterogeneous pixel value whose channel references can be constructed from the pixel bitfield and their index. Models ColorBaseValueConcept, PixelValueConcept, PixelBasedConcept /// Typical use for this is a model of a packed pixel (like 565 RGB) /// \tparam BitField Type that holds the bits of the pixel. Typically an integral type, like std::uint16_t. /// \tparam ChannelRefs MP11 list whose elements are packed channels. They must be constructible from BitField. GIL uses packed_channel_reference /// \tparam Layout defining the color space and ordering of the channels. Example value: rgb_layout_t template <typename BitField, typename ChannelRefs, typename Layout> struct packed_pixel { BitField _bitfield{0}; // TODO: Make private using layout_t = Layout; using value_type = packed_pixel<BitField, ChannelRefs, Layout>; using reference = value_type&; using const_reference = value_type const&; static constexpr bool is_mutable = channel_traits<mp11::mp_front<ChannelRefs>>::is_mutable; packed_pixel() = default; explicit packed_pixel(const BitField& bitfield) : _bitfield(bitfield) {} // Construct from another compatible pixel type packed_pixel(const packed_pixel& p) : _bitfield(p._bitfield) {} template <typename Pixel> packed_pixel(Pixel const& p, typename std::enable_if<is_pixel<Pixel>::value>::type /dummy/ = nullptr) { check_compatible<Pixel>(); static_copy(p, this); } packed_pixel(int chan0, int chan1) : _bitfield(0) { static_assert(num_channels<packed_pixel>::value == 2, ""); gil::at_c<0>(this) = chan0; gil::at_c<1>(this) = chan1; } packed_pixel(int chan0, int chan1, int chan2) : _bitfield(0) { static_assert(num_channels<packed_pixel>::value == 3, ""); gil::at_c<0>(this) = chan0; gil::at_c<1>(this) = chan1; gil::at_c<2>(this) = chan2; } packed_pixel(int chan0, int chan1, int chan2, int chan3) : _bitfield(0) { static_assert(num_channels<packed_pixel>::value == 4, ""); gil::at_c<0>(this) = chan0; gil::at_c<1>(this) = chan1; gil::at_c<2>(this) = chan2; gil::at_c<3>(this) = chan3; } packed_pixel(int chan0, int chan1, int chan2, int chan3, int chan4) : _bitfield(0) { static_assert(num_channels<packed_pixel>::value == 5, ""); gil::at_c<0>(this) = chan0; gil::at_c<1>(this) = chan1; gil::at_c<2>(this) = chan2; gil::at_c<3>(this) = chan3; gil::at_c<4>(this) = chan4; } auto operator=(packed_pixel const& p) -> packed_pixel& { _bitfield = p._bitfield; return this; } template <typename Pixel> auto operator=(Pixel const& p) -> packed_pixel& { assign(p, is_pixel<Pixel>()); return this; } template <typename Pixel> bool operator==(Pixel const& p) const { return equal(p, is_pixel<Pixel>()); } template <typename Pixel> bool operator!=(Pixel const& p) const { return !(this==p); } private: template <typename Pixel> static void check_compatible() { gil_function_requires<PixelsCompatibleConcept<Pixel, packed_pixel>>(); } template <typename Pixel> void assign(Pixel const& p, std::true_type) { check_compatible<Pixel>(); static_copy(p, this); } template <typename Pixel> bool equal(Pixel const& p, std::true_type) const { check_compatible<Pixel>(); return static_equal(this, p); } // Support for assignment/equality comparison of a channel with a grayscale pixel static void check_gray() { static_assert(std::is_same<typename Layout::color_space_t, gray_t>::value, ""); } template <typename Channel> void assign(Channel const& channel, std::false_type) { check_gray(); gil::at_c<0>(this) = channel; } template <typename Channel> bool equal (Channel const& channel, std::false_type) const { check_gray(); return gil::at_c<0>(this) == channel; } public: auto operator=(int channel) -> packed_pixel& { check_gray(); gil::at_c<0>(this) = channel; return this; } bool operator==(int channel) const { check_gray(); return gil::at_c<0>(this) == channel; } }; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template <typename BitField, typename ChannelRefs, typename Layout, int K> struct kth_element_type<packed_pixel<BitField, ChannelRefs, Layout>, K> { using type = typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::value_type; }; template <typename BitField, typename ChannelRefs, typename Layout, int K> struct kth_element_reference_type<packed_pixel<BitField, ChannelRefs, Layout>, K> { using type = typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::reference; }; template <typename BitField, typename ChannelRefs, typename Layout, int K> struct kth_element_const_reference_type<packed_pixel<BitField, ChannelRefs, Layout>, K> { using type = typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::const_reference; }; template <int K, typename P, typename C, typename L> inline auto at_c(packed_pixel<P, C, L>& p) -> typename kth_element_reference_type<packed_pixel<P, C, L>, K>::type { return typename kth_element_reference_type < packed_pixel<P, C, L>, K >::type{&p._bitfield}; } template <int K, typename P, typename C, typename L> inline auto at_c(const packed_pixel<P, C, L>& p) -> typename kth_element_const_reference_type<packed_pixel<P, C, L>, K>::type { return typename kth_element_const_reference_type < packed_pixel<P, C, L>, K>::type{&p._bitfield}; } ///////////////////////////// // PixelConcept ///////////////////////////// // Metafunction predicate that flags packed_pixel as a model of PixelConcept. // Required by PixelConcept template <typename BitField, typename ChannelRefs, typename Layout> struct is_pixel<packed_pixel<BitField, ChannelRefs, Layout>> : std::true_type {}; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename P, typename C, typename Layout> struct color_space_type<packed_pixel<P, C, Layout>> { using type = typename Layout::color_space_t; }; template <typename P, typename C, typename Layout> struct channel_mapping_type<packed_pixel<P, C, Layout>> { using type = typename Layout::channel_mapping_t; }; template <typename P, typename C, typename Layout> struct is_planar<packed_pixel<P, C, Layout>> : std::false_type {}; //////////////////////////////////////////////////////////////////////////////// /// Support for interleaved iterators over packed pixel //////////////////////////////////////////////////////////////////////////////// /// \defgroup PixelIteratorModelPackedInterleavedPtr Pointer to packed_pixel<P,CR,Layout> /// \ingroup PixelIteratorModel /// \brief Iterators over interleaved pixels. /// The pointer packed_pixel<P,CR,Layout> is used as an iterator over interleaved /// pixels of packed format. /// Models PixelIteratorConcept, HasDynamicXStepTypeConcept, MemoryBasedIteratorConcept template <typename P, typename C, typename L> struct iterator_is_mutable<packed_pixel<P, C, L>> : std::integral_constant<bool, packed_pixel<P, C, L>::is_mutable> {}; template <typename P, typename C, typename L> struct iterator_is_mutable<const packed_pixel<P, C, L>> : std::false_type {}; }} // namespace boost::gil #endif PK��p�[PHC7��7��bit_aligned_pixel_reference.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_BIT_ALIGNED_PIXEL_REFERENCE_HPP #define BOOST_GIL_BIT_ALIGNED_PIXEL_REFERENCE_HPP #include <boost/gil/pixel.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <functional> #include <type_traits> namespace boost { namespace gil { /// A model of a heterogeneous pixel that is not byte aligned. /// Examples are bitmap (1-bit pixels) or 6-bit RGB (222). ///////////////////////////// // bit_range // // Represents a range of bits that can span multiple consecutive bytes. The range has a size fixed at compile time, but the offset is specified at run time. ///////////////////////////// template <int RangeSize, bool IsMutable> class bit_range { public: using byte_t = mp11::mp_if_c<IsMutable, unsigned char, unsigned char const>; using difference_type = std::ptrdiff_t; template <int RS, bool M> friend class bit_range; private: byte_t* _current_byte; // the starting byte of the bit range int _bit_offset; // offset from the beginning of the current byte. 0<=_bit_offset<=7 public: bit_range() : _current_byte(nullptr), _bit_offset(0) {} bit_range(byte_t* current_byte, int bit_offset) : _current_byte(current_byte) , _bit_offset(bit_offset) { BOOST_ASSERT(bit_offset >= 0 && bit_offset < 8); } bit_range(const bit_range& br) : _current_byte(br._current_byte), _bit_offset(br._bit_offset) {} template <bool M> bit_range(const bit_range<RangeSize,M>& br) : _current_byte(br._current_byte), _bit_offset(br._bit_offset) {} bit_range& operator=(const bit_range& br) { _current_byte = br._current_byte; _bit_offset=br._bit_offset; return this; } bool operator==(const bit_range& br) const { return _current_byte==br._current_byte && _bit_offset==br._bit_offset; } bit_range& operator++() { _current_byte += (_bit_offset+RangeSize) / 8; _bit_offset = (_bit_offset+RangeSize) % 8; return this; } bit_range& operator--() { bit_advance(-RangeSize); return this; } void bit_advance(difference_type num_bits) { int new_offset = int(_bit_offset+num_bits); _current_byte += new_offset / 8; _bit_offset = new_offset % 8; if (_bit_offset<0) { _bit_offset+=8; --_current_byte; } } difference_type bit_distance_to(const bit_range& b) const { return (b.current_byte() - current_byte())8 + b.bit_offset()-bit_offset(); } byte_t* current_byte() const { return _current_byte; } int bit_offset() const { return _bit_offset; } }; /// \defgroup ColorBaseModelNonAlignedPixel bit_aligned_pixel_reference /// \ingroup ColorBaseModel /// \brief A heterogeneous color base representing pixel that may not be byte aligned, i.e. it may correspond to a bit range that does not start/end at a byte boundary. Models ColorBaseConcept. /// /// \defgroup PixelModelNonAlignedPixel bit_aligned_pixel_reference /// \ingroup PixelModel /// \brief A heterogeneous pixel reference used to represent non-byte-aligned pixels. Models PixelConcept /// /// Example: /// \code /// unsigned char data=0; /// /// // A mutable reference to a 6-bit BGR pixel in "123" format (1 bit for red, 2 bits for green, 3 bits for blue) /// using rgb123_ref_t = bit_aligned_pixel_reference<unsigned char, mp11::mp_list_c<int,1,2,3>, rgb_layout_t, true> const; /// /// // create the pixel reference at bit offset 2 /// // (i.e. red = [2], green = [3,4], blue = [5,6,7] bits) /// rgb123_ref_t ref(&data, 2); /// get_color(ref, red_t()) = 1; /// assert(data == 0x04); /// get_color(ref, green_t()) = 3; /// assert(data == 0x1C); /// get_color(ref, blue_t()) = 7; /// assert(data == 0xFC); /// \endcode /// /// \ingroup ColorBaseModelNonAlignedPixel PixelModelNonAlignedPixel PixelBasedModel /// \brief Heterogeneous pixel reference corresponding to non-byte-aligned bit range. Models ColorBaseConcept, PixelConcept, PixelBasedConcept /// /// \tparam BitField /// \tparam ChannelBitSizes Boost.MP11-compatible list of integral types defining the number of bits for each channel. For example, for 565RGB, mp_list_c<int,5,6,5> /// \tparam Layout /// \tparam IsMutable template <typename BitField, typename ChannelBitSizes, typename Layout, bool IsMutable> struct bit_aligned_pixel_reference { static constexpr int bit_size = mp11::mp_fold < ChannelBitSizes, std::integral_constant<int, 0>, mp11::mp_plus >::value; using bit_range_t = boost::gil::bit_range<bit_size,IsMutable>; using bitfield_t = BitField; using data_ptr_t = mp11::mp_if_c<IsMutable, unsigned char, const unsigned char>; using layout_t = Layout; using value_type = typename packed_pixel_type<bitfield_t,ChannelBitSizes,Layout>::type; using reference = const bit_aligned_pixel_reference<BitField, ChannelBitSizes, Layout, IsMutable>; using const_reference = bit_aligned_pixel_reference<BitField,ChannelBitSizes,Layout,false> const; static constexpr bool is_mutable = IsMutable; bit_aligned_pixel_reference(){} bit_aligned_pixel_reference(data_ptr_t data_ptr, int bit_offset) : _bit_range(data_ptr, bit_offset) {} explicit bit_aligned_pixel_reference(const bit_range_t& bit_range) : _bit_range(bit_range) {} template <bool IsMutable2> bit_aligned_pixel_reference(const bit_aligned_pixel_reference<BitField,ChannelBitSizes,Layout,IsMutable2>& p) : _bit_range(p._bit_range) {} // Grayscale references can be constructed from the channel reference explicit bit_aligned_pixel_reference(typename kth_element_type<bit_aligned_pixel_reference,0>::type const channel0) : _bit_range(static_cast<data_ptr_t>(&channel0), channel0.first_bit()) { static_assert(num_channels<bit_aligned_pixel_reference>::value == 1, ""); } // Construct from another compatible pixel type bit_aligned_pixel_reference(bit_aligned_pixel_reference const& p) : _bit_range(p._bit_range) {} // TODO: Why p by non-const reference? template <typename BF, typename CR> bit_aligned_pixel_reference(packed_pixel<BF, CR, Layout>& p) : _bit_range(static_cast<data_ptr_t>(&gil::at_c<0>(p)), gil::at_c<0>(p).first_bit()) { check_compatible<packed_pixel<BF, CR, Layout>>(); } auto operator=(bit_aligned_pixel_reference const& p) const -> bit_aligned_pixel_reference const& { static_copy(p, this); return this; } template <typename P> auto operator=(P const& p) const -> bit_aligned_pixel_reference const& { assign(p, is_pixel<P>()); return this; } template <typename P> bool operator==(P const& p) const { return equal(p, is_pixel<P>()); } template <typename P> bool operator!=(P const& p) const { return !(this==p); } auto operator->() const -> bit_aligned_pixel_reference const* { return this; } bit_range_t const& bit_range() const { return _bit_range; } private: mutable bit_range_t _bit_range; template <typename B, typename C, typename L, bool M> friend struct bit_aligned_pixel_reference; template <typename Pixel> static void check_compatible() { gil_function_requires<PixelsCompatibleConcept<Pixel,bit_aligned_pixel_reference> >(); } template <typename Pixel> void assign(Pixel const& p, std::true_type) const { check_compatible<Pixel>(); static_copy(p, this); } template <typename Pixel> bool equal(Pixel const& p, std::true_type) const { check_compatible<Pixel>(); return static_equal(this, p); } private: static void check_gray() { static_assert(std::is_same<typename Layout::color_space_t, gray_t>::value, ""); } template <typename Channel> void assign(Channel const& channel, std::false_type) const { check_gray(); gil::at_c<0>(this) = channel; } template <typename Channel> bool equal (Channel const& channel, std::false_type) const { check_gray(); return gil::at_c<0>(this) == channel; } }; ///////////////////////////// // ColorBasedConcept ///////////////////////////// template <typename BitField, typename ChannelBitSizes, typename L, bool IsMutable, int K> struct kth_element_type < bit_aligned_pixel_reference<BitField, ChannelBitSizes, L, IsMutable>, K > { using type = packed_dynamic_channel_reference < BitField, mp11::mp_at_c<ChannelBitSizes, K>::value, IsMutable > const; }; template <typename B, typename C, typename L, bool M, int K> struct kth_element_reference_type<bit_aligned_pixel_reference<B,C,L,M>, K> : public kth_element_type<bit_aligned_pixel_reference<B,C,L,M>, K> {}; template <typename B, typename C, typename L, bool M, int K> struct kth_element_const_reference_type<bit_aligned_pixel_reference<B,C,L,M>, K> : public kth_element_type<bit_aligned_pixel_reference<B,C,L,M>, K> {}; namespace detail { // returns sum of IntegralVector[0] ... IntegralVector[K-1] template <typename IntegralVector, int K> struct sum_k : mp11::mp_plus < sum_k<IntegralVector, K - 1>, typename mp11::mp_at_c<IntegralVector, K - 1>::type > {}; template <typename IntegralVector> struct sum_k<IntegralVector, 0> : std::integral_constant<int, 0> {}; } // namespace detail // at_c required by MutableColorBaseConcept template <int K, typename BitField, typename ChannelBitSizes, typename L, bool IsMutable> inline auto at_c(const bit_aligned_pixel_reference<BitField, ChannelBitSizes, L, IsMutable>& p) -> typename kth_element_reference_type<bit_aligned_pixel_reference<BitField, ChannelBitSizes, L, IsMutable>, K>::type { using pixel_t = bit_aligned_pixel_reference<BitField, ChannelBitSizes, L, IsMutable>; using channel_t = typename kth_element_reference_type<pixel_t, K>::type; using bit_range_t = typename pixel_t::bit_range_t; bit_range_t bit_range(p.bit_range()); bit_range.bit_advance(detail::sum_k<ChannelBitSizes, K>::value); return channel_t(bit_range.current_byte(), bit_range.bit_offset()); } ///////////////////////////// // PixelConcept ///////////////////////////// /// Metafunction predicate that flags bit_aligned_pixel_reference as a model of PixelConcept. Required by PixelConcept template <typename B, typename C, typename L, bool M> struct is_pixel<bit_aligned_pixel_reference<B, C, L, M> > : std::true_type {}; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename B, typename C, typename L, bool M> struct color_space_type<bit_aligned_pixel_reference<B, C, L, M>> { using type = typename L::color_space_t; }; template <typename B, typename C, typename L, bool M> struct channel_mapping_type<bit_aligned_pixel_reference<B, C, L, M>> { using type = typename L::channel_mapping_t; }; template <typename B, typename C, typename L, bool M> struct is_planar<bit_aligned_pixel_reference<B, C, L, M>> : std::false_type {}; ///////////////////////////// // pixel_reference_type ///////////////////////////// // Constructs a homogeneous bit_aligned_pixel_reference given a channel reference template <typename BitField, int NumBits, typename Layout> struct pixel_reference_type < packed_dynamic_channel_reference<BitField, NumBits, false> const, Layout, false, false > { private: using channel_bit_sizes_t = mp11::mp_repeat < mp11::mp_list<std::integral_constant<unsigned, NumBits>>, mp11::mp_size<typename Layout::color_space_t> >; public: using type = bit_aligned_pixel_reference<BitField, channel_bit_sizes_t, Layout, false>; }; // Same but for the mutable case. We cannot combine the mutable // and read-only cases because this triggers ambiguity template <typename BitField, int NumBits, typename Layout> struct pixel_reference_type < packed_dynamic_channel_reference<BitField, NumBits, true> const, Layout, false, true > { private: using channel_bit_sizes_t = mp11::mp_repeat < mp11::mp_list<std::integral_constant<unsigned, NumBits>>, mp11::mp_size<typename Layout::color_space_t> >; public: using type = bit_aligned_pixel_reference<BitField, channel_bit_sizes_t, Layout, true>; }; } } // namespace boost::gil namespace std { // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified. // swap with 'left bias': // - swap between proxy and anything // - swap between value type and proxy // - swap between proxy and proxy // Having three overloads allows us to swap between different (but compatible) models of PixelConcept template <typename B, typename C, typename L, typename R> inline void swap(const boost::gil::bit_aligned_pixel_reference<B,C,L,true> x, R& y) { boost::gil::swap_proxy<typename boost::gil::bit_aligned_pixel_reference<B,C,L,true>::value_type>(x,y); } template <typename B, typename C, typename L> inline void swap(typename boost::gil::bit_aligned_pixel_reference<B,C,L,true>::value_type& x, const boost::gil::bit_aligned_pixel_reference<B,C,L,true> y) { boost::gil::swap_proxy<typename boost::gil::bit_aligned_pixel_reference<B,C,L,true>::value_type>(x,y); } template <typename B, typename C, typename L> inline void swap(const boost::gil::bit_aligned_pixel_reference<B,C,L,true> x, const boost::gil::bit_aligned_pixel_reference<B,C,L,true> y) { boost::gil::swap_proxy<typename boost::gil::bit_aligned_pixel_reference<B,C,L,true>::value_type>(x,y); } } // namespace std #endif PK��p�[5��device_n.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_DEVICE_N_HPP #define BOOST_GIL_DEVICE_N_HPP #include <boost/gil/metafunctions.hpp> #include <boost/gil/utilities.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/config.hpp> #include <cstddef> #include <type_traits> namespace boost { namespace gil { // TODO: Document the DeviceN Color Space and Color Model // with reference to the Adobe documentation // https://www.adobe.com/content/dam/acom/en/devnet/postscript/pdfs/TN5604.DeviceN_Color.pdf /// \brief unnamed color /// \ingroup ColorNameModel template <int N> struct devicen_color_t {}; template <int N> struct devicen_t; /// \brief Unnamed color space of 1, 3, 4, or 5 channels /// \tparam N Number of color components (1, 3, 4 or 5). /// \ingroup ColorSpaceModel template <int N> struct devicen_t { private: template <typename T> using color_t = devicen_color_t<T::value>; static_assert( N == 1 \|\| (3 <= N && N <= 5), "invalid number of DeviceN color components"); public: using type = mp11::mp_transform<color_t, mp11::mp_iota_c<N>>; }; /// \brief unnamed color layout of up to five channels /// \ingroup LayoutModel template <int N> struct devicen_layout_t : layout<typename devicen_t<N>::type> {}; /// \ingroup ImageViewConstructors /// \brief from 2-channel planar data template <typename IC> inline typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<2>>>::view_t planar_devicen_view(std::size_t width, std::size_t height, IC c0, IC c1, std::ptrdiff_t rowsize_in_bytes) { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<2>>>::view_t; return view_t(width, height, typename view_t::locator(typename view_t::x_iterator(c0,c1), rowsize_in_bytes)); } /// \ingroup ImageViewConstructors /// \brief from 3-channel planar data template <typename IC> inline auto planar_devicen_view(std::size_t width, std::size_t height, IC c0, IC c1, IC c2, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<3>>>::view_t { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<3>>>::view_t; return view_t(width, height, typename view_t::locator(typename view_t::x_iterator(c0,c1,c2), rowsize_in_bytes)); } /// \ingroup ImageViewConstructors /// \brief from 4-channel planar data template <typename IC> inline auto planar_devicen_view(std::size_t width, std::size_t height, IC c0, IC c1, IC c2, IC c3, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<4>>>::view_t { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<4>>>::view_t; return view_t(width, height, typename view_t::locator(typename view_t::x_iterator(c0,c1,c2,c3), rowsize_in_bytes)); } /// \ingroup ImageViewConstructors /// \brief from 5-channel planar data template <typename IC> inline auto planar_devicen_view(std::size_t width, std::size_t height, IC c0, IC c1, IC c2, IC c3, IC c4, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<5>>>::view_t { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC,devicen_t<5>>>::view_t; return view_t(width, height, typename view_t::locator(typename view_t::x_iterator(c0,c1,c2,c3,c4), rowsize_in_bytes)); } }} // namespace boost::gil #endif PK��p�[0j��pixel_iterator.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_PIXEL_ITERATOR_HPP #define BOOST_GIL_PIXEL_ITERATOR_HPP #include <boost/gil/concepts.hpp> #include <boost/gil/dynamic_step.hpp> #include <boost/gil/utilities.hpp> #include <boost/gil/pixel.hpp> #include <iterator> #include <type_traits> namespace boost { namespace gil { //forwarded declaration (as this file is included in step_iterator.hpp) template <typename Iterator> class memory_based_step_iterator; /// \brief metafunction predicate determining whether the given iterator is a plain one or an adaptor over another iterator. /// Examples of adaptors are the step iterator and the dereference iterator adaptor. template <typename It> struct is_iterator_adaptor : public std::false_type {}; /// \brief returns the base iterator for a given iterator adaptor. Provide an specialization when introducing new iterator adaptors template <typename It> struct iterator_adaptor_get_base; /// \brief Changes the base iterator of an iterator adaptor. Provide an specialization when introducing new iterator adaptors template <typename It, typename NewBaseIt> struct iterator_adaptor_rebind; /// \brief Returns the type of an iterator just like the input iterator, except operating over immutable values template <typename It> struct const_iterator_type; // The default implementation when the iterator is a C pointer is to use the standard constness semantics template <typename T> struct const_iterator_type<T> { using type = T const; }; template <typename T> struct const_iterator_type<T const> { using type = T const; }; /// \brief Metafunction predicate returning whether the given iterator allows for changing its values /// \ingroup GILIsMutable template <typename It> struct iterator_is_mutable{}; // The default implementation when the iterator is a C pointer is to use the standard constness semantics template <typename T> struct iterator_is_mutable<T> : std::true_type {}; template <typename T> struct iterator_is_mutable<T const> : std::false_type {}; /// \defgroup PixelIteratorModelInterleavedPtr C pointer to a pixel /// \ingroup PixelIteratorModel /// \brief Iterators over interleaved pixels. /// A C pointer to a model of PixelValueConcept is used as an iterator over interleaved pixels. Models PixelIteratorConcept, HomogeneousPixelBasedConcept, HasDynamicXStepTypeConcept, MemoryBasedIteratorConcept ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// /// \ingroup PixelIteratorModelInterleavedPtr template <typename Pixel> struct dynamic_x_step_type<Pixel> { using type = memory_based_step_iterator<Pixel >; }; /// \ingroup PixelIteratorModelInterleavedPtr template <typename Pixel> struct dynamic_x_step_type<const Pixel> { using type = memory_based_step_iterator<const Pixel >; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename Pixel> struct color_space_type<Pixel> : color_space_type<Pixel> {}; template <typename Pixel> struct color_space_type<Pixel const> : color_space_type<Pixel> {}; template <typename Pixel> struct channel_mapping_type<Pixel> : channel_mapping_type<Pixel> {}; template <typename Pixel> struct channel_mapping_type<Pixel const> : channel_mapping_type<Pixel> {}; template <typename Pixel> struct is_planar<Pixel> : is_planar<Pixel> {}; template <typename Pixel> struct is_planar<Pixel const> : is_planar<Pixel> {}; ///////////////////////////// // HomogeneousPixelBasedConcept ///////////////////////////// template <typename Pixel> struct channel_type<Pixel> : channel_type<Pixel> {}; template <typename Pixel> struct channel_type<Pixel const> : channel_type<Pixel> {}; //////////////////////////////////////////////////////////////////////////////////////// /// Support for pixel iterator movement measured in memory units (bytes or bits) as opposed to pixel type. /// Necessary to handle image row alignment and channel plane alignment. //////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template <typename T> struct byte_to_memunit : std::integral_constant<int, 1> {}; template <typename P> inline std::ptrdiff_t memunit_step(P const) { return sizeof(P); } template <typename P> inline std::ptrdiff_t memunit_distance(P const p1, P const* p2) { return ( gil_reinterpret_cast_c<unsigned char const>(p2) - gil_reinterpret_cast_c<unsigned char const>(p1)); } template <typename P> inline void memunit_advance(P* &p, std::ptrdiff_t diff) { p = (P)((unsigned char)(p)+diff); } template <typename P> inline P* memunit_advanced(const P* p, std::ptrdiff_t diff) { return (P)((char)(p)+diff); } // memunit_advanced_ref // (shortcut to advancing a pointer by a given number of memunits and taking the reference in case the compiler is not smart enough) template <typename P> inline P& memunit_advanced_ref(P* p, std::ptrdiff_t diff) { return memunit_advanced(p,diff); } } } // namespace boost::gil #endif PK��p�[�9/h�� point.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_POINT_HPP #define BOOST_GIL_POINT_HPP #include <boost/gil/utilities.hpp> #include <boost/gil/detail/std_common_type.hpp> #include <boost/config.hpp> #include <cstddef> #include <type_traits> namespace boost { namespace gil { /// \addtogroup PointModel /// /// Example: /// \code /// point<std::ptrdiff_t> p(3,2); /// assert((p[0] == p.x) && (p[1] == p.y)); /// assert(axis_value<0>(p) == 3); /// assert(axis_value<1>(p) == 2); /// \endcode /// \brief 2D point both axes of which have the same dimension type /// \ingroup PointModel /// Models: Point2DConcept template <typename T> class point { public: using value_type = T; template<std::size_t D> struct axis { using coord_t = value_type; }; static constexpr std::size_t num_dimensions = 2; point() = default; point(T px, T py) : x(px), y(py) {} point operator<<(std::ptrdiff_t shift) const { return point(x << shift, y << shift); } point operator>>(std::ptrdiff_t shift) const { return point(x >> shift, y >> shift); } point& operator+=(point const& p) { x += p.x; y += p.y; return this; } point& operator-=(point const& p) { x -= p.x; y -= p.y; return this; } point& operator/=(double d) { if (d < 0 \|\| 0 < d) { x = static_cast<T>(x / d); y = static_cast<T>(y / d); } return this; } point& operator=(double d) { x = static_cast<T>(x d); y = static_cast<T>(y * d); return this; } T const& operator[](std::size_t i) const { return this->mem_array[i]; } T& operator[](std::size_t i) { return this->mem_array[i]; } T x{0}; T y{0}; private: // this static array of pointers to member variables makes operator[] safe // and doesn't seem to exhibit any performance penalty. static T point<T>:: const mem_array[num_dimensions]; }; /// Alias template for backward compatibility with Boost <=1.68. template <typename T> using point2 = point<T>; /// Common type to represent 2D dimensions or in-memory size of image or view. /// @todo TODO: rename to dims_t or dimensions_t for purpose clarity? using point_t = point<std::ptrdiff_t>; template <typename T> T point<T>::* const point<T>::mem_array[point<T>::num_dimensions] = { &point<T>::x, &point<T>::y }; /// \ingroup PointModel template <typename T> BOOST_FORCEINLINE bool operator==(const point<T>& p1, const point<T>& p2) { return p1.x == p2.x && p1.y == p2.y; } /// \ingroup PointModel template <typename T> BOOST_FORCEINLINE bool operator!=(const point<T>& p1, const point<T>& p2) { return p1.x != p2.x \|\| p1.y != p2.y; } /// \ingroup PointModel template <typename T> BOOST_FORCEINLINE point<T> operator+(const point<T>& p1, const point<T>& p2) { return { p1.x + p2.x, p1.y + p2.y }; } /// \ingroup PointModel template <typename T> BOOST_FORCEINLINE point<T> operator-(const point<T>& p) { return { -p.x, -p.y }; } /// \ingroup PointModel template <typename T> BOOST_FORCEINLINE point<T> operator-(const point<T>& p1, const point<T>& p2) { return { p1.x - p2.x, p1.y - p2.y }; } /// \ingroup PointModel template <typename T, typename D> BOOST_FORCEINLINE auto operator/(point<T> const& p, D d) -> typename std::enable_if < std::is_arithmetic<D>::value, point<typename detail::std_common_type<T, D>::type> >::type { static_assert(std::is_arithmetic<D>::value, "denominator is not arithmetic type"); using result_type = typename detail::std_common_type<T, D>::type; if (d < 0 \|\| 0 < d) { double const x = static_cast<double>(p.x) / static_cast<double>(d); double const y = static_cast<double>(p.y) / static_cast<double>(d); return point<result_type>{ static_cast<result_type>(iround(x)), static_cast<result_type>(iround(y))}; } else { return point<result_type>{0, 0}; } } /// \ingroup PointModel template <typename T, typename M> BOOST_FORCEINLINE auto operator(point<T> const& p, M m) -> typename std::enable_if < std::is_arithmetic<M>::value, point<typename detail::std_common_type<T, M>::type> >::type { static_assert(std::is_arithmetic<M>::value, "multiplier is not arithmetic type"); using result_type = typename detail::std_common_type<T, M>::type; return point<result_type>{p.x m, p.y * m}; } /// \ingroup PointModel template <typename T, typename M> BOOST_FORCEINLINE auto operator(M m, point<T> const& p) -> typename std::enable_if < std::is_arithmetic<M>::value, point<typename detail::std_common_type<T, M>::type> >::type { static_assert(std::is_arithmetic<M>::value, "multiplier is not arithmetic type"); using result_type = typename detail::std_common_type<T, M>::type; return point<result_type>{p.x m, p.y * m}; } /// \ingroup PointModel template <std::size_t K, typename T> BOOST_FORCEINLINE T const& axis_value(point<T> const& p) { static_assert(K < point<T>::num_dimensions, "axis index out of range"); return p[K]; } /// \ingroup PointModel template <std::size_t K, typename T> BOOST_FORCEINLINE T& axis_value(point<T>& p) { static_assert(K < point<T>::num_dimensions, "axis index out of range"); return p[K]; } /// \addtogroup PointAlgorithm /// /// Example: /// \code /// assert(iround(point<double>(3.1, 3.9)) == point<std::ptrdiff_t>(3,4)); /// \endcode /// \ingroup PointAlgorithm template <typename T> inline point<std::ptrdiff_t> iround(point<T> const& p) { static_assert(std::is_integral<T>::value, "T is not integer"); return { static_cast<std::ptrdiff_t>(p.x), static_cast<std::ptrdiff_t>(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> iround(point<float> const& p) { return { iround(p.x), iround(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> iround(point<double> const& p) { return { iround(p.x), iround(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> ifloor(point<float> const& p) { return { ifloor(p.x), ifloor(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> ifloor(point<double> const& p) { return { ifloor(p.x), ifloor(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> iceil(point<float> const& p) { return { iceil(p.x), iceil(p.y) }; } /// \ingroup PointAlgorithm inline point<std::ptrdiff_t> iceil(point<double> const& p) { return { iceil(p.x), iceil(p.y) }; } }} // namespace boost::gil #endif PK��p�[��cmyk.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_CMYK_HPP #define BOOST_GIL_CMYK_HPP #include <boost/gil/metafunctions.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> namespace boost { namespace gil { /// \addtogroup ColorNameModel /// \{ /// \brief Cyan struct cyan_t {}; /// \brief Magenta struct magenta_t {}; /// \brief Yellow struct yellow_t {}; /// \brief Black struct black_t {}; /// \} /// \ingroup ColorSpaceModel using cmyk_t = mp11::mp_list<cyan_t, magenta_t, yellow_t, black_t>; /// \ingroup LayoutModel using cmyk_layout_t = layout<cmyk_t>; /// \ingroup ImageViewConstructors /// \brief from raw CMYK planar data template <typename IC> inline typename type_from_x_iterator<planar_pixel_iterator<IC,cmyk_t> >::view_t planar_cmyk_view(std::size_t width, std::size_t height, IC c, IC m, IC y, IC k, std::ptrdiff_t rowsize_in_bytes) { using view_t = typename type_from_x_iterator<planar_pixel_iterator<IC,cmyk_t> >::view_t; return view_t(width, height, typename view_t::locator(planar_pixel_iterator<IC,cmyk_t>(c,m,y,k), rowsize_in_bytes)); } } } // namespace gil #endif PK��p�[E#�H� �� premultiply.hppnu��[��// // Copyright 2014 Bill Gallafent // // 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_PREMULTIPLY_HPP #define BOOST_GIL_PREMULTIPLY_HPP #include <boost/gil/rgba.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/core/ignore_unused.hpp> #include <type_traits> namespace boost { namespace gil { template <typename SrcP, typename DstP> struct channel_premultiply { channel_premultiply(SrcP const & src, DstP & dst) : src_(src), dst_(dst) {} template <typename Channel> void operator()(Channel /* channel /) const { // TODO: Explain why 'channel' input paramater is not used, or used as tag only. // @todo: need to do a "channel_convert" too, in case the channel types aren't the same? get_color(dst_, Channel()) = channel_multiply(get_color(src_,Channel()), alpha_or_max(src_)); } SrcP const & src_; DstP & dst_; }; namespace detail { template <typename SrcP, typename DstP> void assign_alpha_if(std::true_type, SrcP const &src, DstP &dst) { get_color(dst,alpha_t()) = alpha_or_max(src); } template <typename SrcP, typename DstP> void assign_alpha_if(std::false_type, SrcP const& src, DstP& dst) { // nothing to do boost::ignore_unused(src); boost::ignore_unused(dst); } } struct premultiply { template <typename SrcP, typename DstP> void operator()(const SrcP& src, DstP& dst) const { using src_colour_space_t = typename color_space_type<SrcP>::type; using dst_colour_space_t = typename color_space_type<DstP>::type; using src_colour_channels = mp11::mp_remove<src_colour_space_t, alpha_t>; using has_alpha_t = std::integral_constant<bool, mp11::mp_contains<dst_colour_space_t, alpha_t>::value>; mp11::mp_for_each<src_colour_channels>(channel_premultiply<SrcP, DstP>(src, dst)); detail::assign_alpha_if(has_alpha_t(), src, dst); } }; template <typename SrcConstRefP, // const reference to the source pixel typename DstP> // Destination pixel value (models PixelValueConcept) class premultiply_deref_fn { public: using const_t = premultiply_deref_fn<SrcConstRefP, DstP>; using value_type = DstP; using reference = value_type; // read-only dereferencing using const_reference = const value_type &; using argument_type = SrcConstRefP; using result_type = reference; static constexpr bool is_mutable = false; result_type operator()(argument_type srcP) const { result_type dstP; premultiply()(srcP,dstP); return dstP; } }; template <typename SrcView, typename DstP> struct premultiplied_view_type { private: using src_pix_ref = typename SrcView::const_t::reference; // const reference to pixel in SrcView using deref_t = premultiply_deref_fn<src_pix_ref, DstP>; // the dereference adaptor that performs color conversion using add_ref_t = typename SrcView::template add_deref<deref_t>; public: using type = typename add_ref_t::type; // the color converted view type static type make(const SrcView& sv) { return add_ref_t::make(sv, deref_t()); } }; template <typename DstP, typename View> inline typename premultiplied_view_type<View,DstP>::type premultiply_view(const View& src) { return premultiplied_view_type<View,DstP>::make(src); } }} // namespace boost::gil #endif PK��p�[ #�b1`��1`��image_view_factory.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_VIEW_FACTORY_HPP #define BOOST_GIL_IMAGE_VIEW_FACTORY_HPP #include <boost/gil/color_convert.hpp> #include <boost/gil/dynamic_step.hpp> #include <boost/gil/gray.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/gil/point.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/assert.hpp> #include <cstddef> #include <type_traits> /// Methods for creating shallow image views from raw pixel data or from other image views - /// flipping horizontally or vertically, axis-aligned rotation, a subimage, subsampled /// or n-th channel image view. Derived image views are shallow copies and are fast to construct. /// \defgroup ImageViewConstructors Image View From Raw Data /// \ingroup ImageViewAlgorithm /// \brief Methods for constructing image views from raw data and for getting raw data from views /// \defgroup ImageViewTransformations Image View Transformations /// \ingroup ImageViewAlgorithm /// \brief Methods for constructing one image view from another namespace boost { namespace gil { struct default_color_converter; template <typename T> struct transposed_type; /// \brief Returns the type of a view that has a dynamic step along both X and Y /// \ingroup ImageViewTransformations template <typename View> struct dynamic_xy_step_type : dynamic_y_step_type<typename dynamic_x_step_type<View>::type> {}; /// \brief Returns the type of a transposed view that has a dynamic step along both X and Y /// \ingroup ImageViewTransformations template <typename View> struct dynamic_xy_step_transposed_type : dynamic_xy_step_type<typename transposed_type<View>::type> {}; /// \ingroup ImageViewConstructors /// \brief Constructing image views from raw interleaved pixel data template <typename Iterator> typename type_from_x_iterator<Iterator>::view_t interleaved_view(std::size_t width, std::size_t height, Iterator pixels, std::ptrdiff_t rowsize_in_bytes) { using RView = typename type_from_x_iterator<Iterator>::view_t; return RView(width, height, typename RView::locator(pixels, rowsize_in_bytes)); } /// \ingroup ImageViewConstructors /// \brief Constructing image views from raw interleaved pixel data template <typename Iterator> auto interleaved_view(point<std::ptrdiff_t> dim, Iterator pixels, std::ptrdiff_t rowsize_in_bytes) -> typename type_from_x_iterator<Iterator>::view_t { using RView = typename type_from_x_iterator<Iterator>::view_t; return RView(dim, typename RView::locator(pixels, rowsize_in_bytes)); } ///////////////////////////// // interleaved_view_get_raw_data, planar_view_get_raw_data - return pointers to the raw data (the channels) of a basic homogeneous view. ///////////////////////////// namespace detail { template <typename View, bool IsMutable> struct channel_pointer_type_impl; template <typename View> struct channel_pointer_type_impl<View, true> { using type = typename channel_type<View>::type ; }; template <typename View> struct channel_pointer_type_impl<View, false> { using type = const typename channel_type<View>::type ; }; template <typename View> struct channel_pointer_type : public channel_pointer_type_impl<View, view_is_mutable<View>::value> {}; } // namespace detail /// \ingroup ImageViewConstructors /// \brief Returns C pointer to the the channels of an interleaved homogeneous view. template <typename HomogeneousView> typename detail::channel_pointer_type<HomogeneousView>::type interleaved_view_get_raw_data(const HomogeneousView& view) { static_assert(!is_planar<HomogeneousView>::value && view_is_basic<HomogeneousView>::value, ""); static_assert(std::is_pointer<typename HomogeneousView::x_iterator>::value, ""); return &gil::at_c<0>(view(0,0)); } /// \ingroup ImageViewConstructors /// \brief Returns C pointer to the the channels of a given color plane of a planar homogeneous view. template <typename HomogeneousView> typename detail::channel_pointer_type<HomogeneousView>::type planar_view_get_raw_data(const HomogeneousView& view, int plane_index) { static_assert(is_planar<HomogeneousView>::value && view_is_basic<HomogeneousView>::value, ""); return dynamic_at_c(view.row_begin(0),plane_index); } /// \defgroup ImageViewTransformationsColorConvert color_converted_view /// \ingroup ImageViewTransformations /// \brief Color converted view of another view /// \ingroup ImageViewTransformationsColorConvert PixelDereferenceAdaptorModel /// \brief Function object that given a source pixel, returns it converted to a given color space and channel depth. Models: PixelDereferenceAdaptorConcept /// /// Useful in constructing a color converted view over a given image view template <typename SrcConstRefP, typename DstP, typename CC=default_color_converter > // const_reference to the source pixel and destination pixel value class color_convert_deref_fn : public deref_base<color_convert_deref_fn<SrcConstRefP,DstP,CC>, DstP, DstP, const DstP&, SrcConstRefP, DstP, false> { private: CC _cc; // color-converter public: color_convert_deref_fn() {} color_convert_deref_fn(CC cc_in) : _cc(cc_in) {} DstP operator()(SrcConstRefP srcP) const { DstP dstP; _cc(srcP,dstP); return dstP; } }; namespace detail { // Add color converter upon dereferencing template <typename SrcView, typename CC, typename DstP, typename SrcP> struct _color_converted_view_type { private: using deref_t = color_convert_deref_fn<typename SrcView::const_t::reference,DstP,CC>; using add_ref_t = typename SrcView::template add_deref<deref_t>; public: using type = typename add_ref_t::type; static type make(const SrcView& sv,CC cc) {return add_ref_t::make(sv,deref_t(cc));} }; // If the Src view has the same pixel type as the target, there is no need for color conversion template <typename SrcView, typename CC, typename DstP> struct _color_converted_view_type<SrcView,CC,DstP,DstP> { using type = SrcView; static type make(const SrcView& sv,CC) {return sv;} }; } // namespace detail /// \brief Returns the type of a view that does color conversion upon dereferencing its pixels /// \ingroup ImageViewTransformationsColorConvert template <typename SrcView, typename DstP, typename CC=default_color_converter> struct color_converted_view_type : public detail::_color_converted_view_type<SrcView, CC, DstP, typename SrcView::value_type> { BOOST_GIL_CLASS_REQUIRE(DstP, boost::gil, MutablePixelConcept)//why does it have to be mutable??? }; /// \ingroup ImageViewTransformationsColorConvert /// \brief view of a different color space with a user defined color-converter template <typename DstP, typename View, typename CC> inline typename color_converted_view_type<View,DstP,CC>::type color_converted_view(const View& src,CC cc) { return color_converted_view_type<View,DstP,CC>::make(src,cc); } /// \ingroup ImageViewTransformationsColorConvert /// \brief overload of generic color_converted_view with the default color-converter template <typename DstP, typename View> inline typename color_converted_view_type<View,DstP>::type color_converted_view(const View& src) { return color_converted_view<DstP>(src,default_color_converter()); } /// \defgroup ImageViewTransformationsFlipUD flipped_up_down_view /// \ingroup ImageViewTransformations /// \brief view of a view flipped up-to-down /// \ingroup ImageViewTransformationsFlipUD template <typename View> inline typename dynamic_y_step_type<View>::type flipped_up_down_view(const View& src) { using RView = typename dynamic_y_step_type<View>::type; return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(0,src.height()-1),-1)); } /// \defgroup ImageViewTransformationsFlipLR flipped_left_right_view /// \ingroup ImageViewTransformations /// \brief view of a view flipped left-to-right /// \ingroup ImageViewTransformationsFlipLR template <typename View> inline typename dynamic_x_step_type<View>::type flipped_left_right_view(const View& src) { using RView = typename dynamic_x_step_type<View>::type; return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(src.width()-1,0),-1,1)); } /// \defgroup ImageViewTransformationsTransposed transposed_view /// \ingroup ImageViewTransformations /// \brief view of a view transposed /// \ingroup ImageViewTransformationsTransposed template <typename View> inline typename dynamic_xy_step_transposed_type<View>::type transposed_view(const View& src) { using RView = typename dynamic_xy_step_transposed_type<View>::type; return RView(src.height(),src.width(),typename RView::xy_locator(src.xy_at(0,0),1,1,true)); } /// \defgroup ImageViewTransformations90CW rotated90cw_view /// \ingroup ImageViewTransformations /// \brief view of a view rotated 90 degrees clockwise /// \ingroup ImageViewTransformations90CW template <typename View> inline typename dynamic_xy_step_transposed_type<View>::type rotated90cw_view(const View& src) { using RView = typename dynamic_xy_step_transposed_type<View>::type; return RView(src.height(),src.width(),typename RView::xy_locator(src.xy_at(0,src.height()-1),-1,1,true)); } /// \defgroup ImageViewTransformations90CCW rotated90ccw_view /// \ingroup ImageViewTransformations /// \brief view of a view rotated 90 degrees counter-clockwise /// \ingroup ImageViewTransformations90CCW template <typename View> inline typename dynamic_xy_step_transposed_type<View>::type rotated90ccw_view(const View& src) { using RView = typename dynamic_xy_step_transposed_type<View>::type; return RView(src.height(),src.width(),typename RView::xy_locator(src.xy_at(src.width()-1,0),1,-1,true)); } /// \defgroup ImageViewTransformations180 rotated180_view /// \ingroup ImageViewTransformations /// \brief view of a view rotated 180 degrees /// \ingroup ImageViewTransformations180 template <typename View> inline typename dynamic_xy_step_type<View>::type rotated180_view(const View& src) { using RView = typename dynamic_xy_step_type<View>::type; return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(src.width()-1,src.height()-1),-1,-1)); } /// \defgroup ImageViewTransformationsSubimage subimage_view /// \ingroup ImageViewTransformations /// \brief view of an axis-aligned rectangular area within an image_view /// \ingroup ImageViewTransformationsSubimage template <typename View> inline View subimage_view( View const& src, typename View::point_t const& topleft, typename View::point_t const& dimensions) { return View(dimensions, src.xy_at(topleft)); } /// \ingroup ImageViewTransformationsSubimage template <typename View> inline View subimage_view(View const& src, typename View::coord_t x_min, typename View::coord_t y_min, typename View::coord_t width, typename View::coord_t height) { return View(width, height, src.xy_at(x_min, y_min)); } /// \defgroup ImageViewTransformationsSubsampled subsampled_view /// \ingroup ImageViewTransformations /// \brief view of a subsampled version of an image_view, stepping over a number of channels in X and number of rows in Y /// \ingroup ImageViewTransformationsSubsampled template <typename View> inline auto subsampled_view(View const& src, typename View::coord_t x_step, typename View::coord_t y_step) -> typename dynamic_xy_step_type<View>::type { BOOST_ASSERT(x_step > 0 && y_step > 0); using view_t =typename dynamic_xy_step_type<View>::type; return view_t( (src.width() + (x_step - 1)) / x_step, (src.height() + (y_step - 1)) / y_step, typename view_t::xy_locator(src.xy_at(0,0), x_step, y_step)); } /// \ingroup ImageViewTransformationsSubsampled template <typename View> inline auto subsampled_view(View const& src, typename View::point_t const& step) -> typename dynamic_xy_step_type<View>::type { return subsampled_view(src, step.x, step.y); } /// \defgroup ImageViewTransformationsNthChannel nth_channel_view /// \ingroup ImageViewTransformations /// \brief single-channel (grayscale) view of the N-th channel of a given image_view namespace detail { template <typename View, bool AreChannelsTogether> struct __nth_channel_view_basic; // nth_channel_view when the channels are not adjacent in memory. This can happen for multi-channel interleaved images // or images with a step template <typename View> struct __nth_channel_view_basic<View,false> { using type = typename view_type<typename channel_type<View>::type, gray_layout_t, false, true, view_is_mutable<View>::value>::type; static type make(const View& src, int n) { using locator_t = typename type::xy_locator; using x_iterator_t = typename type::x_iterator; using x_iterator_base_t = typename iterator_adaptor_get_base<x_iterator_t>::type; x_iterator_t sit(x_iterator_base_t(&(src(0,0)[n])),src.pixels().pixel_size()); return type(src.dimensions(),locator_t(sit, src.pixels().row_size())); } }; // nth_channel_view when the channels are together in memory (true for simple grayscale or planar images) template <typename View> struct __nth_channel_view_basic<View,true> { using type = typename view_type<typename channel_type<View>::type, gray_layout_t, false, false, view_is_mutable<View>::value>::type; static type make(const View& src, int n) { using x_iterator_t = typename type::x_iterator; return interleaved_view(src.width(),src.height(),(x_iterator_t)&(src(0,0)[n]), src.pixels().row_size()); } }; template <typename View, bool IsBasic> struct __nth_channel_view; // For basic (memory-based) views dispatch to __nth_channel_view_basic template <typename View> struct __nth_channel_view<View,true> { private: using src_x_iterator = typename View::x_iterator; // Determines whether the channels of a given pixel iterator are adjacent in memory. // Planar and grayscale iterators have channels adjacent in memory, whereas multi-channel interleaved and iterators with non-fundamental step do not. static constexpr bool adjacent = !iterator_is_step<src_x_iterator>::value && (is_planar<src_x_iterator>::value \|\| num_channels<View>::value == 1); public: using type = typename __nth_channel_view_basic<View,adjacent>::type; static type make(const View& src, int n) { return __nth_channel_view_basic<View,adjacent>::make(src,n); } }; /// \brief Function object that returns a grayscale reference of the N-th channel of a given reference. Models: PixelDereferenceAdaptorConcept. /// \ingroup PixelDereferenceAdaptorModel /// /// If the input is a pixel value or constant reference, the function object is immutable. Otherwise it is mutable (and returns non-const reference to the n-th channel) template <typename SrcP> // SrcP is a reference to PixelConcept (could be pixel value or const/non-const reference) // Examples: pixel<T,L>, pixel<T,L>&, const pixel<T,L>&, planar_pixel_reference<T&,L>, planar_pixel_reference<const T&,L> struct nth_channel_deref_fn { static constexpr bool is_mutable = pixel_is_reference<SrcP>::value && pixel_reference_is_mutable<SrcP>::value; private: using src_pixel_t = typename std::remove_reference<SrcP>::type; using channel_t = typename channel_type<src_pixel_t>::type; using const_ref_t = typename src_pixel_t::const_reference; using ref_t = typename pixel_reference_type<channel_t,gray_layout_t,false,is_mutable>::type; public: using const_t = nth_channel_deref_fn<const_ref_t>; using value_type = typename pixel_value_type<channel_t,gray_layout_t>::type; using const_reference = typename pixel_reference_type<channel_t,gray_layout_t,false,false>::type; using argument_type = SrcP; using reference = mp11::mp_if_c<is_mutable, ref_t, value_type>; using result_type = reference; nth_channel_deref_fn(int n=0) : _n(n) {} template <typename P> nth_channel_deref_fn(const nth_channel_deref_fn<P>& d) : _n(d._n) {} int _n; // the channel to use result_type operator()(argument_type srcP) const { return result_type(srcP[_n]); } }; template <typename View> struct __nth_channel_view<View,false> { private: using deref_t = nth_channel_deref_fn<typename View::reference>; using AD = typename View::template add_deref<deref_t>; public: using type = typename AD::type; static type make(const View& src, int n) { return AD::make(src, deref_t(n)); } }; } // namespace detail /// \brief Given a source image view type View, returns the type of an image view over a single channel of View /// \ingroup ImageViewTransformationsNthChannel /// /// If the channels in the source view are adjacent in memory (such as planar non-step view or single-channel view) then the /// return view is a single-channel non-step view. /// If the channels are non-adjacent (interleaved and/or step view) then the return view is a single-channel step view. template <typename View> struct nth_channel_view_type { private: BOOST_GIL_CLASS_REQUIRE(View, boost::gil, ImageViewConcept) using VB = detail::__nth_channel_view<View,view_is_basic<View>::value>; public: using type = typename VB::type; static type make(const View& src, int n) { return VB::make(src,n); } }; /// \ingroup ImageViewTransformationsNthChannel template <typename View> typename nth_channel_view_type<View>::type nth_channel_view(const View& src, int n) { return nth_channel_view_type<View>::make(src,n); } /// \defgroup ImageViewTransformationsKthChannel kth_channel_view /// \ingroup ImageViewTransformations /// \brief single-channel (grayscale) view of the K-th channel of a given image_view. The channel index is a template parameter namespace detail { template <int K, typename View, bool AreChannelsTogether> struct __kth_channel_view_basic; // kth_channel_view when the channels are not adjacent in memory. This can happen for multi-channel interleaved images // or images with a step template <int K, typename View> struct __kth_channel_view_basic<K,View,false> { private: using channel_t = typename kth_element_type<typename View::value_type,K>::type; public: using type = typename view_type<channel_t, gray_layout_t, false, true, view_is_mutable<View>::value>::type; static type make(const View& src) { using locator_t = typename type::xy_locator; using x_iterator_t = typename type::x_iterator; using x_iterator_base_t = typename iterator_adaptor_get_base<x_iterator_t>::type; x_iterator_t sit(x_iterator_base_t(&gil::at_c<K>(src(0,0))),src.pixels().pixel_size()); return type(src.dimensions(),locator_t(sit, src.pixels().row_size())); } }; // kth_channel_view when the channels are together in memory (true for simple grayscale or planar images) template <int K, typename View> struct __kth_channel_view_basic<K,View,true> { private: using channel_t = typename kth_element_type<typename View::value_type, K>::type; public: using type = typename view_type<channel_t, gray_layout_t, false, false, view_is_mutable<View>::value>::type; static type make(const View& src) { using x_iterator_t = typename type::x_iterator; return interleaved_view(src.width(),src.height(),(x_iterator_t)&gil::at_c<K>(src(0,0)), src.pixels().row_size()); } }; template <int K, typename View, bool IsBasic> struct __kth_channel_view; // For basic (memory-based) views dispatch to __kth_channel_view_basic template <int K, typename View> struct __kth_channel_view<K,View,true> { private: using src_x_iterator = typename View::x_iterator; // Determines whether the channels of a given pixel iterator are adjacent in memory. // Planar and grayscale iterators have channels adjacent in memory, whereas multi-channel interleaved and iterators with non-fundamental step do not. static constexpr bool adjacent = !iterator_is_step<src_x_iterator>::value && (is_planar<src_x_iterator>::value \|\| num_channels<View>::value == 1); public: using type = typename __kth_channel_view_basic<K,View,adjacent>::type; static type make(const View& src) { return __kth_channel_view_basic<K,View,adjacent>::make(src); } }; /// \brief Function object that returns a grayscale reference of the K-th channel (specified as a template parameter) of a given reference. Models: PixelDereferenceAdaptorConcept. /// \ingroup PixelDereferenceAdaptorModel /// /// If the input is a pixel value or constant reference, the function object is immutable. Otherwise it is mutable (and returns non-const reference to the k-th channel) /// \tparam SrcP reference to PixelConcept (could be pixel value or const/non-const reference) /// Examples: pixel<T,L>, pixel<T,L>&, const pixel<T,L>&, planar_pixel_reference<T&,L>, planar_pixel_reference<const T&,L> template <int K, typename SrcP> struct kth_channel_deref_fn { static constexpr bool is_mutable = pixel_is_reference<SrcP>::value && pixel_reference_is_mutable<SrcP>::value; private: using src_pixel_t = typename std::remove_reference<SrcP>::type; using channel_t = typename kth_element_type<src_pixel_t, K>::type; using const_ref_t = typename src_pixel_t::const_reference; using ref_t = typename pixel_reference_type<channel_t,gray_layout_t,false,is_mutable>::type; public: using const_t = kth_channel_deref_fn<K,const_ref_t>; using value_type = typename pixel_value_type<channel_t,gray_layout_t>::type; using const_reference = typename pixel_reference_type<channel_t,gray_layout_t,false,false>::type; using argument_type = SrcP; using reference = mp11::mp_if_c<is_mutable, ref_t, value_type>; using result_type = reference; kth_channel_deref_fn() {} template <typename P> kth_channel_deref_fn(const kth_channel_deref_fn<K,P>&) {} result_type operator()(argument_type srcP) const { return result_type(gil::at_c<K>(srcP)); } }; template <int K, typename View> struct __kth_channel_view<K,View,false> { private: using deref_t = kth_channel_deref_fn<K,typename View::reference>; using AD = typename View::template add_deref<deref_t>; public: using type = typename AD::type; static type make(const View& src) { return AD::make(src, deref_t()); } }; } // namespace detail /// \brief Given a source image view type View, returns the type of an image view over a given channel of View. /// \ingroup ImageViewTransformationsKthChannel /// /// If the channels in the source view are adjacent in memory (such as planar non-step view or single-channel view) then the /// return view is a single-channel non-step view. /// If the channels are non-adjacent (interleaved and/or step view) then the return view is a single-channel step view. template <int K, typename View> struct kth_channel_view_type { private: BOOST_GIL_CLASS_REQUIRE(View, boost::gil, ImageViewConcept) using VB = detail::__kth_channel_view<K,View,view_is_basic<View>::value>; public: using type = typename VB::type; static type make(const View& src) { return VB::make(src); } }; /// \ingroup ImageViewTransformationsKthChannel template <int K, typename View> typename kth_channel_view_type<K,View>::type kth_channel_view(const View& src) { return kth_channel_view_type<K,View>::make(src); } } } // namespace boost::gil #endif PK��p�[�V�X��X��-��extension/dynamic_image/dynamic_image_all.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_DYNAMIC_IMAGE_ALL_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_DYNAMIC_IMAGE_ALL_HPP #include <boost/gil/extension/dynamic_image/algorithm.hpp> #include <boost/gil/extension/dynamic_image/any_image.hpp> #include <boost/gil/extension/dynamic_image/apply_operation.hpp> #include <boost/gil/extension/dynamic_image/image_view_factory.hpp> #endif PK��p�[�!�� %��extension/dynamic_image/algorithm.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_ALGORITHM_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_ALGORITHM_HPP #include <boost/gil/extension/dynamic_image/any_image.hpp> #include <boost/gil/algorithm.hpp> #include <functional> //////////////////////////////////////////////////////////////////////////////////////// /// \file /// \brief Some basic STL-style algorithms when applied to runtime type specified image views /// \author Lubomir Bourdev and Hailin Jin \n /// Adobe Systems Incorporated /// \date 2005-2007 \n Last updated on September 24, 2006 /// //////////////////////////////////////////////////////////////////////////////////////// namespace boost { namespace gil { namespace detail { struct equal_pixels_fn : binary_operation_obj<equal_pixels_fn, bool> { template <typename V1, typename V2> BOOST_FORCEINLINE bool apply_compatible(V1 const& v1, V2 const& v2) const { return equal_pixels(v1, v2); } }; } // namespace detail /// \ingroup ImageViewSTLAlgorithmsEqualPixels /// \tparam Types Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam View Model MutableImageViewConcept template <typename ...Types, typename View> bool equal_pixels(any_image_view<Types...> const& src, View const& dst) { return apply_operation( src, std::bind(detail::equal_pixels_fn(), std::placeholders::_1, dst)); } /// \ingroup ImageViewSTLAlgorithmsEqualPixels /// \tparam View Model ImageViewConcept /// \tparam Types Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename View, typename ...Types> bool equal_pixels(View const& src, any_image_view<Types...> const& dst) { return apply_operation( dst, std::bind(detail::equal_pixels_fn(), src, std::placeholders::_1)); } /// \ingroup ImageViewSTLAlgorithmsEqualPixels /// \tparam Types1 Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam Types2 Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename ...Types1, typename ...Types2> bool equal_pixels(any_image_view<Types1...> const& src, any_image_view<Types2...> const& dst) { return apply_operation(src, dst, detail::equal_pixels_fn()); } namespace detail { struct copy_pixels_fn : public binary_operation_obj<copy_pixels_fn> { template <typename View1, typename View2> BOOST_FORCEINLINE void apply_compatible(View1 const& src, View2 const& dst) const { copy_pixels(src,dst); } }; } // namespace detail /// \ingroup ImageViewSTLAlgorithmsCopyPixels /// \tparam Types Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam View Model MutableImageViewConcept template <typename ...Types, typename View> void copy_pixels(any_image_view<Types...> const& src, View const& dst) { apply_operation(src, std::bind(detail::copy_pixels_fn(), std::placeholders::_1, dst)); } /// \ingroup ImageViewSTLAlgorithmsCopyPixels /// \tparam Types Model Boost.MP11-compatible list of models of MutableImageViewConcept /// \tparam View Model ImageViewConcept template <typename ...Types, typename View> void copy_pixels(View const& src, any_image_view<Types...> const& dst) { apply_operation(dst, std::bind(detail::copy_pixels_fn(), src, std::placeholders::_1)); } /// \ingroup ImageViewSTLAlgorithmsCopyPixels /// \tparam Types1 Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam Types2 Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename ...Types1, typename ...Types2> void copy_pixels(any_image_view<Types1...> const& src, any_image_view<Types2...> const& dst) { apply_operation(src, dst, detail::copy_pixels_fn()); } //forward declaration for default_color_converter (see full definition in color_convert.hpp) struct default_color_converter; /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam Types Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam View Model MutableImageViewConcept /// \tparam CC Model ColorConverterConcept template <typename ...Types, typename View, typename CC> void copy_and_convert_pixels(any_image_view<Types...> const& src, View const& dst, CC cc) { using cc_fn = detail::copy_and_convert_pixels_fn<CC>; apply_operation(src, std::bind(cc_fn{cc}, std::placeholders::_1, dst)); } /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam Types Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam View Model MutableImageViewConcept template <typename ...Types, typename View> void copy_and_convert_pixels(any_image_view<Types...> const& src, View const& dst) { using cc_fn = detail::copy_and_convert_pixels_fn<default_color_converter>; apply_operation(src, std::bind(cc_fn{}, std::placeholders::_1, dst)); } /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam View Model ImageViewConcept /// \tparam Types Model Boost.MP11-compatible list of models of MutableImageViewConcept /// \tparam CC Model ColorConverterConcept template <typename View, typename ...Types, typename CC> void copy_and_convert_pixels(View const& src, any_image_view<Types...> const& dst, CC cc) { using cc_fn = detail::copy_and_convert_pixels_fn<CC>; apply_operation(dst, std::bind(cc_fn{cc}, src, std::placeholders::_1)); } /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam View Model ImageViewConcept /// \tparam Type Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename View, typename ...Types> void copy_and_convert_pixels(View const& src, any_image_view<Types...> const& dst) { using cc_fn = detail::copy_and_convert_pixels_fn<default_color_converter>; apply_operation(dst, std::bind(cc_fn{}, src, std::placeholders::_1)); } /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam Types1 Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam Types2 Model Boost.MP11-compatible list of models of MutableImageViewConcept /// \tparam CC Model ColorConverterConcept template <typename ...Types1, typename ...Types2, typename CC> void copy_and_convert_pixels( any_image_view<Types1...> const& src, any_image_view<Types2...> const& dst, CC cc) { apply_operation(src, dst, detail::copy_and_convert_pixels_fn<CC>(cc)); } /// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels /// \tparam Types1 Model Boost.MP11-compatible list of models of ImageViewConcept /// \tparam Types2 Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename ...Types1, typename ...Types2> void copy_and_convert_pixels( any_image_view<Types1...> const& src, any_image_view<Types2...> const& dst) { apply_operation(src, dst, detail::copy_and_convert_pixels_fn<default_color_converter>()); } namespace detail { template <bool IsCompatible> struct fill_pixels_fn1 { template <typename V, typename Value> static void apply(V const &src, Value const &val) { fill_pixels(src, val); } }; // copy_pixels invoked on incompatible images template <> struct fill_pixels_fn1<false> { template <typename V, typename Value> static void apply(V const &, Value const &) { throw std::bad_cast();} }; template <typename Value> struct fill_pixels_fn { fill_pixels_fn(Value const& val) : val_(val) {} using result_type = void; template <typename V> result_type operator()(V const& view) const { fill_pixels_fn1 < pixels_are_compatible < typename V::value_type, Value >::value >::apply(view, val_); } Value val_; }; } // namespace detail /// \ingroup ImageViewSTLAlgorithmsFillPixels /// \brief fill_pixels for any image view. The pixel to fill with must be compatible with the current view /// \tparam Types Model Boost.MP11-compatible list of models of MutableImageViewConcept template <typename ...Types, typename Value> void fill_pixels(any_image_view<Types...> const& view, Value const& val) { apply_operation(view, detail::fill_pixels_fn<Value>(val)); } }} // namespace boost::gil #endif PK��p�[��}����extension/dynamic_image/any_image_view.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_ANY_IMAGE_VIEW_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_ANY_IMAGE_VIEW_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/image.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/point.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/variant2/variant.hpp> namespace boost { namespace gil { template <typename View> struct dynamic_xy_step_transposed_type; namespace detail { template <typename View> struct get_const_t { using type = typename View::const_t; }; template <typename Views> struct views_get_const_t : mp11::mp_transform<get_const_t, Views> {}; // works for both image_view and image struct any_type_get_num_channels { using result_type = int; template <typename T> result_type operator()(const T&) const { return num_channels<T>::value; } }; // works for both image_view and image struct any_type_get_dimensions { using result_type = point<std::ptrdiff_t>; template <typename T> result_type operator()(const T& v) const { return v.dimensions(); } }; // works for image_view struct any_type_get_size { using result_type = std::size_t; template <typename T> result_type operator()(const T& v) const { return v.size(); } }; } // namespace detail //////////////////////////////////////////////////////////////////////////////////////// /// CLASS any_image_view /// /// \ingroup ImageViewModel /// \brief Represents a run-time specified image view. Models HasDynamicXStepTypeConcept, HasDynamicYStepTypeConcept, Note that this class does NOT model ImageViewConcept /// /// Represents a view whose type (color space, layout, planar/interleaved organization, etc) can be specified at run time. /// It is the runtime equivalent of \p image_view. /// Some of the requirements of ImageViewConcept, such as the \p value_type alias cannot be fulfilled, since the language does not allow runtime type specification. /// Other requirements, such as access to the pixels, would be inefficient to provide. Thus \p any_image_view does not fully model ImageViewConcept. /// However, many algorithms provide overloads taking runtime specified views and thus in many cases \p any_image_view can be used in places taking a view. /// /// To perform an algorithm on any_image_view, put the algorithm in a function object and invoke it by calling \p apply_operation(runtime_view, algorithm_fn); //////////////////////////////////////////////////////////////////////////////////////// template <typename ...Views> class any_image_view : public variant2::variant<Views...> { using parent_t = variant2::variant<Views...>; public: using const_t = detail::views_get_const_t<any_image_view>; using x_coord_t = std::ptrdiff_t; using y_coord_t = std::ptrdiff_t; using point_t = point<std::ptrdiff_t>; using size_type = std::size_t; any_image_view() = default; any_image_view(any_image_view const& view) : parent_t((parent_t const&)view) {} template <typename View> explicit any_image_view(View const& view) : parent_t(view) {} template <typename ...OtherViews> any_image_view(any_image_view<OtherViews...> const& view) : parent_t((variant2::variant<OtherViews...> const&)view) {} any_image_view& operator=(any_image_view const& view) { parent_t::operator=((parent_t const&)view); return this; } template <typename View> any_image_view& operator=(View const& view) { parent_t::operator=(view); return this; } template <typename ...OtherViews> any_image_view& operator=(any_image_view<OtherViews...> const& view) { parent_t::operator=((variant2::variant<OtherViews...> const&)view); return this; } std::size_t num_channels() const { return apply_operation(this, detail::any_type_get_num_channels()); } point_t dimensions() const { return apply_operation(this, detail::any_type_get_dimensions()); } size_type size() const { return apply_operation(this, detail::any_type_get_size()); } x_coord_t width() const { return dimensions().x; } y_coord_t height() const { return dimensions().y; } }; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename ...Views> struct dynamic_x_step_type<any_image_view<Views...>> { private: // FIXME: Remove class name injection with gil:: qualification // Required as workaround for Boost.MP11 issue that treats unqualified metafunction // in the class definition of the same name as the specialization (Peter Dimov): // invalid template argument for template parameter 'F', expected a class template template <typename T> using dynamic_step_view = typename gil::dynamic_x_step_type<T>::type; public: using type = mp11::mp_transform<dynamic_step_view, any_image_view<Views...>>; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template <typename ...Views> struct dynamic_y_step_type<any_image_view<Views...>> { private: // FIXME: Remove class name injection with gil:: qualification // Required as workaround for Boost.MP11 issue that treats unqualified metafunction // in the class definition of the same name as the specialization (Peter Dimov): // invalid template argument for template parameter 'F', expected a class template template <typename T> using dynamic_step_view = typename gil::dynamic_y_step_type<T>::type; public: using type = mp11::mp_transform<dynamic_step_view, any_image_view<Views...>>; }; template <typename ...Views> struct dynamic_xy_step_type<any_image_view<Views...>> { private: // FIXME: Remove class name injection with gil:: qualification // Required as workaround for Boost.MP11 issue that treats unqualified metafunction // in the class definition of the same name as the specialization (Peter Dimov): // invalid template argument for template parameter 'F', expected a class template template <typename T> using dynamic_step_view = typename gil::dynamic_xy_step_type<T>::type; public: using type = mp11::mp_transform<dynamic_step_view, any_image_view<Views...>>; }; template <typename ...Views> struct dynamic_xy_step_transposed_type<any_image_view<Views...>> { private: // FIXME: Remove class name injection with gil:: qualification // Required as workaround for Boost.MP11 issue that treats unqualified metafunction // in the class definition of the same name as the specialization (Peter Dimov): // invalid template argument for template parameter 'F', expected a class template template <typename T> using dynamic_step_view = typename gil::dynamic_xy_step_type<T>::type; public: using type = mp11::mp_transform<dynamic_step_view, any_image_view<Views...>>; }; }} // namespace boost::gil #endif PK��p�[g��K��+��extension/dynamic_image/apply_operation.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_APPLY_OPERATION_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_APPLY_OPERATION_HPP #include <boost/variant2/variant.hpp> namespace boost { namespace gil { /// \ingroup Variant /// \brief Applies the visitor op to the variants template <typename Variant1, typename Visitor> BOOST_FORCEINLINE auto apply_operation(Variant1&& arg1, Visitor&& op) #if defined(BOOST_NO_CXX14_DECLTYPE_AUTO) \|\| defined(BOOST_NO_CXX11_DECLTYPE_N3276) -> decltype(variant2::visit(std::forward<Visitor>(op), std::forward<Variant1>(arg1))) #endif { return variant2::visit(std::forward<Visitor>(op), std::forward<Variant1>(arg1)); } /// \ingroup Variant /// \brief Applies the visitor op to the variants template <typename Variant1, typename Variant2, typename Visitor> BOOST_FORCEINLINE auto apply_operation(Variant1&& arg1, Variant2&& arg2, Visitor&& op) #if defined(BOOST_NO_CXX14_DECLTYPE_AUTO) \|\| defined(BOOST_NO_CXX11_DECLTYPE_N3276) -> decltype(variant2::visit(std::forward<Visitor>(op), std::forward<Variant1>(arg1), std::forward<Variant2>(arg2))) #endif { return variant2::visit(std::forward<Visitor>(op), std::forward<Variant1>(arg1), std::forward<Variant2>(arg2)); } }} // namespace boost::gil #endif PK��p�[�nְ_��_��%��extension/dynamic_image/any_image.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2020 Samuel Debionne // // 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_EXTENSION_DYNAMIC_IMAGE_ANY_IMAGE_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_ANY_IMAGE_HPP #include <boost/gil/extension/dynamic_image/any_image_view.hpp> #include <boost/gil/extension/dynamic_image/apply_operation.hpp> #include <boost/gil/image.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/config.hpp> #include <boost/variant2/variant.hpp> #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace boost { namespace gil { namespace detail { template <typename T> using get_view_t = typename T::view_t; template <typename Images> using images_get_views_t = mp11::mp_transform<get_view_t, Images>; template <typename T> using get_const_view_t = typename T::const_view_t; template <typename Images> using images_get_const_views_t = mp11::mp_transform<get_const_view_t, Images>; struct recreate_image_fnobj { using result_type = void; point<std::ptrdiff_t> const& _dimensions; unsigned _alignment; recreate_image_fnobj(point<std::ptrdiff_t> const& dims, unsigned alignment) : _dimensions(dims), _alignment(alignment) {} template <typename Image> result_type operator()(Image& img) const { img.recreate(_dimensions,_alignment); } }; template <typename AnyView> // Models AnyViewConcept struct any_image_get_view { using result_type = AnyView; template <typename Image> result_type operator()(Image& img) const { return result_type(view(img)); } }; template <typename AnyConstView> // Models AnyConstViewConcept struct any_image_get_const_view { using result_type = AnyConstView; template <typename Image> result_type operator()(Image const& img) const { return result_type{const_view(img)}; } }; } // namespce detail //////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ImageModel /// \brief Represents a run-time specified image. Note it does NOT model ImageConcept /// /// Represents an image whose type (color space, layout, planar/interleaved organization, etc) can be specified at run time. /// It is the runtime equivalent of \p image. /// Some of the requirements of ImageConcept, such as the \p value_type alias cannot be fulfilled, since the language does not allow runtime type specification. /// Other requirements, such as access to the pixels, would be inefficient to provide. Thus \p any_image does not fully model ImageConcept. /// In particular, its \p view and \p const_view methods return \p any_image_view, which does not fully model ImageViewConcept. See \p any_image_view for more. //////////////////////////////////////////////////////////////////////////////////////// template <typename ...Images> class any_image : public variant2::variant<Images...> { using parent_t = variant2::variant<Images...>; public: using view_t = mp11::mp_rename<detail::images_get_views_t<any_image>, any_image_view>; using const_view_t = mp11::mp_rename<detail::images_get_const_views_t<any_image>, any_image_view>; using x_coord_t = std::ptrdiff_t; using y_coord_t = std::ptrdiff_t; using point_t = point<std::ptrdiff_t>; any_image() = default; any_image(any_image const& img) : parent_t((parent_t const&)img) {} template <typename Image> explicit any_image(Image const& img) : parent_t(img) {} template <typename Image> any_image(Image&& img) : parent_t(std::move(img)) {} template <typename Image> explicit any_image(Image& img, bool do_swap) : parent_t(img, do_swap) {} template <typename ...OtherImages> any_image(any_image<OtherImages...> const& img) : parent_t((variant2::variant<OtherImages...> const&)img) {} any_image& operator=(any_image const& img) { parent_t::operator=((parent_t const&)img); return this; } template <typename Image> any_image& operator=(Image const& img) { parent_t::operator=(img); return this; } template <typename ...OtherImages> any_image& operator=(any_image<OtherImages...> const& img) { parent_t::operator=((typename variant2::variant<OtherImages...> const&)img); return this; } void recreate(const point_t& dims, unsigned alignment=1) { apply_operation(this, detail::recreate_image_fnobj(dims, alignment)); } void recreate(x_coord_t width, y_coord_t height, unsigned alignment=1) { recreate({ width, height }, alignment); } std::size_t num_channels() const { return apply_operation(this, detail::any_type_get_num_channels()); } point_t dimensions() const { return apply_operation(this, detail::any_type_get_dimensions()); } x_coord_t width() const { return dimensions().x; } y_coord_t height() const { return dimensions().y; } }; ///@{ /// \name view, const_view /// \brief Get an image view from a run-time instantiated image /// \ingroup ImageModel /// \brief Returns the non-constant-pixel view of any image. The returned view is any view. /// \tparam Images Models ImageVectorConcept template <typename ...Images> BOOST_FORCEINLINE auto view(any_image<Images...>& img) -> typename any_image<Images...>::view_t { using view_t = typename any_image<Images...>::view_t; return apply_operation(img, detail::any_image_get_view<view_t>()); } /// \brief Returns the constant-pixel view of any image. The returned view is any view. /// \tparam Types Models ImageVectorConcept template <typename ...Images> BOOST_FORCEINLINE auto const_view(any_image<Images...> const& img) -> typename any_image<Images...>::const_view_t { using view_t = typename any_image<Images...>::const_view_t; return apply_operation(img, detail::any_image_get_const_view<view_t>()); } ///@} }} // namespace boost::gil #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif #endif PK��p�[�c�E�7��7��.��extension/dynamic_image/image_view_factory.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_IMAGE_VIEW_FACTORY_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_IMAGE_VIEW_FACTORY_HPP #include <boost/gil/extension/dynamic_image/any_image_view.hpp> #include <boost/gil/dynamic_step.hpp> #include <boost/gil/image_view_factory.hpp> #include <boost/gil/point.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstdint> namespace boost { namespace gil { // Methods for constructing any image views from other any image views // Extends image view factory to runtime type-specified views (any_image_view) namespace detail { template <typename ResultView> struct flipped_up_down_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{flipped_up_down_view(src)}; } }; template <typename ResultView> struct flipped_left_right_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{flipped_left_right_view(src)}; } }; template <typename ResultView> struct rotated90cw_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{rotated90cw_view(src)}; } }; template <typename ResultView> struct rotated90ccw_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{rotated90ccw_view(src)}; } }; template <typename ResultView> struct tranposed_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{tranposed_view(src)}; } }; template <typename ResultView> struct rotated180_view_fn { using result_type = ResultView; template <typename View> auto operator()(View const& src) const -> result_type { return result_type{rotated180_view(src)}; } }; template <typename ResultView> struct subimage_view_fn { using result_type = ResultView; subimage_view_fn(point_t const& topleft, point_t const& dimensions) : _topleft(topleft), _size2(dimensions) {} template <typename View> auto operator()(View const& src) const -> result_type { return result_type{subimage_view(src,_topleft,_size2)}; } point_t _topleft; point_t _size2; }; template <typename ResultView> struct subsampled_view_fn { using result_type = ResultView; subsampled_view_fn(point_t const& step) : _step(step) {} template <typename View> auto operator()(View const& src) const -> result_type { return result_type{subsampled_view(src,_step)}; } point_t _step; }; template <typename ResultView> struct nth_channel_view_fn { using result_type = ResultView; nth_channel_view_fn(int n) : _n(n) {} template <typename View> auto operator()(View const& src) const -> result_type { return result_type(nth_channel_view(src,_n)); } int _n; }; template <typename DstP, typename ResultView, typename CC = default_color_converter> struct color_converted_view_fn { using result_type = ResultView; color_converted_view_fn(CC cc = CC()): _cc(cc) {} template <typename View> auto operator()(View const& src) const -> result_type { return result_type{color_converted_view<DstP>(src, _cc)}; } private: CC _cc; }; } // namespace detail /// \ingroup ImageViewTransformationsFlipUD /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto flipped_up_down_view(any_image_view<Views...> const& src) -> typename dynamic_y_step_type<any_image_view<Views...>>::type { using result_view_t = typename dynamic_y_step_type<any_image_view<Views...>>::type; return apply_operation(src, detail::flipped_up_down_view_fn<result_view_t>()); } /// \ingroup ImageViewTransformationsFlipLR /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto flipped_left_right_view(any_image_view<Views...> const& src) -> typename dynamic_x_step_type<any_image_view<Views...>>::type { using result_view_t = typename dynamic_x_step_type<any_image_view<Views...>>::type; return apply_operation(src, detail::flipped_left_right_view_fn<result_view_t>()); } /// \ingroup ImageViewTransformationsTransposed /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto transposed_view(const any_image_view<Views...>& src) -> typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type { using result_view_t = typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type; return apply_operation(src, detail::tranposed_view_fn<result_view_t>()); } /// \ingroup ImageViewTransformations90CW /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto rotated90cw_view(const any_image_view<Views...>& src) -> typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type { using result_view_t = typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type; return apply_operation(src,detail::rotated90cw_view_fn<result_view_t>()); } /// \ingroup ImageViewTransformations90CCW /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto rotated90ccw_view(const any_image_view<Views...>& src) -> typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type { return apply_operation(src,detail::rotated90ccw_view_fn<typename dynamic_xy_step_transposed_type<any_image_view<Views...>>::type>()); } /// \ingroup ImageViewTransformations180 /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto rotated180_view(any_image_view<Views...> const& src) -> typename dynamic_xy_step_type<any_image_view<Views...>>::type { using step_type = typename dynamic_xy_step_type<any_image_view<Views...>>::type; return apply_operation(src, detail::rotated180_view_fn<step_type>()); } /// \ingroup ImageViewTransformationsSubimage /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto subimage_view( any_image_view<Views...> const& src, point_t const& topleft, point_t const& dimensions) -> any_image_view<Views...> { using subimage_view_fn = detail::subimage_view_fn<any_image_view<Views...>>; return apply_operation(src, subimage_view_fn(topleft, dimensions)); } /// \ingroup ImageViewTransformationsSubimage /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto subimage_view( any_image_view<Views...> const& src, std::ptrdiff_t x_min, std::ptrdiff_t y_min, std::ptrdiff_t width, std::ptrdiff_t height) -> any_image_view<Views...> { using subimage_view_fn = detail::subimage_view_fn<any_image_view<Views...>>; return apply_operation(src, subimage_view_fn(point_t(x_min, y_min),point_t(width, height))); } /// \ingroup ImageViewTransformationsSubsampled /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto subsampled_view(any_image_view<Views...> const& src, point_t const& step) -> typename dynamic_xy_step_type<any_image_view<Views...>>::type { using step_type = typename dynamic_xy_step_type<any_image_view<Views...>>::type; using subsampled_view = detail::subsampled_view_fn<step_type>; return apply_operation(src, subsampled_view(step)); } /// \ingroup ImageViewTransformationsSubsampled /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto subsampled_view(any_image_view<Views...> const& src, std::ptrdiff_t x_step, std::ptrdiff_t y_step) -> typename dynamic_xy_step_type<any_image_view<Views...>>::type { using step_type = typename dynamic_xy_step_type<any_image_view<Views...>>::type; using subsampled_view_fn = detail::subsampled_view_fn<step_type>; return apply_operation(src, subsampled_view_fn(point_t(x_step, y_step))); } namespace detail { template <typename View> struct get_nthchannel_type { using type = typename nth_channel_view_type<View>::type; }; template <typename Views> struct views_get_nthchannel_type : mp11::mp_transform<get_nthchannel_type, Views> {}; } // namespace detail /// \ingroup ImageViewTransformationsNthChannel /// \brief Given a runtime source image view, returns the type of a runtime image view over a single channel of the source view template <typename ...Views> struct nth_channel_view_type<any_image_view<Views...>> { using type = typename detail::views_get_nthchannel_type<any_image_view<Views...>>; }; /// \ingroup ImageViewTransformationsNthChannel /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename ...Views> inline auto nth_channel_view(const any_image_view<Views...>& src, int n) -> typename nth_channel_view_type<any_image_view<Views...>>::type { using result_view_t = typename nth_channel_view_type<any_image_view<Views...>>::type; return apply_operation(src,detail::nth_channel_view_fn<result_view_t>(n)); } namespace detail { template <typename View, typename DstP, typename CC> struct get_ccv_type : color_converted_view_type<View, DstP, CC> {}; template <typename Views, typename DstP, typename CC> struct views_get_ccv_type { private: // FIXME: Remove class name injection with detail:: qualification // Required as workaround for MP11 issue that treats unqualified metafunction // in the class definition of the same name as the specialization (Peter Dimov): // invalid template argument for template parameter 'F', expected a class template template <typename T> using ccvt = detail::get_ccv_type<T, DstP, CC>; public: using type = mp11::mp_transform<ccvt, Views>; }; } // namespace detail /// \ingroup ImageViewTransformationsColorConvert /// \brief Returns the type of a runtime-specified view, color-converted to a given pixel type with user specified color converter template <typename ...Views, typename DstP, typename CC> struct color_converted_view_type<any_image_view<Views...>,DstP,CC> { //using type = any_image_view<typename detail::views_get_ccv_type<Views, DstP, CC>::type>; using type = detail::views_get_ccv_type<any_image_view<Views...>, DstP, CC>; }; /// \ingroup ImageViewTransformationsColorConvert /// \brief overload of generic color_converted_view with user defined color-converter /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename DstP, typename ...Views, typename CC> inline auto color_converted_view(const any_image_view<Views...>& src, CC) -> typename color_converted_view_type<any_image_view<Views...>, DstP, CC>::type { using cc_view_t = typename color_converted_view_type<any_image_view<Views...>, DstP, CC>::type; return apply_operation(src, detail::color_converted_view_fn<DstP, cc_view_t>()); } /// \ingroup ImageViewTransformationsColorConvert /// \brief Returns the type of a runtime-specified view, color-converted to a given pixel type with the default coor converter template <typename ...Views, typename DstP> struct color_converted_view_type<any_image_view<Views...>,DstP> { using type = detail::views_get_ccv_type<any_image_view<Views...>, DstP, default_color_converter>; }; /// \ingroup ImageViewTransformationsColorConvert /// \brief overload of generic color_converted_view with the default color-converter /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename DstP, typename ...Views> inline auto color_converted_view(any_image_view<Views...> const& src) -> typename color_converted_view_type<any_image_view<Views...>, DstP>::type { using cc_view_t = typename color_converted_view_type<any_image_view<Views...>, DstP>::type; return apply_operation(src, detail::color_converted_view_fn<DstP, cc_view_t>()); } /// \ingroup ImageViewTransformationsColorConvert /// \brief overload of generic color_converted_view with user defined color-converter /// These are workarounds for GCC 3.4, which thinks color_converted_view is ambiguous with the same method for templated views (in gil/image_view_factory.hpp) /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename DstP, typename ...Views, typename CC> inline auto any_color_converted_view(const any_image_view<Views...>& src, CC) -> typename color_converted_view_type<any_image_view<Views...>, DstP, CC>::type { using cc_view_t = typename color_converted_view_type<any_image_view<Views...>, DstP, CC>::type; return apply_operation(src, detail::color_converted_view_fn<DstP, cc_view_t>()); } /// \ingroup ImageViewTransformationsColorConvert /// \brief overload of generic color_converted_view with the default color-converter /// These are workarounds for GCC 3.4, which thinks color_converted_view is ambiguous with the same method for templated views (in gil/image_view_factory.hpp) /// \tparam Views Models Boost.MP11-compatible list of models of ImageViewConcept template <typename DstP, typename ...Views> inline auto any_color_converted_view(const any_image_view<Views...>& src) -> typename color_converted_view_type<any_image_view<Views...>, DstP>::type { using cc_view_t = typename color_converted_view_type<any_image_view<Views...>, DstP>::type; return apply_operation(src, detail::color_converted_view_fn<DstP, cc_view_t>()); } /// \} }} // namespace boost::gil #endif PK��p�[��X#��#��(��extension/dynamic_image/dynamic_at_c.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_DYNAMIC_IMAGE_DYNAMIC_AT_C_HPP #define BOOST_GIL_EXTENSION_DYNAMIC_IMAGE_DYNAMIC_AT_C_HPP #include <boost/gil/detail/mp11.hpp> #include <boost/preprocessor/facilities/empty.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <stdexcept> namespace boost { namespace gil { // Constructs for static-to-dynamic integer convesion #define BOOST_GIL_AT_C_VALUE(z, N, text) mp11::mp_at_c<IntTypes, S+N>::value, #define BOOST_GIL_DYNAMIC_AT_C_LIMIT 226 // size of the maximum vector to handle #define BOOST_GIL_AT_C_LOOKUP(z, NUM, text) \ template<std::size_t S> \ struct at_c_fn<S,NUM> { \ template <typename IntTypes, typename ValueType> inline \ static ValueType apply(std::size_t index) { \ static ValueType table[] = { \ BOOST_PP_REPEAT(NUM, BOOST_GIL_AT_C_VALUE, BOOST_PP_EMPTY) \ }; \ return table[index]; \ } \ }; namespace detail { namespace at_c { template <std::size_t START, std::size_t NUM> struct at_c_fn; BOOST_PP_REPEAT(BOOST_GIL_DYNAMIC_AT_C_LIMIT, BOOST_GIL_AT_C_LOOKUP, BOOST_PP_EMPTY) template <std::size_t QUOT> struct at_c_impl; template <> struct at_c_impl<0> { template <typename IntTypes, typename ValueType> inline static ValueType apply(std::size_t index) { return at_c_fn<0, mp11::mp_size<IntTypes>::value>::template apply<IntTypes,ValueType>(index); } }; template <> struct at_c_impl<1> { template <typename IntTypes, typename ValueType> inline static ValueType apply(std::size_t index) { const std::size_t SIZE = mp11::mp_size<IntTypes>::value; const std::size_t REM = SIZE % BOOST_GIL_DYNAMIC_AT_C_LIMIT; switch (index / BOOST_GIL_DYNAMIC_AT_C_LIMIT) { case 0: return at_c_fn<0 ,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); case 1: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT ,REM >::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT); }; throw; } }; template <> struct at_c_impl<2> { template <typename IntTypes, typename ValueType> inline static ValueType apply(std::size_t index) { const std::size_t SIZE = mp11::mp_size<IntTypes>::value; const std::size_t REM = SIZE % BOOST_GIL_DYNAMIC_AT_C_LIMIT; switch (index / BOOST_GIL_DYNAMIC_AT_C_LIMIT) { case 0: return at_c_fn<0 ,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); case 1: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT ,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT); case 2: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT2,REM >::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT2); }; throw; } }; template <> struct at_c_impl<3> { template <typename IntTypes, typename ValueType> inline static ValueType apply(std::size_t index) { const std::size_t SIZE = mp11::mp_size<IntTypes>::value; const std::size_t REM = SIZE % BOOST_GIL_DYNAMIC_AT_C_LIMIT; switch (index / BOOST_GIL_DYNAMIC_AT_C_LIMIT) { case 0: return at_c_fn<0 ,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index); case 1: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT ,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT); case 2: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT2,BOOST_GIL_DYNAMIC_AT_C_LIMIT-1>::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT2); case 3: return at_c_fn<BOOST_GIL_DYNAMIC_AT_C_LIMIT3,REM >::template apply<IntTypes,ValueType>(index - BOOST_GIL_DYNAMIC_AT_C_LIMIT3); }; throw; } }; } } //////////////////////////////////////////////////////////////////////////////////// /// /// \brief Given an Boost.MP11-compatible list and a dynamic index n, /// returns the value of the n-th element. /// It constructs a lookup table at compile time. /// //////////////////////////////////////////////////////////////////////////////////// template <typename IntTypes, typename ValueType> inline ValueType at_c(std::size_t index) { const std::size_t Size=mp11::mp_size<IntTypes>::value; return detail::at_c::at_c_impl<Size/BOOST_GIL_DYNAMIC_AT_C_LIMIT>::template apply<IntTypes,ValueType>(index); } #undef BOOST_GIL_AT_C_VALUE #undef BOOST_GIL_DYNAMIC_AT_C_LIMIT #undef BOOST_GIL_AT_C_LOOKUP }} // namespace boost::gil #endif PK��p�[�p�'��'��extension/numeric/kernel.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Miral Shah <miralshah2211@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_EXTENSION_NUMERIC_KERNEL_HPP #define BOOST_GIL_EXTENSION_NUMERIC_KERNEL_HPP #include <boost/gil/utilities.hpp> #include <boost/gil/point.hpp> #include <boost/assert.hpp> #include <algorithm> #include <array> #include <cstddef> #include <memory> #include <vector> #include <cmath> #include <stdexcept> namespace boost { namespace gil { // Definitions of 1D fixed-size and variable-size kernels and related operations namespace detail { /// \brief kernel adaptor for one-dimensional cores /// Core needs to provide size(),begin(),end(),operator[], /// value_type,iterator,const_iterator,reference,const_reference template <typename Core> class kernel_1d_adaptor : public Core { public: kernel_1d_adaptor() = default; explicit kernel_1d_adaptor(std::size_t center) : center_(center) { BOOST_ASSERT(center_ < this->size()); } kernel_1d_adaptor(std::size_t size, std::size_t center) : Core(size) , center_(center) { BOOST_ASSERT(this->size() > 0); BOOST_ASSERT(center_ < this->size()); // also implies `size() > 0` } kernel_1d_adaptor(kernel_1d_adaptor const& other) : Core(other), center_(other.center_) { BOOST_ASSERT(this->size() > 0); BOOST_ASSERT(center_ < this->size()); // also implies `size() > 0` } kernel_1d_adaptor& operator=(kernel_1d_adaptor const& other) { Core::operator=(other); center_ = other.center_; return this; } std::size_t left_size() const { BOOST_ASSERT(center_ < this->size()); return center_; } std::size_t right_size() const { BOOST_ASSERT(center_ < this->size()); return this->size() - center_ - 1; } auto center() -> std::size_t& { BOOST_ASSERT(center_ < this->size()); return center_; } auto center() const -> std::size_t const& { BOOST_ASSERT(center_ < this->size()); return center_; } private: std::size_t center_{0}; }; } // namespace detail /// \brief variable-size kernel template <typename T, typename Allocator = std::allocator<T> > class kernel_1d : public detail::kernel_1d_adaptor<std::vector<T, Allocator>> { using parent_t = detail::kernel_1d_adaptor<std::vector<T, Allocator>>; public: kernel_1d() = default; kernel_1d(std::size_t size, std::size_t center) : parent_t(size, center) {} template <typename FwdIterator> kernel_1d(FwdIterator elements, std::size_t size, std::size_t center) : parent_t(size, center) { detail::copy_n(elements, size, this->begin()); } kernel_1d(kernel_1d const& other) : parent_t(other) {} kernel_1d& operator=(kernel_1d const& other) = default; }; /// \brief static-size kernel template <typename T,std::size_t Size> class kernel_1d_fixed : public detail::kernel_1d_adaptor<std::array<T, Size>> { using parent_t = detail::kernel_1d_adaptor<std::array<T, Size>>; public: static constexpr std::size_t static_size = Size; static_assert(static_size > 0, "kernel must have size greater than 0"); static_assert(static_size % 2 == 1, "kernel size must be odd to ensure validity at the center"); kernel_1d_fixed() = default; explicit kernel_1d_fixed(std::size_t center) : parent_t(center) {} template <typename FwdIterator> explicit kernel_1d_fixed(FwdIterator elements, std::size_t center) : parent_t(center) { detail::copy_n(elements, Size, this->begin()); } kernel_1d_fixed(kernel_1d_fixed const& other) : parent_t(other) {} kernel_1d_fixed& operator=(kernel_1d_fixed const& other) = default; }; // TODO: This data member is odr-used and definition at namespace scope // is required by C++11. Redundant and deprecated in C++17. template <typename T,std::size_t Size> constexpr std::size_t kernel_1d_fixed<T, Size>::static_size; /// \brief reverse a kernel template <typename Kernel> inline Kernel reverse_kernel(Kernel const& kernel) { Kernel result(kernel); result.center() = kernel.right_size(); std::reverse(result.begin(), result.end()); return result; } namespace detail { template <typename Core> class kernel_2d_adaptor : public Core { public: kernel_2d_adaptor() = default; explicit kernel_2d_adaptor(std::size_t center_y, std::size_t center_x) : center_(center_x, center_y) { BOOST_ASSERT(center_.y < this->size() && center_.x < this->size()); } kernel_2d_adaptor(std::size_t size, std::size_t center_y, std::size_t center_x) : Core(size size), square_size(size), center_(center_x, center_y) { BOOST_ASSERT(this->size() > 0); BOOST_ASSERT(center_.y < this->size() && center_.x < this->size()); // implies `size() > 0` } kernel_2d_adaptor(kernel_2d_adaptor const& other) : Core(other), square_size(other.square_size), center_(other.center_.x, other.center_.y) { BOOST_ASSERT(this->size() > 0); BOOST_ASSERT(center_.y < this->size() && center_.x < this->size()); // implies `size() > 0` } kernel_2d_adaptor& operator=(kernel_2d_adaptor const& other) { Core::operator=(other); center_.y = other.center_.y; center_.x = other.center_.x; square_size = other.square_size; return this; } std::size_t upper_size() const { BOOST_ASSERT(center_.y < this->size()); return center_.y; } std::size_t lower_size() const { BOOST_ASSERT(center_.y < this->size()); return this->size() - center_.y - 1; } std::size_t left_size() const { BOOST_ASSERT(center_.x < this->size()); return center_.x; } std::size_t right_size() const { BOOST_ASSERT(center_.x < this->size()); return this->size() - center_.x - 1; } auto center_y() -> std::size_t& { BOOST_ASSERT(center_.y < this->size()); return center_.y; } auto center_y() const -> std::size_t const& { BOOST_ASSERT(center_.y < this->size()); return center_.y; } auto center_x() -> std::size_t& { BOOST_ASSERT(center_.x < this->size()); return center_.x; } auto center_x() const -> std::size_t const& { BOOST_ASSERT(center_.x < this->size()); return center_.x; } std::size_t size() const { return square_size; } typename Core::value_type at(std::size_t x, std::size_t y) const { if (x >= this->size() \|\| y >= this->size()) { throw std::out_of_range("Index out of range"); } return this->begin()[y this->size() + x]; } protected: std::size_t square_size{0}; private: point<std::size_t> center_{0, 0}; }; /// \brief variable-size kernel template < typename T, typename Allocator = std::allocator<T> > class kernel_2d : public detail::kernel_2d_adaptor<std::vector<T, Allocator>> { using parent_t = detail::kernel_2d_adaptor<std::vector<T, Allocator>>; public: kernel_2d() = default; kernel_2d(std::size_t size,std::size_t center_y, std::size_t center_x) : parent_t(size, center_y, center_x) {} template <typename FwdIterator> kernel_2d(FwdIterator elements, std::size_t size, std::size_t center_y, std::size_t center_x) : parent_t(static_cast<int>(std::sqrt(size)), center_y, center_x) { detail::copy_n(elements, size, this->begin()); } kernel_2d(kernel_2d const& other) : parent_t(other) {} kernel_2d& operator=(kernel_2d const& other) = default; }; /// \brief static-size kernel template <typename T, std::size_t Size> class kernel_2d_fixed : public detail::kernel_2d_adaptor<std::array<T, Size * Size>> { using parent_t = detail::kernel_2d_adaptor<std::array<T, Size * Size>>; public: static constexpr std::size_t static_size = Size; static_assert(static_size > 0, "kernel must have size greater than 0"); static_assert(static_size % 2 == 1, "kernel size must be odd to ensure validity at the center"); kernel_2d_fixed() { this->square_size = Size; } explicit kernel_2d_fixed(std::size_t center_y, std::size_t center_x) : parent_t(center_y, center_x) { this->square_size = Size; } template <typename FwdIterator> explicit kernel_2d_fixed(FwdIterator elements, std::size_t center_y, std::size_t center_x) : parent_t(center_y, center_x) { this->square_size = Size; detail::copy_n(elements, Size * Size, this->begin()); } kernel_2d_fixed(kernel_2d_fixed const& other) : parent_t(other) {} kernel_2d_fixed& operator=(kernel_2d_fixed const& other) = default; }; // TODO: This data member is odr-used and definition at namespace scope // is required by C++11. Redundant and deprecated in C++17. template <typename T, std::size_t Size> constexpr std::size_t kernel_2d_fixed<T, Size>::static_size; template <typename Kernel> inline Kernel reverse_kernel_2d(Kernel const& kernel) { Kernel result(kernel); result.center_x() = kernel.lower_size(); result.center_y() = kernel.right_size(); std::reverse(result.begin(), result.end()); return result; } /// \brief reverse a kernel_2d template<typename T, typename Allocator> inline kernel_2d<T, Allocator> reverse_kernel(kernel_2d<T, Allocator> const& kernel) { return reverse_kernel_2d(kernel); } /// \brief reverse a kernel_2d template<typename T, std::size_t Size> inline kernel_2d_fixed<T, Size> reverse_kernel(kernel_2d_fixed<T, Size> const& kernel) { return reverse_kernel_2d(kernel); } } //namespace detail }} // namespace boost::gil #endif PK��p�[�p��extension/numeric/resample.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_NUMERIC_RESAMPLE_HPP #define BOOST_GIL_EXTENSION_NUMERIC_RESAMPLE_HPP #include <boost/gil/extension/numeric/affine.hpp> #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp> #include <algorithm> #include <functional> namespace boost { namespace gil { // Support for generic image resampling // NOTE: The code is for example use only. It is not optimized for performance /////////////////////////////////////////////////////////////////////////// //// //// resample_pixels: set each pixel in the destination view as the result of a sampling function over the transformed coordinates of the source view //// /////////////////////////////////////////////////////////////////////////// template <typename MapFn> struct mapping_traits {}; /// \brief Set each pixel in the destination view as the result of a sampling function over the transformed coordinates of the source view /// \ingroup ImageAlgorithms /// /// The provided implementation works for 2D image views only template <typename Sampler, // Models SamplerConcept typename SrcView, // Models RandomAccess2DImageViewConcept typename DstView, // Models MutableRandomAccess2DImageViewConcept typename MapFn> // Models MappingFunctionConcept void resample_pixels(const SrcView& src_view, const DstView& dst_view, const MapFn& dst_to_src, Sampler sampler=Sampler()) { typename DstView::point_t dst_dims=dst_view.dimensions(); typename DstView::point_t dst_p; for (dst_p.y=0; dst_p.y<dst_dims.y; ++dst_p.y) { typename DstView::x_iterator xit = dst_view.row_begin(dst_p.y); for (dst_p.x=0; dst_p.x<dst_dims.x; ++dst_p.x) { sample(sampler, src_view, transform(dst_to_src, dst_p), xit[dst_p.x]); } } } /////////////////////////////////////////////////////////////////////////// //// //// resample_pixels when one or both image views are run-time instantiated. //// /////////////////////////////////////////////////////////////////////////// namespace detail { template <typename Sampler, typename MapFn> struct resample_pixels_fn : public binary_operation_obj<resample_pixels_fn<Sampler,MapFn> > { MapFn _dst_to_src; Sampler _sampler; resample_pixels_fn(const MapFn& dst_to_src, const Sampler& sampler) : _dst_to_src(dst_to_src), _sampler(sampler) {} template <typename SrcView, typename DstView> BOOST_FORCEINLINE void apply_compatible(const SrcView& src, const DstView& dst) const { resample_pixels(src, dst, _dst_to_src, _sampler); } }; } /// \brief resample_pixels when the source is run-time specified /// If invoked on incompatible views, throws std::bad_cast() /// \ingroup ImageAlgorithms template <typename Sampler, typename ...Types1, typename V2, typename MapFn> void resample_pixels(const any_image_view<Types1...>& src, const V2& dst, const MapFn& dst_to_src, Sampler sampler=Sampler()) { apply_operation(src, std::bind( detail::resample_pixels_fn<Sampler, MapFn>(dst_to_src, sampler), std::placeholders::_1, dst)); } /// \brief resample_pixels when the destination is run-time specified /// If invoked on incompatible views, throws std::bad_cast() /// \ingroup ImageAlgorithms template <typename Sampler, typename V1, typename ...Types2, typename MapFn> void resample_pixels(const V1& src, const any_image_view<Types2...>& dst, const MapFn& dst_to_src, Sampler sampler=Sampler()) { using namespace std::placeholders; apply_operation(dst, std::bind( detail::resample_pixels_fn<Sampler, MapFn>(dst_to_src, sampler), src, std::placeholders::_1)); } /// \brief resample_pixels when both the source and the destination are run-time specified /// If invoked on incompatible views, throws std::bad_cast() /// \ingroup ImageAlgorithms template <typename Sampler, typename ...SrcTypes, typename ...DstTypes, typename MapFn> void resample_pixels(const any_image_view<SrcTypes...>& src, const any_image_view<DstTypes...>& dst, const MapFn& dst_to_src, Sampler sampler=Sampler()) { apply_operation(src,dst,detail::resample_pixels_fn<Sampler,MapFn>(dst_to_src,sampler)); } /////////////////////////////////////////////////////////////////////////// //// //// resample_subimage: copy into the destination a rotated rectangular region from the source, rescaling it to fit into the destination //// /////////////////////////////////////////////////////////////////////////// // Extract into dst the rotated bounds [src_min..src_max] rotated at 'angle' from the source view 'src' // The source coordinates are in the coordinate space of the source image // Note that the views could also be variants (i.e. any_image_view) template <typename Sampler, typename SrcMetaView, typename DstMetaView> void resample_subimage(const SrcMetaView& src, const DstMetaView& dst, double src_min_x, double src_min_y, double src_max_x, double src_max_y, double angle, const Sampler& sampler=Sampler()) { double src_width = std::max<double>(src_max_x - src_min_x - 1,1); double src_height = std::max<double>(src_max_y - src_min_y - 1,1); double dst_width = std::max<double>((double)(dst.width()-1),1); double dst_height = std::max<double>((double)(dst.height()-1),1); matrix3x2<double> mat = matrix3x2<double>::get_translate(-dst_width/2.0, -dst_height/2.0) * matrix3x2<double>::get_scale(src_width / dst_width, src_height / dst_height)* matrix3x2<double>::get_rotate(-angle)* matrix3x2<double>::get_translate(src_min_x + src_width/2.0, src_min_y + src_height/2.0); resample_pixels(src,dst,mat,sampler); } /////////////////////////////////////////////////////////////////////////// //// //// resize_view: Copy the source view into the destination, scaling to fit //// /////////////////////////////////////////////////////////////////////////// template <typename Sampler, typename SrcMetaView, typename DstMetaView> void resize_view(const SrcMetaView& src, const DstMetaView& dst, const Sampler& sampler=Sampler()) { resample_subimage(src,dst,0.0,0.0,(double)src.width(),(double)src.height(),0.0,sampler); } } } // namespace boost::gil #endif // BOOST_GIL_EXTENSION_NUMERIC_RESAMPLE_HPP PK��p�[U��X��X��extension/numeric/sampler.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_NUMERIC_SAMPLER_HPP #define BOOST_GIL_EXTENSION_NUMERIC_SAMPLER_HPP #include <boost/gil/extension/numeric/pixel_numeric_operations.hpp> #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp> namespace boost { namespace gil { // Nearest-neighbor and bilinear image samplers. // NOTE: The code is for example use only. It is not optimized for performance /////////////////////////////////////////////////////////////////////////// //// //// resample_pixels: set each pixel in the destination view as the result of a sampling function over the transformed coordinates of the source view //// /////////////////////////////////////////////////////////////////////////// /* template <typename Sampler> concept SamplerConcept { template <typename DstP, // Models PixelConcept typename SrcView, // Models RandomAccessNDImageViewConcept typename S_COORDS> // Models PointNDConcept, where S_COORDS::num_dimensions == SrcView::num_dimensions bool sample(const Sampler& s, const SrcView& src, const S_COORDS& p, DstP result); }; / /// \brief A sampler that sets the destination pixel to the closest one in the source. If outside the bounds, it doesn't change the destination /// \ingroup ImageAlgorithms struct nearest_neighbor_sampler {}; template <typename DstP, typename SrcView, typename F> bool sample(nearest_neighbor_sampler, SrcView const& src, point<F> const& p, DstP& result) { typename SrcView::point_t center(iround(p)); if (center.x >= 0 && center.y >= 0 && center.x < src.width() && center.y < src.height()) { result=src(center.x,center.y); return true; } return false; } struct cast_channel_fn { template <typename SrcChannel, typename DstChannel> void operator()(const SrcChannel& src, DstChannel& dst) { using dst_value_t = typename channel_traits<DstChannel>::value_type; dst = dst_value_t(src); } }; template <typename SrcPixel, typename DstPixel> void cast_pixel(const SrcPixel& src, DstPixel& dst) { static_for_each(src,dst,cast_channel_fn()); } namespace detail { template <typename Weight> struct add_dst_mul_src_channel { Weight _w; add_dst_mul_src_channel(Weight w) : _w(w) {} template <typename SrcChannel, typename DstChannel> void operator()(const SrcChannel& src, DstChannel& dst) const { dst += DstChannel(src_w); } }; // dst += DST_TYPE(src * w) template <typename SrcP,typename Weight,typename DstP> struct add_dst_mul_src { void operator()(const SrcP& src, Weight weight, DstP& dst) const { static_for_each(src,dst, add_dst_mul_src_channel<Weight>(weight)); // pixel_assigns_t<DstP,DstP&>()( // pixel_plus_t<DstP,DstP,DstP>()( // pixel_multiplies_scalar_t<SrcP,Weight,DstP>()(src,weight), // dst), // dst); } }; } // namespace detail /// \brief A sampler that sets the destination pixel as the bilinear interpolation of the four closest pixels from the source. /// If outside the bounds, it doesn't change the destination /// \ingroup ImageAlgorithms struct bilinear_sampler {}; template <typename DstP, typename SrcView, typename F> bool sample(bilinear_sampler, SrcView const& src, point<F> const& p, DstP& result) { using SrcP = typename SrcView::value_type; point_t p0(ifloor(p.x), ifloor(p.y)); // the closest integer coordinate top left from p point<F> frac(p.x-p0.x, p.y-p0.y); if (p0.x < -1 \|\| p0.y < -1 \|\| p0.x>=src.width() \|\| p0.y>=src.height()) { return false; } pixel<F,devicen_layout_t<num_channels<SrcView>::value> > mp(0); // suboptimal typename SrcView::xy_locator loc=src.xy_at(p0.x,p0.y); if (p0.x == -1) { if (p0.y == -1) { // the top-left corner pixel ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], 1 ,mp); } else if (p0.y+1<src.height()) { // on the first column, but not the top-left nor bottom-left corner pixel detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], (1-frac.y),mp); ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], frac.y ,mp); } else { // the bottom-left corner pixel detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], 1 ,mp); } } else if (p0.x+1<src.width()) { if (p0.y == -1) { // on the first row, but not the top-left nor top-right corner pixel ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, (1-frac.x) ,mp); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], frac.x ,mp); } else if (p0.y+1<src.height()) { // most common case - inside the image, not on the frist nor last row/column detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, (1-frac.x)(1-frac.y),mp); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], frac.x (1-frac.y),mp); ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, (1-frac.x) frac.y ,mp); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], frac.x * frac.y ,mp); } else { // on the last row, but not the bottom-left nor bottom-right corner pixel detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, (1-frac.x) ,mp); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc.x()[1], frac.x ,mp); } } else { if (p0.y == -1) { // the top-right corner pixel ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, 1 ,mp); } else if (p0.y+1<src.height()) { // on the last column, but not the top-right nor bottom-right corner pixel detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, (1-frac.y),mp); ++loc.y(); detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, frac.y ,mp); } else { // the bottom-right corner pixel detail::add_dst_mul_src<SrcP,F,pixel<F,devicen_layout_t<num_channels<SrcView>::value> > >()(loc, 1 ,mp); } } // Convert from floating point average value to the source type SrcP src_result; cast_pixel(mp,src_result); color_convert(src_result, result); return true; } }} // namespace boost::gil #endif PK��p�[�t}��extension/numeric/affine.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_NUMERIC_AFFINE_HPP #define BOOST_GIL_EXTENSION_NUMERIC_AFFINE_HPP #include <boost/gil/point.hpp> namespace boost { namespace gil { //////////////////////////////////////////////////////////////////////////////////////// /// /// Simple matrix to do 2D affine transformations. It is actually 3x3 but the last column is [0 0 1] /// //////////////////////////////////////////////////////////////////////////////////////// template <typename T> class matrix3x2 { public: matrix3x2() : a(1), b(0), c(0), d(1), e(0), f(0) {} matrix3x2(T A, T B, T C, T D, T E, T F) : a(A),b(B),c(C),d(D),e(E),f(F) {} matrix3x2(const matrix3x2& mat) : a(mat.a), b(mat.b), c(mat.c), d(mat.d), e(mat.e), f(mat.f) {} matrix3x2& operator=(const matrix3x2& m) { a=m.a; b=m.b; c=m.c; d=m.d; e=m.e; f=m.f; return this; } matrix3x2& operator=(const matrix3x2& m) { (this) = (this)m; return this; } static matrix3x2 get_rotate(T rads) { T c=std::cos(rads); T s=std::sin(rads); return matrix3x2(c,s,-s,c,0,0); } static matrix3x2 get_translate(point<T> const& t) { return matrix3x2(1, 0, 0, 1, t.x, t.y); } static matrix3x2 get_translate(T x, T y) { return matrix3x2(1 ,0,0,1 ,x, y ); } static matrix3x2 get_scale(point<T> const& s) { return matrix3x2(s.x, 0, 0, s.y, 0, 0); } static matrix3x2 get_scale(T x, T y) { return matrix3x2(x, 0,0,y, 0 ,0 ); } static matrix3x2 get_scale(T s) { return matrix3x2(s ,0,0,s ,0 ,0 ); } T a,b,c,d,e,f; }; template <typename T> BOOST_FORCEINLINE matrix3x2<T> operator(const matrix3x2<T>& m1, const matrix3x2<T>& m2) { return matrix3x2<T>( m1.a * m2.a + m1.b * m2.c, m1.a * m2.b + m1.b * m2.d, m1.c * m2.a + m1.d * m2.c, m1.c * m2.b + m1.d * m2.d, m1.e * m2.a + m1.f * m2.c + m2.e, m1.e * m2.b + m1.f * m2.d + m2.f ); } template <typename T, typename F> BOOST_FORCEINLINE point<F> operator(point<T> const& p, matrix3x2<F> const& m) { return { m.ap.x + m.cp.y + m.e, m.bp.x + m.dp.y + m.f }; } //////////////////////////////////////////////////////////////////////////////////////// /// Define affine mapping that transforms the source coordinates by the affine transformation //////////////////////////////////////////////////////////////////////////////////////// / template <typename MapFn> concept MappingFunctionConcept { typename mapping_traits<MapFn>::result_type; where PointNDConcept<result_type>; template <typename Domain> { where PointNDConcept<Domain> } result_type transform(MapFn&, const Domain& src); }; / template <typename T> struct mapping_traits; template <typename F> struct mapping_traits<matrix3x2<F>> { using result_type = point<F>; }; template <typename F, typename F2> BOOST_FORCEINLINE point<F> transform(matrix3x2<F> const& mat, point<F2> const& src) { return src mat; } }} // namespace boost::gil #endif PK��p�[��i��4��4��extension/numeric/algorithm.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 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_EXTENSION_NUMERIC_ALGORITHM_HPP #define BOOST_GIL_EXTENSION_NUMERIC_ALGORITHM_HPP #include <boost/gil/extension/numeric/pixel_numeric_operations.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/gil/image.hpp> #include <boost/assert.hpp> #include <algorithm> #include <iterator> #include <numeric> #include <type_traits> namespace boost { namespace gil { /// \brief Reference proxy associated with a type that has a \p "reference" member type alias. /// /// The reference proxy is the reference type, but with stripped-out C++ reference. /// Models PixelConcept. template <typename T> struct pixel_proxy : std::remove_reference<typename T::reference> {}; /// \brief std::for_each for a pair of iterators template <typename Iterator1, typename Iterator2, typename BinaryFunction> BinaryFunction for_each(Iterator1 first1, Iterator1 last1, Iterator2 first2, BinaryFunction f) { while (first1 != last1) f(first1++, first2++); return f; } template <typename SrcIterator, typename DstIterator> inline auto assign_pixels(SrcIterator src, SrcIterator src_end, DstIterator dst) -> DstIterator { for_each(src, src_end, dst, pixel_assigns_t < typename pixel_proxy<typename std::iterator_traits<SrcIterator>::value_type>::type, typename pixel_proxy<typename std::iterator_traits<DstIterator>::value_type>::type >()); return dst + (src_end - src); } namespace detail { template <std::size_t Size> struct inner_product_k_t { template < class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2 > static T apply( InputIterator1 first1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) { init = binary_op1(init, binary_op2(first1, first2)); return inner_product_k_t<Size - 1>::template apply( first1 + 1, first2 + 1, init, binary_op1, binary_op2); } }; template <> struct inner_product_k_t<0> { template < class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2 > static T apply( InputIterator1 first1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) { return init; } }; } // namespace detail /// static version of std::inner_product template < std::size_t Size, class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2 > BOOST_FORCEINLINE T inner_product_k( InputIterator1 first1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) { return detail::inner_product_k_t<Size>::template apply( first1, first2, init, binary_op1, binary_op2); } /// \brief 1D un-guarded cross-correlation with a variable-size kernel template < typename PixelAccum, typename SrcIterator, typename KernelIterator, typename Size, typename DstIterator > inline auto correlate_pixels_n( SrcIterator src_begin, SrcIterator src_end, KernelIterator kernel_begin, Size kernel_size, DstIterator dst_begin) -> DstIterator { using src_pixel_ref_t = typename pixel_proxy < typename std::iterator_traits<SrcIterator>::value_type >::type; using dst_pixel_ref_t = typename pixel_proxy < typename std::iterator_traits<DstIterator>::value_type >::type; using kernel_value_t = typename std::iterator_traits<KernelIterator>::value_type; PixelAccum accum_zero; pixel_zeros_t<PixelAccum>()(accum_zero); while (src_begin != src_end) { pixel_assigns_t<PixelAccum, dst_pixel_ref_t>()( std::inner_product( src_begin, src_begin + kernel_size, kernel_begin, accum_zero, pixel_plus_t<PixelAccum, PixelAccum, PixelAccum>(), pixel_multiplies_scalar_t<src_pixel_ref_t, kernel_value_t, PixelAccum>()), dst_begin); ++src_begin; ++dst_begin; } return dst_begin; } /// \brief 1D un-guarded cross-correlation with a fixed-size kernel template < std::size_t Size, typename PixelAccum, typename SrcIterator, typename KernelIterator, typename DstIterator > inline auto correlate_pixels_k( SrcIterator src_begin, SrcIterator src_end, KernelIterator kernel_begin, DstIterator dst_begin) -> DstIterator { using src_pixel_ref_t = typename pixel_proxy < typename std::iterator_traits<SrcIterator>::value_type >::type; using dst_pixel_ref_t = typename pixel_proxy < typename std::iterator_traits<DstIterator>::value_type >::type; using kernel_type = typename std::iterator_traits<KernelIterator>::value_type; PixelAccum accum_zero; pixel_zeros_t<PixelAccum>()(accum_zero); while (src_begin != src_end) { pixel_assigns_t<PixelAccum, dst_pixel_ref_t>()( inner_product_k<Size>( src_begin, kernel_begin, accum_zero, pixel_plus_t<PixelAccum, PixelAccum, PixelAccum>(), pixel_multiplies_scalar_t<src_pixel_ref_t, kernel_type, PixelAccum>()), dst_begin); ++src_begin; ++dst_begin; } return dst_begin; } /// \brief destination is set to be product of the source and a scalar /// \tparam PixelAccum - TODO /// \tparam SrcView Models ImageViewConcept /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Scalar, typename DstView> inline void view_multiplies_scalar(SrcView const& src_view, Scalar const& scalar, DstView const& dst_view) { static_assert(std::is_scalar<Scalar>::value, "Scalar is not scalar"); BOOST_ASSERT(src_view.dimensions() == dst_view.dimensions()); using src_pixel_ref_t = typename pixel_proxy<typename SrcView::value_type>::type; using dst_pixel_ref_t = typename pixel_proxy<typename DstView::value_type>::type; using y_coord_t = typename SrcView::y_coord_t; y_coord_t const height = src_view.height(); for (y_coord_t y = 0; y < height; ++y) { typename SrcView::x_iterator it_src = src_view.row_begin(y); typename DstView::x_iterator it_dst = dst_view.row_begin(y); typename SrcView::x_iterator it_src_end = src_view.row_end(y); while (it_src != it_src_end) { pixel_assigns_t<PixelAccum, dst_pixel_ref_t>()( pixel_multiplies_scalar_t<src_pixel_ref_t, Scalar, PixelAccum>()(it_src, scalar), it_dst); ++it_src; ++it_dst; } } } /// \ingroup ImageAlgorithms /// \brief Boundary options for image boundary extension enum class boundary_option { output_ignore, /// do nothing to the output output_zero, /// set the output to zero extend_padded, /// assume the source boundaries to be padded already extend_zero, /// assume the source boundaries to be zero extend_constant /// assume the source boundaries to be the boundary value }; namespace detail { template <typename SrcView, typename RltView> void extend_row_impl( SrcView const& src_view, RltView result_view, std::size_t extend_count, boundary_option option) { std::ptrdiff_t extend_count_ = static_cast<std::ptrdiff_t>(extend_count); if (option == boundary_option::extend_constant) { for (std::ptrdiff_t i = 0; i < result_view.height(); i++) { if(i >= extend_count_ && i < extend_count_ + src_view.height()) { assign_pixels( src_view.row_begin(i - extend_count_), src_view.row_end(i - extend_count_), result_view.row_begin(i) ); } else if(i < extend_count_) { assign_pixels(src_view.row_begin(0), src_view.row_end(0), result_view.row_begin(i)); } else { assign_pixels( src_view.row_begin(src_view.height() - 1), src_view.row_end(src_view.height() - 1), result_view.row_begin(i) ); } } } else if (option == boundary_option::extend_zero) { typename SrcView::value_type acc_zero; pixel_zeros_t<typename SrcView::value_type>()(acc_zero); for (std::ptrdiff_t i = 0; i < result_view.height(); i++) { if (i >= extend_count_ && i < extend_count_ + src_view.height()) { assign_pixels( src_view.row_begin(i - extend_count_), src_view.row_end(i - extend_count_), result_view.row_begin(i) ); } else { std::fill_n(result_view.row_begin(i), result_view.width(), acc_zero); } } } else if (option == boundary_option::extend_padded) { auto original_view = subimage_view( src_view, 0, -extend_count, src_view.width(), src_view.height() + (2 * extend_count) ); for (std::ptrdiff_t i = 0; i < result_view.height(); i++) { assign_pixels( original_view.row_begin(i), original_view.row_end(i), result_view.row_begin(i) ); } } else { BOOST_ASSERT_MSG(false, "Invalid boundary option"); } } } //namespace detail /// \brief adds new row at top and bottom. /// Image padding introduces new pixels around the edges of an image. /// The border provides space for annotations or acts as a boundary when using advanced filtering techniques. /// \tparam SrcView Models ImageViewConcept /// \tparam extend_count number of rows to be added each side /// \tparam option - TODO template <typename SrcView> auto extend_row( SrcView const& src_view, std::size_t extend_count, boundary_option option ) -> typename gil::image<typename SrcView::value_type> { typename gil::image<typename SrcView::value_type> result_img(src_view.width(), src_view.height() + (2 * extend_count)); auto result_view = view(result_img); detail::extend_row_impl(src_view, result_view, extend_count, option); return result_img; } /// \brief adds new column at left and right. /// Image padding introduces new pixels around the edges of an image. /// The border provides space for annotations or acts as a boundary when using advanced filtering techniques. /// \tparam SrcView Models ImageViewConcept /// \tparam extend_count number of columns to be added each side /// \tparam option - TODO template <typename SrcView> auto extend_col( SrcView const& src_view, std::size_t extend_count, boundary_option option ) -> typename gil::image<typename SrcView::value_type> { auto src_view_rotate = rotated90cw_view(src_view); typename gil::image<typename SrcView::value_type> result_img(src_view.width() + (2 * extend_count), src_view.height()); auto result_view = rotated90cw_view(view(result_img)); detail::extend_row_impl(src_view_rotate, result_view, extend_count, option); return result_img; } /// \brief adds new row and column at all sides. /// Image padding introduces new pixels around the edges of an image. /// The border provides space for annotations or acts as a boundary when using advanced filtering techniques. /// \tparam SrcView Models ImageViewConcept /// \tparam extend_count number of rows/column to be added each side /// \tparam option - TODO template <typename SrcView> auto extend_boundary( SrcView const& src_view, std::size_t extend_count, boundary_option option ) -> typename gil::image<typename SrcView::value_type> { if (option == boundary_option::extend_padded) { typename gil::image<typename SrcView::value_type> result_img(src_view.width()+(2 * extend_count), src_view.height()+(2 * extend_count)); typename gil::image<typename SrcView::value_type>::view_t result_view = view(result_img); auto original_view = subimage_view( src_view, -extend_count, -extend_count, src_view.width() + (2 * extend_count), src_view.height() + (2 * extend_count) ); for (std::ptrdiff_t i = 0; i < result_view.height(); i++) { assign_pixels( original_view.row_begin(i), original_view.row_end(i), result_view.row_begin(i) ); } return result_img; } auto auxilary_img = extend_col(src_view, extend_count, option); return extend_row(view(auxilary_img), extend_count, option); } }} // namespace boost::gil #endif PK��p�[��>_:��_:��extension/numeric/convolve.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // Copyright 2019 Miral Shah <miralshah2211@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_EXTENSION_NUMERIC_CONVOLVE_HPP #define BOOST_GIL_EXTENSION_NUMERIC_CONVOLVE_HPP #include <boost/gil/extension/numeric/algorithm.hpp> #include <boost/gil/extension/numeric/kernel.hpp> #include <boost/gil/extension/numeric/pixel_numeric_operations.hpp> #include <boost/gil/algorithm.hpp> #include <boost/gil/image_view_factory.hpp> #include <boost/gil/metafunctions.hpp> #include <boost/assert.hpp> #include <algorithm> #include <cstddef> #include <functional> #include <type_traits> #include <vector> namespace boost { namespace gil { // 2D spatial seperable convolutions and cross-correlations namespace detail { /// \brief Compute the cross-correlation of 1D kernel with the rows of an image /// \tparam PixelAccum - TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel - TODO /// \tparam DstView Models MutableImageViewConcept /// \tparam Correlator - TODO /// \param src_view /// \param kernel - TODO /// \param dst_view Destination where new computed values of pixels are assigned to /// \param option - TODO /// \param correlator - TODO template < typename PixelAccum, typename SrcView, typename Kernel, typename DstView, typename Correlator > void correlate_rows_impl( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option, Correlator correlator) { BOOST_ASSERT(src_view.dimensions() == dst_view.dimensions()); BOOST_ASSERT(kernel.size() != 0); if(kernel.size() == 1) { // Reduces to a multiplication view_multiplies_scalar<PixelAccum>(src_view, kernel.begin(), dst_view); return; } using src_pixel_ref_t = typename pixel_proxy<typename SrcView::value_type>::type; using dst_pixel_ref_t = typename pixel_proxy<typename DstView::value_type>::type; using x_coord_t = typename SrcView::x_coord_t; using y_coord_t = typename SrcView::y_coord_t; x_coord_t const width = src_view.width(); y_coord_t const height = src_view.height(); if (width == 0) return; PixelAccum acc_zero; pixel_zeros_t<PixelAccum>()(acc_zero); if (option == boundary_option::output_ignore \|\| option == boundary_option::output_zero) { typename DstView::value_type dst_zero; pixel_assigns_t<PixelAccum, dst_pixel_ref_t>()(acc_zero, dst_zero); if (width < static_cast<x_coord_t>(kernel.size())) { if (option == boundary_option::output_zero) fill_pixels(dst_view, dst_zero); } else { std::vector<PixelAccum> buffer(width); for (y_coord_t y = 0; y < height; ++y) { assign_pixels(src_view.row_begin(y), src_view.row_end(y), &buffer.front()); typename DstView::x_iterator it_dst = dst_view.row_begin(y); if (option == boundary_option::output_zero) std::fill_n(it_dst, kernel.left_size(), dst_zero); it_dst += kernel.left_size(); correlator(&buffer.front(), &buffer.front() + width + 1 - kernel.size(), kernel.begin(), it_dst); it_dst += width + 1 - kernel.size(); if (option == boundary_option::output_zero) std::fill_n(it_dst, kernel.right_size(), dst_zero); } } } else { std::vector<PixelAccum> buffer(width + kernel.size() - 1); for (y_coord_t y = 0; y < height; ++y) { PixelAccum it_buffer = &buffer.front(); if (option == boundary_option::extend_padded) { assign_pixels( src_view.row_begin(y) - kernel.left_size(), src_view.row_end(y) + kernel.right_size(), it_buffer); } else if (option == boundary_option::extend_zero) { std::fill_n(it_buffer, kernel.left_size(), acc_zero); it_buffer += kernel.left_size(); assign_pixels(src_view.row_begin(y), src_view.row_end(y), it_buffer); it_buffer += width; std::fill_n(it_buffer, kernel.right_size(), acc_zero); } else if (option == boundary_option::extend_constant) { PixelAccum filler; pixel_assigns_t<src_pixel_ref_t, PixelAccum>()(src_view.row_begin(y), filler); std::fill_n(it_buffer, kernel.left_size(), filler); it_buffer += kernel.left_size(); assign_pixels(src_view.row_begin(y), src_view.row_end(y), it_buffer); it_buffer += width; pixel_assigns_t<src_pixel_ref_t, PixelAccum>()(src_view.row_end(y)[-1], filler); std::fill_n(it_buffer, kernel.right_size(), filler); } correlator( &buffer.front(), &buffer.front() + width, kernel.begin(), dst_view.row_begin(y)); } } } template <typename PixelAccum> class correlator_n { public: correlator_n(std::size_t size) : size_(size) {} template <typename SrcIterator, typename KernelIterator, typename DstIterator> void operator()( SrcIterator src_begin, SrcIterator src_end, KernelIterator kernel_begin, DstIterator dst_begin) { correlate_pixels_n<PixelAccum>(src_begin, src_end, kernel_begin, size_, dst_begin); } private: std::size_t size_{0}; }; template <std::size_t Size, typename PixelAccum> struct correlator_k { template <typename SrcIterator, typename KernelIterator, typename DstIterator> void operator()( SrcIterator src_begin, SrcIterator src_end, KernelIterator kernel_begin, DstIterator dst_begin) { correlate_pixels_k<Size, PixelAccum>(src_begin, src_end, kernel_begin, dst_begin); } }; } // namespace detail /// \ingroup ImageAlgorithms /// \brief Correlate 1D variable-size kernel along the rows of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void correlate_rows( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { detail::correlate_rows_impl<PixelAccum>( src_view, kernel, dst_view, option, detail::correlator_n<PixelAccum>(kernel.size())); } /// \ingroup ImageAlgorithms /// \brief Correlate 1D variable-size kernel along the columns of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void correlate_cols( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { correlate_rows<PixelAccum>( transposed_view(src_view), kernel, transposed_view(dst_view), option); } /// \ingroup ImageAlgorithms /// \brief Convolve 1D variable-size kernel along the rows of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void convolve_rows( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { correlate_rows<PixelAccum>(src_view, reverse_kernel(kernel), dst_view, option); } /// \ingroup ImageAlgorithms /// \brief Convolve 1D variable-size kernel along the columns of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void convolve_cols( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { convolve_rows<PixelAccum>( transposed_view(src_view), kernel, transposed_view(dst_view), option); } /// \ingroup ImageAlgorithms /// \brief Correlate 1D fixed-size kernel along the rows of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void correlate_rows_fixed( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { using correlator = detail::correlator_k<Kernel::static_size, PixelAccum>; detail::correlate_rows_impl<PixelAccum>(src_view, kernel, dst_view, option, correlator{}); } /// \ingroup ImageAlgorithms /// \brief Correlate 1D fixed-size kernel along the columns of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum,typename SrcView,typename Kernel,typename DstView> BOOST_FORCEINLINE void correlate_cols_fixed( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { correlate_rows_fixed<PixelAccum>( transposed_view(src_view), kernel, transposed_view(dst_view), option); } /// \ingroup ImageAlgorithms /// \brief Convolve 1D fixed-size kernel along the rows of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void convolve_rows_fixed( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { correlate_rows_fixed<PixelAccum>(src_view, reverse_kernel(kernel), dst_view, option); } /// \ingroup ImageAlgorithms /// \brief Convolve 1D fixed-size kernel along the columns of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void convolve_cols_fixed( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { convolve_rows_fixed<PixelAccum>( transposed_view(src_view), kernel, transposed_view(dst_view), option); } namespace detail { /// \ingroup ImageAlgorithms /// \brief Convolve 1D variable-size kernel along both rows and columns of image /// \tparam PixelAccum TODO /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename PixelAccum, typename SrcView, typename Kernel, typename DstView> BOOST_FORCEINLINE void convolve_1d( SrcView const& src_view, Kernel const& kernel, DstView const& dst_view, boundary_option option = boundary_option::extend_zero) { convolve_rows<PixelAccum>(src_view, kernel, dst_view, option); convolve_cols<PixelAccum>(dst_view, kernel, dst_view, option); } template <typename SrcView, typename DstView, typename Kernel> void convolve_2d_impl(SrcView const& src_view, DstView const& dst_view, Kernel const& kernel) { int flip_ker_row, flip_ker_col, row_boundary, col_boundary; float aux_total; for (std::ptrdiff_t view_row = 0; view_row < src_view.height(); ++view_row) { for (std::ptrdiff_t view_col = 0; view_col < src_view.width(); ++view_col) { aux_total = 0.0f; for (std::size_t kernel_row = 0; kernel_row < kernel.size(); ++kernel_row) { flip_ker_row = kernel.size() - 1 - kernel_row; // row index of flipped kernel for (std::size_t kernel_col = 0; kernel_col < kernel.size(); ++kernel_col) { flip_ker_col = kernel.size() - 1 - kernel_col; // column index of flipped kernel // index of input signal, used for checking boundary row_boundary = view_row + (kernel.center_y() - flip_ker_row); col_boundary = view_col + (kernel.center_x() - flip_ker_col); // ignore input samples which are out of bound if (row_boundary >= 0 && row_boundary < src_view.height() && col_boundary >= 0 && col_boundary < src_view.width()) { aux_total += src_view(col_boundary, row_boundary) kernel.at(flip_ker_row, flip_ker_col); } } } dst_view(view_col, view_row) = aux_total; } } } /// \ingroup ImageAlgorithms /// \brief convolve_2d can only use convolve_option_extend_zero as convolve_boundary_option /// this is the default option and cannot be changed for now /// (In future there are plans to improve the algorithm and allow user to use other options as well) /// \tparam SrcView Models ImageViewConcept /// \tparam Kernel TODO /// \tparam DstView Models MutableImageViewConcept template <typename SrcView, typename DstView, typename Kernel> void convolve_2d(SrcView const& src_view, Kernel const& kernel, DstView const& dst_view) { BOOST_ASSERT(src_view.dimensions() == dst_view.dimensions()); BOOST_ASSERT(kernel.size() != 0); gil_function_requires<ImageViewConcept<SrcView>>(); gil_function_requires<MutableImageViewConcept<DstView>>(); static_assert(color_spaces_are_compatible < typename color_space_type<SrcView>::type, typename color_space_type<DstView>::type >::value, "Source and destination views must have pixels with the same color space"); for (std::size_t i = 0; i < src_view.num_channels(); i++) { detail::convolve_2d_impl( nth_channel_view(src_view, i), nth_channel_view(dst_view, i), kernel ); } } }}} // namespace boost::gil::detail #endif PK��p�[����.��extension/numeric/pixel_numeric_operations.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_NUMERIC_PIXEL_NUMERIC_OPERATIONS_HPP #define BOOST_GIL_EXTENSION_NUMERIC_PIXEL_NUMERIC_OPERATIONS_HPP #include <boost/gil/extension/numeric/channel_numeric_operations.hpp> #include <boost/gil/color_base_algorithm.hpp> #include <boost/gil/pixel.hpp> namespace boost { namespace gil { // Function objects and utilities for pixel-wise numeric operations. // // List of currently defined functors: // pixel_plus_t (+) // pixel_minus_t (-) // pixel_multiplies_scalar_t () // pixel_divides_scalar_t (/) // pixel_halves_t (/=2), // pixel_zeros_t (=0) // pixel_assigns_t (=) /// \ingroup PixelNumericOperations /// \brief Performs channel-wise addition of two pixels. /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelRef2 - models PixelConcept /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef1, typename PixelRef2, typename PixelResult> struct pixel_plus_t { auto operator()(PixelRef1 const& p1, PixelRef2 const& p2) const -> PixelResult { PixelResult result; static_transform(p1, p2, result, channel_plus_t < typename channel_type<PixelRef1>::type, typename channel_type<PixelRef2>::type, typename channel_type<PixelResult>::type >()); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise subtraction of two pixels. /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelRef2 - models PixelConcept /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef1, typename PixelRef2, typename PixelResult> struct pixel_minus_t { auto operator()(PixelRef1 const& p1, PixelRef2 const& p2) const -> PixelResult { PixelResult result; static_transform(p1, p2, result, channel_minus_t < typename channel_type<PixelRef1>::type, typename channel_type<PixelRef2>::type, typename channel_type<PixelResult>::type >()); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise multiplication of pixel elements by scalar. /// \tparam PixelRef - models PixelConcept /// \tparam Scalar - models a scalar type /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef, typename Scalar, typename PixelResult> struct pixel_multiplies_scalar_t { auto operator()(PixelRef const& p, Scalar const& s) const -> PixelResult { PixelResult result; static_transform(p, result, std::bind( channel_multiplies_scalar_t<typename channel_type<PixelRef>::type, Scalar, typename channel_type<PixelResult>::type>(), std::placeholders::_1, s)); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise multiplication of two pixels. /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef1, typename PixelRef2, typename PixelResult> struct pixel_multiply_t { auto operator()(PixelRef1 const& p1, PixelRef2 const& p2) const -> PixelResult { PixelResult result; static_transform(p1, p2, result, channel_multiplies_t < typename channel_type<PixelRef1>::type, typename channel_type<PixelRef2>::type, typename channel_type<PixelResult>::type >()); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise division of pixel elements by scalar. /// \tparam PixelRef - models PixelConcept /// \tparam Scalar - models a scalar type /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef, typename Scalar, typename PixelResult> struct pixel_divides_scalar_t { auto operator()(PixelRef const& p, Scalar const& s) const -> PixelResult { PixelResult result; static_transform(p, result, std::bind(channel_divides_scalar_t<typename channel_type<PixelRef>::type, Scalar, typename channel_type<PixelResult>::type>(), std::placeholders::_1, s)); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise division of two pixels. /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelRef1 - models PixelConcept /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef1, typename PixelRef2, typename PixelResult> struct pixel_divide_t { auto operator()(PixelRef1 const& p1, PixelRef2 const& p2) const -> PixelResult { PixelResult result; static_transform(p1, p2, result, channel_divides_t < typename channel_type<PixelRef1>::type, typename channel_type<PixelRef2>::type, typename channel_type<PixelResult>::type >()); return result; } }; /// \ingroup PixelNumericOperations /// \brief Performs channel-wise division by 2 /// \tparam PixelRef - models PixelConcept template <typename PixelRef> struct pixel_halves_t { auto operator()(PixelRef& p) const -> PixelRef& { static_for_each(p, channel_halves_t<typename channel_type<PixelRef>::type>()); return p; } }; /// \ingroup PixelNumericOperations /// \brief Sets pixel elements to zero (for whatever zero means) /// \tparam PixelRef - models PixelConcept template <typename PixelRef> struct pixel_zeros_t { auto operator()(PixelRef& p) const -> PixelRef& { static_for_each(p, channel_zeros_t<typename channel_type<PixelRef>::type>()); return p; } }; /// \brief Sets pixel elements to zero (for whatever zero means) /// \tparam Pixel - models PixelConcept template <typename Pixel> void zero_channels(Pixel& p) { static_for_each(p, channel_zeros_t<typename channel_type<Pixel>::type>()); } /// \ingroup PixelNumericOperations /// \brief Casts and assigns a pixel to another /// /// A generic implementation for casting and assigning a pixel to another. /// User should specialize it for better performance. /// /// \tparam PixelRef - models PixelConcept /// \tparam PixelResult - models PixelValueConcept template <typename PixelRef, typename PixelResult> struct pixel_assigns_t { auto operator()(PixelRef const& src, PixelResult& dst) const -> PixelResult { static_for_each(src, dst, channel_assigns_t < typename channel_type<PixelRef>::type, typename channel_type<PixelResult>::type >()); return dst; } }; }} // namespace boost::gil #endif PK��p�[�:��)��)��0��extension/numeric/channel_numeric_operations.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_NUMERIC_CHANNEL_NUMERIC_OPERATIONS_HPP #define BOOST_GIL_EXTENSION_NUMERIC_CHANNEL_NUMERIC_OPERATIONS_HPP #include <boost/gil/channel.hpp> namespace boost { namespace gil { // Function objects and utilities for channel-wise numeric operations. // // List of currently defined functors: // channel_plus_t (+) // channel_minus_t (-) // channel_multiplies_t () // channel_divides_t (/), // channel_plus_scalar_t (+s) // channel_minus_scalar_t (-s), // channel_multiplies_scalar_t (s) // channel_divides_scalar_t (/s), // channel_halves_t (/=2) // channel_zeros_t (=0) // channel_assigns_t (=) /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of addition of two channel values. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel1, typename Channel2, typename ChannelResult> struct channel_plus_t { using ChannelRef1 = typename channel_traits<Channel1>::const_reference; using ChannelRef2 = typename channel_traits<Channel2>::const_reference; static_assert(std::is_convertible<ChannelRef1, ChannelResult>::value, "ChannelRef1 not convertible to ChannelResult"); static_assert(std::is_convertible<ChannelRef2, ChannelResult>::value, "ChannelRef2 not convertible to ChannelResult"); /// \param ch1 - first of the two addends (augend). /// \param ch2 - second of the two addends. auto operator()(ChannelRef1 ch1, ChannelRef2 ch2) const -> ChannelResult { return ChannelResult(ch1) + ChannelResult(ch2); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of subtraction of two channel values. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel1, typename Channel2, typename ChannelResult> struct channel_minus_t { using ChannelRef1 = typename channel_traits<Channel1>::const_reference; using ChannelRef2 = typename channel_traits<Channel2>::const_reference; static_assert(std::is_convertible<ChannelRef1, ChannelResult>::value, "ChannelRef1 not convertible to ChannelResult"); static_assert(std::is_convertible<ChannelRef2, ChannelResult>::value, "ChannelRef2 not convertible to ChannelResult"); /// \param ch1 - minuend operand of the subtraction. /// \param ch2 - subtrahend operand of the subtraction. auto operator()(ChannelRef1 ch1, ChannelRef2 ch2) const -> ChannelResult { return ChannelResult(ch1) - ChannelResult(ch2); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of multiplication of two channel values. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel1, typename Channel2, typename ChannelResult> struct channel_multiplies_t { using ChannelRef1 = typename channel_traits<Channel1>::const_reference; using ChannelRef2 = typename channel_traits<Channel2>::const_reference; static_assert(std::is_convertible<ChannelRef1, ChannelResult>::value, "ChannelRef1 not convertible to ChannelResult"); static_assert(std::is_convertible<ChannelRef2, ChannelResult>::value, "ChannelRef2 not convertible to ChannelResult"); /// \param ch1 - first of the two factors (multiplicand). /// \param ch2 - second of the two factors (multiplier). auto operator()(ChannelRef1 ch1, ChannelRef2 ch2) const -> ChannelResult { return ChannelResult(ch1) * ChannelResult(ch2); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of division of two channel values. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel1, typename Channel2, typename ChannelResult> struct channel_divides_t { using ChannelRef1 = typename channel_traits<Channel1>::const_reference; using ChannelRef2 = typename channel_traits<Channel2>::const_reference; static_assert(std::is_convertible<ChannelRef1, ChannelResult>::value, "ChannelRef1 not convertible to ChannelResult"); static_assert(std::is_convertible<ChannelRef2, ChannelResult>::value, "ChannelRef2 not convertible to ChannelResult"); /// \param ch1 - dividend operand of the two division operation. /// \param ch2 - divisor operand of the two division operation. auto operator()(ChannelRef1 ch1, ChannelRef2 ch2) const -> ChannelResult { return ChannelResult(ch1) / ChannelResult(ch2); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of adding scalar to channel value. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel, typename Scalar, typename ChannelResult> struct channel_plus_scalar_t { using ChannelRef = typename channel_traits<Channel>::const_reference; static_assert(std::is_convertible<ChannelRef, ChannelResult>::value, "ChannelRef not convertible to ChannelResult"); static_assert(std::is_scalar<Scalar>::value, "Scalar not a scalar"); static_assert(std::is_convertible<Scalar, ChannelResult>::value, "Scalar not convertible to ChannelResult"); auto operator()(ChannelRef channel, Scalar const& scalar) const -> ChannelResult { return ChannelResult(channel) + ChannelResult(scalar); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of subtracting scalar from channel value. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel, typename Scalar, typename ChannelResult> struct channel_minus_scalar_t { using ChannelRef = typename channel_traits<Channel>::const_reference; static_assert(std::is_convertible<ChannelRef, ChannelResult>::value, "ChannelRef not convertible to ChannelResult"); static_assert(std::is_scalar<Scalar>::value, "Scalar not a scalar"); static_assert(std::is_convertible<Scalar, ChannelResult>::value, "Scalar not convertible to ChannelResult"); /// \param channel - minuend operand of the subtraction. /// \param scalar - subtrahend operand of the subtraction. auto operator()(ChannelRef channel, Scalar const& scalar) const -> ChannelResult { // TODO: Convertion after subtraction vs conversion of operands in channel_minus_t? return ChannelResult(channel - scalar); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of channel value by a scalar. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel, typename Scalar, typename ChannelResult> struct channel_multiplies_scalar_t { using ChannelRef = typename channel_traits<Channel>::const_reference; static_assert(std::is_convertible<ChannelRef, ChannelResult>::value, "ChannelRef not convertible to ChannelResult"); static_assert(std::is_scalar<Scalar>::value, "Scalar not a scalar"); static_assert(std::is_convertible<Scalar, ChannelResult>::value, "Scalar not convertible to ChannelResult"); /// \param channel - first of the two factors (multiplicand). /// \param scalar - second of the two factors (multiplier). auto operator()(ChannelRef channel, Scalar const& scalar) const -> ChannelResult { return ChannelResult(channel) * ChannelResult(scalar); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of dividing channel value by scalar. /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel, typename Scalar, typename ChannelResult> struct channel_divides_scalar_t { using ChannelRef = typename channel_traits<Channel>::const_reference; static_assert(std::is_convertible<ChannelRef, ChannelResult>::value, "ChannelRef not convertible to ChannelResult"); static_assert(std::is_scalar<Scalar>::value, "Scalar not a scalar"); static_assert(std::is_convertible<Scalar, ChannelResult>::value, "Scalar not convertible to ChannelResult"); /// \param channel - dividend operand of the two division operation. /// \param scalar - divisor operand of the two division operation. auto operator()(ChannelRef channel, Scalar const& scalar) const -> ChannelResult { return ChannelResult(channel) / ChannelResult(scalar); } }; /// \ingroup ChannelNumericOperations /// \brief Arithmetic operation of dividing channel value by 2 /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel> struct channel_halves_t { using ChannelRef = typename channel_traits<Channel>::reference; auto operator()(ChannelRef channel) const -> ChannelRef { // TODO: Split into steps: extract with explicit conversion to double, divide and assign? //double const v = ch; //ch = static_cast<Channel>(v / 2.0); channel /= 2.0; return channel; } }; /// \ingroup ChannelNumericOperations /// \brief Operation of setting channel value to zero /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel> struct channel_zeros_t { using ChannelRef = typename channel_traits<Channel>::reference; auto operator()(ChannelRef channel) const -> ChannelRef { channel = Channel(0); return channel; } }; /// \ingroup ChannelNumericOperations /// structure for assigning one channel to another /// \note This is a generic implementation; user should specialize it for better performance. template <typename Channel1, typename Channel2> struct channel_assigns_t { using ChannelRef1 = typename channel_traits<Channel1>::const_reference; using ChannelRef2 = typename channel_traits<Channel2>::reference; static_assert(std::is_convertible<ChannelRef1, Channel2>::value, "ChannelRef1 not convertible to Channel2"); /// \param ch1 - assignor side (input) of the assignment operation /// \param ch2 - assignee side (output) of the assignment operation auto operator()(ChannelRef1 ch1, ChannelRef2 ch2) const -> ChannelRef2 { ch2 = Channel2(ch1); return ch2; } }; }} // namespace boost::gil #endif PK��p�[ln��extension/io/raw/tags.hppnu��[��// // Copyright 2013 Christian Henning // // 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_EXTENSION_IO_RAW_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_RAW_TAGS_HPP #include <boost/gil/io/base.hpp> // Historically, LibRaw expects WIN32, not _WIN32 (see https://github.com/LibRaw/LibRaw/pull/206) #ifdef _MSC_VER #ifndef WIN32 #define WIN32 #endif #pragma warning(push) #pragma warning(disable:4251) // 'type' needs to have dll-interface to be used by clients of class #endif #include <libraw/libraw.h> namespace boost { namespace gil { /// Defines tiff tag. struct raw_tag : format_tag {}; /// Defines type for image width property. struct raw_image_width : property_base< int32_t > {}; /// Defines type for image height property. struct raw_image_height : property_base< int32_t > {}; /// Defines type for samples per pixel property. struct raw_samples_per_pixel : property_base< int32_t > {}; /// Defines type for bits per pixel property. struct raw_bits_per_pixel : property_base< int32_t > {}; /// Defines type for camera manufacturer. struct raw_camera_manufacturer : property_base< std::string > {}; /// Defines type for camera model. struct raw_camera_model : property_base< std::string > {}; /// Defines type for raw images count. struct raw_raw_images_count : property_base< unsigned > {}; /// Defines type for dng version. struct raw_dng_version : property_base< unsigned > {}; /// Defines type for number of colors. struct raw_number_colors : property_base< int32_t > {}; /// Defines type for colors description. struct raw_colors_description : property_base< std::string > {}; /// Defines type for raw height. struct raw_raw_height : property_base< uint16_t > {}; /// Defines type for raw width. struct raw_raw_width : property_base< uint16_t > {}; /// Defines type for visible height. struct raw_visible_height : property_base< uint16_t > {}; /// Defines type for visible width. struct raw_visible_width : property_base< uint16_t > {}; /// Defines type for top margin. struct raw_top_margin : property_base< uint16_t > {}; /// Defines type for left margin. struct raw_left_margin : property_base< uint16_t > {}; /// Defines type for output height. struct raw_output_height : property_base< uint16_t > {}; /// Defines type for output width. struct raw_output_width : property_base< uint16_t > {}; /// Defines type for pixel aspect. struct raw_pixel_aspect : property_base< double > {}; /// Defines type for image orientation. struct raw_flip : property_base< uint32_t > {}; /// Defines type for iso speed. struct raw_iso_speed : property_base< float > {}; /// Defines type for shutter. struct raw_shutter : property_base< float > {}; /// Defines type for aperture. struct raw_aperture : property_base< float > {}; /// Defines type for focal length. struct raw_focal_length : property_base< float > {}; /// Defines type for timestamp. struct raw_timestamp : property_base< time_t > {}; /// Defines type for shot order. struct raw_shot_order : property_base< uint16_t > {}; /// Defines type for image description. struct raw_image_description : property_base< std::string > {}; /// Defines type for artist. struct raw_artist : property_base< std::string > {}; /// Defines type for libraw version. struct raw_libraw_version : property_base< std::string > {}; /// Defines type for unpack function name. struct raw_unpack_function_name : property_base< std::string > {}; /// Read information for raw images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< raw_tag > { /// Default contructor. image_read_info< raw_tag >() : _valid( false ) {} // Here, width and height of the image are the ones of the output height (ie after having been processed by dcraw emulator) raw_image_width::type _width; raw_image_height::type _height; raw_samples_per_pixel::type _samples_per_pixel; raw_bits_per_pixel::type _bits_per_pixel; raw_camera_manufacturer::type _camera_manufacturer; raw_camera_model::type _camera_model; raw_raw_images_count::type _raw_images_count; raw_dng_version::type _dng_version; raw_number_colors::type _number_colors; raw_colors_description::type _colors_description; raw_raw_width::type _raw_width; raw_raw_height::type _raw_height; raw_visible_width::type _visible_width; raw_visible_height::type _visible_height; raw_top_margin::type _top_margin; raw_left_margin::type _left_margin; raw_output_width::type _output_width; raw_output_height::type _output_height; raw_pixel_aspect::type _pixel_aspect; raw_flip::type _flip; raw_iso_speed::type _iso_speed; raw_shutter::type _shutter; raw_aperture::type _aperture; raw_focal_length::type _focal_length; raw_timestamp::type _timestamp; raw_shot_order::type _shot_order; raw_image_description::type _image_description; raw_artist::type _artist; raw_libraw_version::type _libraw_version; raw_unpack_function_name::type _unpack_function_name; /// Used internaly to identify if the header has been read. bool _valid; }; /// Read settings for raw images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< raw_tag > : public image_read_settings_base { /// Default constructor image_read_settings() : image_read_settings_base() {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. image_read_settings( const point_t& top_left , const point_t& dim ) : image_read_settings_base( top_left , dim ) {} }; /// Write information for raw images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< raw_tag > { }; }} // namespace boost::gil #ifdef _MSC_VER #pragma warning(pop) #endif #endif PK��p�[��X$��$����extension/io/raw/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_RAW_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_RAW_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/raw/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// RAW Backend /// template< typename Device > struct reader_backend< Device , raw_tag > { public: using format_tag_t = raw_tag; public: reader_backend( const Device& io_dev , const image_read_settings< raw_tag >& settings ) : _io_dev ( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) { read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { _io_dev.get_mem_image_format( &_info._width , &_info._height , &_info._samples_per_pixel , &_info._bits_per_pixel ); // iparams _info._camera_manufacturer = _io_dev.get_camera_manufacturer(); _info._camera_model = _io_dev.get_camera_model(); _info._raw_images_count = _io_dev.get_raw_count(); _info._dng_version = _io_dev.get_dng_version(); _info._number_colors = _io_dev.get_colors(); //_io_dev.get_filters(); _info._colors_description = _io_dev.get_cdesc(); // image_sizes _info._raw_width = _io_dev.get_raw_width(); _info._raw_height = _io_dev.get_raw_height(); _info._visible_width = _io_dev.get_image_width(); _info._visible_height = _io_dev.get_image_height(); _info._top_margin = _io_dev.get_top_margin(); _info._left_margin = _io_dev.get_left_margin(); _info._output_width = _io_dev.get_iwidth(); _info._output_height = _io_dev.get_iheight(); _info._pixel_aspect = _io_dev.get_pixel_aspect(); _info._flip = _io_dev.get_flip(); // imgother _info._iso_speed = _io_dev.get_iso_speed(); _info._shutter = _io_dev.get_shutter(); _info._aperture = _io_dev.get_aperture(); _info._focal_length = _io_dev.get_focal_len(); _info._timestamp = _io_dev.get_timestamp(); _info._shot_order = static_cast< uint16_t >( _io_dev.get_shot_order() ); //_io_dev.get_gpsdata(); _info._image_description = _io_dev.get_desc(); _info._artist = _io_dev.get_artist(); _info._libraw_version = _io_dev.get_version(); _info._valid = true; } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } public: Device _io_dev; image_read_settings< raw_tag > _settings; image_read_info< raw_tag > _info; std::size_t _scanline_length; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[7 >5��"��extension/io/raw/detail/device.hppnu��[��// // Copyright 2012 Olivier Tournaire // Copyright 2007 Christian Henning // // 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_EXTENSION_IO_RAW_DETAIL_DEVICE_HPP #define BOOST_GIL_EXTENSION_IO_RAW_DETAIL_DEVICE_HPP #include <boost/gil/extension/io/raw/tags.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <memory> #include <string> #include <type_traits> namespace boost { namespace gil { namespace detail { class raw_device_base { public: /// /// Constructor /// raw_device_base() : _processor_ptr( new LibRaw ) {} // iparams getters std::string get_camera_manufacturer() { return std::string(_processor_ptr.get()->imgdata.idata.make); } std::string get_camera_model() { return std::string(_processor_ptr.get()->imgdata.idata.model); } unsigned get_raw_count() { return _processor_ptr.get()->imgdata.idata.raw_count; } unsigned get_dng_version() { return _processor_ptr.get()->imgdata.idata.dng_version; } int get_colors() { return _processor_ptr.get()->imgdata.idata.colors; } unsigned get_filters() { return _processor_ptr.get()->imgdata.idata.filters; } std::string get_cdesc() { return std::string(_processor_ptr.get()->imgdata.idata.cdesc); } // image_sizes getters unsigned short get_raw_width() { return _processor_ptr.get()->imgdata.sizes.raw_width; } unsigned short get_raw_height() { return _processor_ptr.get()->imgdata.sizes.raw_height; } unsigned short get_image_width() { return _processor_ptr.get()->imgdata.sizes.width; } unsigned short get_image_height() { return _processor_ptr.get()->imgdata.sizes.height; } unsigned short get_top_margin() { return _processor_ptr.get()->imgdata.sizes.top_margin; } unsigned short get_left_margin() { return _processor_ptr.get()->imgdata.sizes.left_margin; } unsigned short get_iwidth() { return _processor_ptr.get()->imgdata.sizes.iwidth; } unsigned short get_iheight() { return _processor_ptr.get()->imgdata.sizes.iheight; } double get_pixel_aspect() { return _processor_ptr.get()->imgdata.sizes.pixel_aspect; } int get_flip() { return _processor_ptr.get()->imgdata.sizes.flip; } // colordata getters // TODO // imgother getters float get_iso_speed() { return _processor_ptr.get()->imgdata.other.iso_speed; } float get_shutter() { return _processor_ptr.get()->imgdata.other.shutter; } float get_aperture() { return _processor_ptr.get()->imgdata.other.aperture; } float get_focal_len() { return _processor_ptr.get()->imgdata.other.focal_len; } time_t get_timestamp() { return _processor_ptr.get()->imgdata.other.timestamp; } unsigned int get_shot_order() { return _processor_ptr.get()->imgdata.other.shot_order; } unsigned get_gpsdata() { return _processor_ptr.get()->imgdata.other.gpsdata; } std::string get_desc() { return std::string(_processor_ptr.get()->imgdata.other.desc); } std::string get_artist() { return std::string(_processor_ptr.get()->imgdata.other.artist); } std::string get_version() { return std::string(_processor_ptr.get()->version()); } std::string get_unpack_function_name() { return std::string(_processor_ptr.get()->unpack_function_name()); } void get_mem_image_format(int widthp, int heightp, int colorsp, int bpp) { _processor_ptr.get()->get_mem_image_format(widthp, heightp, colorsp, bpp); } int unpack() { return _processor_ptr.get()->unpack(); } int dcraw_process() { return _processor_ptr.get()->dcraw_process(); } libraw_processed_image_t* dcraw_make_mem_image(int* error_code=nullptr) { return _processor_ptr.get()->dcraw_make_mem_image(error_code); } protected: using libraw_ptr_t = std::shared_ptr<LibRaw>; libraw_ptr_t _processor_ptr; }; /! * file_stream_device specialization for raw images / template<> class file_stream_device< raw_tag > : public raw_device_base { public: struct read_tag {}; /// /// Constructor /// file_stream_device( std::string const& file_name , read_tag = read_tag() ) { io_error_if( _processor_ptr.get()->open_file( file_name.c_str() ) != LIBRAW_SUCCESS , "file_stream_device: failed to open file" ); } /// /// Constructor /// file_stream_device( const char file_name , read_tag = read_tag() ) { io_error_if( _processor_ptr.get()->open_file( file_name ) != LIBRAW_SUCCESS , "file_stream_device: failed to open file" ); } }; template< typename FormatTag > struct is_adaptable_input_device<FormatTag, LibRaw, void> : std::true_type { using device_type = file_stream_device<FormatTag>; }; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[�Bƅ�� extension/io/raw/detail/read.hppnu��[��// // Copyright 2012 Olivier Tournaire, Christian Henning // // 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_EXTENSION_IO_RAW_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_RAW_DETAIL_READ_HPP #include <boost/gil/extension/io/raw/tags.hpp> #include <boost/gil/extension/io/raw/detail/device.hpp> #include <boost/gil/extension/io/raw/detail/is_allowed.hpp> #include <boost/gil/extension/io/raw/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/typedefs.hpp> #include <cstdio> #include <sstream> #include <type_traits> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif #define BUILD_INTERLEAVED_VIEW(color_layout, bits_per_pixel) \ { \ color_layout##bits_per_pixel##_view_t build = boost::gil::interleaved_view(processed_image->width, \ processed_image->height, \ (color_layout##bits_per_pixel##_pixel_t)processed_image->data, \ processed_image->colorsprocessed_image->widthprocessed_image->bits/8); \ this->_cc_policy.read( build.begin(), build.end(), dst_view.begin() ); \ } \ template< typename Device , typename ConversionPolicy > class reader< Device , raw_tag , ConversionPolicy > : public reader_base< raw_tag , ConversionPolicy > , public reader_backend< Device , raw_tag > { private: using this_t = reader<Device, raw_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, raw_tag>; // // Constructor // reader( const Device& io_dev , const image_read_settings< raw_tag >& settings ) : backend_t( io_dev , settings ) {} // // Constructor // reader( const Device& io_dev , const cc_t& cc , const image_read_settings< raw_tag >& settings ) : reader_base< raw_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} template< typename View > void apply( const View& dst_view ) { if( this->_info._valid == false ) { io_error( "Image header was not read." ); } using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_and_convert_t() ) , "Image types aren't compatible." ); // TODO: better error handling based on return code int return_code = this->_io_dev.unpack(); io_error_if( return_code != LIBRAW_SUCCESS, "Unable to unpack image" ); this->_info._unpack_function_name = this->_io_dev.get_unpack_function_name(); return_code = this->_io_dev.dcraw_process(); io_error_if( return_code != LIBRAW_SUCCESS, "Unable to emulate dcraw behavior to process image" ); libraw_processed_image_t processed_image = this->_io_dev.dcraw_make_mem_image(&return_code); io_error_if( return_code != LIBRAW_SUCCESS, "Unable to dcraw_make_mem_image" ); if(processed_image->colors!=1 && processed_image->colors!=3) io_error( "Image is neither gray nor RGB" ); if(processed_image->bits!=8 && processed_image->bits!=16) io_error( "Image is neither 8bit nor 16bit" ); // TODO Olivier Tournaire // Here, we should use a metafunction to reduce code size and avoid a (compile time) macro if(processed_image->bits==8) { if(processed_image->colors==1){ BUILD_INTERLEAVED_VIEW(gray, 8); } else { BUILD_INTERLEAVED_VIEW(rgb, 8); } } else if(processed_image->bits==16) { if(processed_image->colors==1){ BUILD_INTERLEAVED_VIEW(gray, 16); } else { BUILD_INTERLEAVED_VIEW(rgb, 16); } } } }; namespace detail { struct raw_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , raw_tag > {}; }; struct raw_type_format_checker { raw_type_format_checker( const image_read_info< raw_tag >& info ) : _info( info ) {} template< typename Image > bool apply() { using view_t = typename Image::view_t; return is_allowed<view_t>(_info, std::true_type{}); } private: ///todo: do we need this here. Should be part of reader_backend const image_read_info< raw_tag >& _info; }; } // namespace detail /// /// RAW Dynamic Reader /// template< typename Device > class dynamic_image_reader< Device , raw_tag > : public reader< Device , raw_tag , detail::read_and_no_convert > { using parent_t = reader<Device, raw_tag, detail::read_and_no_convert>; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< raw_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::raw_type_format_checker format_checker( this->_info ); if( !construct_matched( images , format_checker )) { std::ostringstream error_message; error_message << "No matching image type between those of the given any_image and that of the file.\n"; error_message << "Image type must be {gray\|\|rgb}{8\|\|16} unsigned for RAW image files."; io_error( error_message.str().c_str() ); } else { if( !this->_info._valid ) this->read_header(); this->init_image(images, this->_settings); detail::dynamic_io_fnobj< detail::raw_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[ա��+��extension/io/raw/detail/supported_types.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_RAW_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_RAW_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/raw/tags.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { // Read support template< typename Channel , typename ColorSpace > struct raw_read_support : read_support_false {}; template<> struct raw_read_support<uint8_t , gray_t > : read_support_true {}; template<> struct raw_read_support<uint16_t , gray_t > : read_support_true {}; template<> struct raw_read_support<uint8_t , rgb_t > : read_support_true {}; template<> struct raw_read_support<uint16_t , rgb_t > : read_support_true {}; // Write support struct raw_write_support : write_support_false {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel,raw_tag> : std::integral_constant < bool, detail::raw_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > {}; template<typename Pixel> struct is_write_supported<Pixel, raw_tag> : std::integral_constant<bool, detail::raw_write_support::is_supported> {}; }} // namespace boost::gil #endif PK��p�[ ��&��extension/io/raw/detail/is_allowed.hppnu��[��// // Copyright 2009 Christian Henning // // 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_EXTENSION_IO_RAW_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_RAW_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/raw/tags.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< raw_tag >& info , std::true_type // is read_and_no_convert ) { using pixel_t = typename get_pixel_type<View>::type; using num_channel_t = typename num_channels<pixel_t>::value_type; using channel_t = typename channel_traits<typename element_type<typename View::value_type>::type>::value_type; constexpr num_channel_t dst_samples_per_pixel = num_channels<pixel_t>::value; constexpr unsigned int dst_bits_per_pixel = detail::unsigned_integral_num_bits<channel_t>::value; constexpr bool is_type_signed = std::is_signed<channel_t>::value; return (dst_samples_per_pixel == info._samples_per_pixel && dst_bits_per_pixel == static_cast<unsigned int>(info._bits_per_pixel) && !is_type_signed); } template< typename View > bool is_allowed( const image_read_info< raw_tag >& /* info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[?�1��extension/io/raw/read.hppnu��[��// // Copyright 2013 Christian Henning // Copyright 2012 Olivier Tournaire // // 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_EXTENSION_IO_RAW_READ_HPP #define BOOST_GIL_EXTENSION_IO_RAW_READ_HPP #include <boost/gil/extension/io/raw/tags.hpp> #include <boost/gil/extension/io/raw/detail/supported_types.hpp> #include <boost/gil/extension/io/raw/detail/read.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[w��mT��T��extension/io/bmp/tags.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_BMP_TAGS_HPP #include <boost/gil/io/base.hpp> namespace boost { namespace gil { /// Defines bmp tag. struct bmp_tag : format_tag {}; /// See http://en.wikipedia.org/wiki/BMP_file_format#BMP_File_Header for reference. /// Defines type for offset value. struct bmp_offset : property_base< uint32_t > {}; /// Defines type for header sizes. struct bmp_header_size : property_base< uint32_t > { static const type _size = 14; /// Constant size for bmp file header size. static const type _win32_info_size = 40; /// Constant size for win32 bmp info header size. static const type _os2_info_size = 12; /// Constant size for os2 bmp info header size. }; /// Defines type for image width property. struct bmp_image_width : property_base< int32_t > {}; /// Defines type for image height property. struct bmp_image_height : property_base< int32_t > {}; /// Defines type for bits per pixels property. struct bmp_bits_per_pixel : property_base< uint16_t > {}; /// Defines type for compression property. struct bmp_compression : property_base< uint32_t > { static const type _rgb = 0; /// RGB without compression static const type _rle8 = 1; /// 8 bit index with RLE compression static const type _rle4 = 2; /// 4 bit index with RLE compression static const type _bitfield = 3; /// 16 or 32 bit fields without compression }; /// Defines type for image size property. struct bmp_image_size : property_base< uint32_t > {}; /// Defines type for horizontal resolution property. struct bmp_horizontal_resolution : property_base< int32_t > {}; /// Defines type for vertical resolution property. struct bmp_vertical_resolution : property_base< int32_t > {}; /// Defines type for number of colors property. struct bmp_num_colors : property_base< uint32_t > {}; /// Defines type for important number of colors property. struct bmp_num_important_colors : property_base< uint32_t > {}; /// if height is negative then image is stored top-down instead of bottom-up. struct bmp_top_down : property_base< bool > {}; static const uint32_t bmp_signature = 0x4D42; /// Constant signature for bmp file format. /// Read information for bmp images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< bmp_tag > { /// Default contructor. image_read_info< bmp_tag >() : _top_down(false) , _valid( false ) {} /// The offset, i.e. starting address, of the byte where the bitmap data can be found. bmp_offset::type _offset; /// The size of this header: /// - 40 bytes for Windows V3 header /// - 12 bytes for OS/2 V1 header bmp_header_size::type _header_size; /// The bitmap width in pixels ( signed integer ). bmp_image_width::type _width; /// The bitmap height in pixels ( signed integer ). bmp_image_height::type _height; /// The number of bits per pixel, which is the color depth of the image. /// Typical values are 1, 4, 8, 16, 24 and 32. bmp_bits_per_pixel::type _bits_per_pixel; /// The compression method being used. See above for a list of possible values. bmp_compression::type _compression; /// The image size. This is the size of the raw bitmap data (see below), /// and should not be confused with the file size. bmp_image_size::type _image_size; /// The horizontal resolution of the image. (pixel per meter, signed integer) bmp_horizontal_resolution::type _horizontal_resolution; /// The vertical resolution of the image. (pixel per meter, signed integer) bmp_vertical_resolution::type _vertical_resolution; /// The number of colors in the color palette, or 0 to default to 2^n - 1. bmp_num_colors::type _num_colors; /// The number of important colors used, or 0 when every color is important; /// generally ignored. bmp_num_important_colors::type _num_important_colors; bmp_top_down::type _top_down; /// Used internaly to identify is the header has been read. bool _valid; }; /// Read settings for bmp images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< bmp_tag > : public image_read_settings_base { /// Default constructor image_read_settings() : image_read_settings_base() {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. image_read_settings( const point_t& top_left , const point_t& dim ) : image_read_settings_base( top_left , dim ) {} }; /// Write information for bmp images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< bmp_tag > { }; } // namespace gil } // namespace boost #endif PK��p�[L�3�V��V��extension/io/bmp/write.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_BMP_WRITE_HPP #include <boost/gil/extension/io/bmp/tags.hpp> #include <boost/gil/extension/io/bmp/detail/supported_types.hpp> #include <boost/gil/extension/io/bmp/detail/write.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[ Z$v��v����extension/io/bmp/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/bmp/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// Color channel mask struct bit_field { unsigned int mask; // Bit mask at corresponding position unsigned int width; // Bit width of the mask unsigned int shift; // Bit position from right to left }; /// BMP color masks struct color_mask { bit_field red; // Red bits bit_field green; // Green bits bit_field blue; // Blue bits }; /// /// BMP Backend /// template< typename Device > struct reader_backend< Device , bmp_tag > { public: using format_tag_t = bmp_tag; public: reader_backend( const Device& io_dev , const image_read_settings< bmp_tag >& settings ) : _io_dev ( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) , _palette() { read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { // the magic number used to identify the BMP file: // 0x42 0x4D (ASCII code points for B and M) if( _io_dev.read_uint16() == 0x424D ) { io_error( "Wrong magic number for bmp file." ); } // the size of the BMP file in bytes _io_dev.read_uint32(); // reserved; actual value depends on the application that creates the image _io_dev.read_uint16(); // reserved; actual value depends on the application that creates the image _io_dev.read_uint16(); _info._offset = _io_dev.read_uint32(); // bitmap information // the size of this header ( 40 bytes ) _info._header_size = _io_dev.read_uint32(); if( _info._header_size == bmp_header_size::_win32_info_size ) { _info._width = _io_dev.read_uint32(); _info._height = _io_dev.read_uint32(); if (_info._height < 0) { _info._height = -_info._height; _info._top_down = true; } // the number of color planes being used. Must be set to 1. _io_dev.read_uint16(); _info._bits_per_pixel = _io_dev.read_uint16(); _info._compression = _io_dev.read_uint32(); _info._image_size = _io_dev.read_uint32(); _info._horizontal_resolution = _io_dev.read_uint32(); _info._vertical_resolution = _io_dev.read_uint32(); _info._num_colors = _io_dev.read_uint32(); _info._num_important_colors = _io_dev.read_uint32(); } else if( _info._header_size == bmp_header_size::_os2_info_size ) { _info._width = static_cast< bmp_image_width::type >( _io_dev.read_uint16() ); _info._height = static_cast< bmp_image_height::type >( _io_dev.read_uint16() ); // the number of color planes being used. Must be set to 1. _io_dev.read_uint16(); _info._bits_per_pixel = _io_dev.read_uint16(); _info._compression = bmp_compression::_rgb; // not used _info._image_size = 0; _info._horizontal_resolution = 0; _info._vertical_resolution = 0; _info._num_colors = 0; _info._num_important_colors = 0; } else if (_info._header_size > bmp_header_size::_win32_info_size) { // could be v4 or v5 // see MSDN: Bitmap Header Types ( BITMAPV4HEADER or BITMAPV5HEADER ) _info._width = _io_dev.read_uint32(); _info._height = _io_dev.read_uint32(); // the number of color planes being used. Must be set to 1. _io_dev.read_uint16(); _info._bits_per_pixel = _io_dev.read_uint16(); _info._compression = _io_dev.read_uint32(); _info._image_size = _io_dev.read_uint32(); _info._horizontal_resolution = _io_dev.read_uint32(); _info._vertical_resolution = _io_dev.read_uint32(); _info._num_colors = _io_dev.read_uint32(); _info._num_important_colors = _io_dev.read_uint32(); } else { io_error( "Invalid BMP info header." ); } _info._valid = true; } void read_palette() { int entries = this->_info._num_colors; if( entries == 0 ) { entries = 1u << this->_info._bits_per_pixel; } _palette.resize( entries, rgba8_pixel_t(0, 0, 0, 0)); for( int i = 0; i < entries; ++i ) { get_color( _palette[i], blue_t() ) = _io_dev.read_uint8(); get_color( _palette[i], green_t() ) = _io_dev.read_uint8(); get_color( _palette[i], red_t() ) = _io_dev.read_uint8(); // there are 4 entries when windows header // but 3 for os2 header if( _info._header_size == bmp_header_size::_win32_info_size ) { _io_dev.read_uint8(); } } // for } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } public: Device _io_dev; image_read_settings< bmp_tag > _settings; image_read_info< bmp_tag > _info; std::size_t _scanline_length; ///@todo make it an image. std::vector< rgba8_pixel_t > _palette; color_mask _mask; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[E��/��!��extension/io/bmp/detail/write.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_WRITE_HPP #include <boost/gil/extension/io/bmp/tags.hpp> #include <boost/gil/extension/io/bmp/detail/writer_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { struct bmp_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , bmp_tag > {}; }; template < int N > struct get_bgr_cs {}; template <> struct get_bgr_cs< 1 > { using type = gray8_view_t; }; template <> struct get_bgr_cs< 3 > { using type = bgr8_view_t; }; template <> struct get_bgr_cs< 4 > { using type = bgra8_view_t; }; } // namespace detail /// /// BMP Writer /// template< typename Device > class writer< Device , bmp_tag > : public writer_backend< Device , bmp_tag > { public: writer( const Device& io_dev , const image_write_info< bmp_tag >& info ) : backend_t( io_dev , info ) {} template<typename View> void apply( const View& view ) { write( view ); } private: using backend_t = writer_backend<Device, bmp_tag>; template< typename View > void write( const View& view ) { // using channel_t = typename channel_type< // typename get_pixel_type<View>::type>::type; // using color_space_t = typename color_space_type<View>::type; // check if supported /* /// todo if( bmp_read_write_support_private<channel_t, color_space_t>::channel != 8) { io_error("Input view type is incompatible with the image type"); } / // compute the file size int bpp = num_channels< View >::value 8; int entries = 0; /* /// @todo: Not supported for now. bit_aligned_images refer to indexed images /// in this context. if( bpp <= 8 ) { entries = 1u << bpp; } / std::size_t spn = ( view.width() num_channels< View >::value + 3 ) & ~3; std::size_t ofs = bmp_header_size::_size + bmp_header_size::_win32_info_size + entries * 4; std::size_t siz = ofs + spn * view.height(); // write the BMP file header this->_io_dev.write_uint16( bmp_signature ); this->_io_dev.write_uint32( (uint32_t) siz ); this->_io_dev.write_uint16( 0 ); this->_io_dev.write_uint16( 0 ); this->_io_dev.write_uint32( (uint32_t) ofs ); // writes Windows information header this->_io_dev.write_uint32( bmp_header_size::_win32_info_size ); this->_io_dev.write_uint32( static_cast< uint32_t >( view.width() )); this->_io_dev.write_uint32( static_cast< uint32_t >( view.height() )); this->_io_dev.write_uint16( 1 ); this->_io_dev.write_uint16( static_cast< uint16_t >( bpp )); this->_io_dev.write_uint32( bmp_compression::_rgb ); this->_io_dev.write_uint32( 0 ); this->_io_dev.write_uint32( 0 ); this->_io_dev.write_uint32( 0 ); this->_io_dev.write_uint32( entries ); this->_io_dev.write_uint32( 0 ); write_image< View , typename detail::get_bgr_cs< num_channels< View >::value >::type >( view, spn ); } template< typename View , typename BMP_View > void write_image( const View& view , const std::size_t spn ) { byte_vector_t buffer( spn ); std::fill( buffer.begin(), buffer.end(), 0 ); BMP_View row = interleaved_view( view.width() , 1 , (typename BMP_View::value_type) &buffer.front() , spn ); for( typename View::y_coord_t y = view.height() - 1; y > -1; --y ) { copy_pixels( subimage_view( view , 0 , (int) y , (int) view.width() , 1 ) , row ); this->_io_dev.write( &buffer.front(), spn ); } } }; /// /// BMP Dynamic Image Writer /// template< typename Device > class dynamic_image_writer< Device , bmp_tag > : public writer< Device , bmp_tag > { using parent_t = writer<Device, bmp_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< bmp_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::bmp_write_is_supported , parent_t > op( this ); apply_operation( views , op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[�`~B3��B3��)��extension/io/bmp/detail/scanline_read.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/bmp/detail/is_allowed.hpp> #include <boost/gil/extension/io/bmp/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <boost/gil/io/typedefs.hpp> #include <functional> #include <type_traits> #include <vector> namespace boost { namespace gil { /// /// BMP Scanline Reader /// template< typename Device > class scanline_reader< Device , bmp_tag > : public reader_backend< Device , bmp_tag > { public: using tag_t = bmp_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; public: // // Constructor // scanline_reader( Device& device , const image_read_settings< bmp_tag >& settings ) : backend_t( device , settings ) , _pitch( 0 ) { initialize(); } /// Read part of image defined by View and return the data. void read( byte_t dst, int pos ) { // jump to scanline long offset = 0; if( this->_info._height > 0 ) { // the image is upside down offset = this->_info._offset + ( this->_info._height - 1 - pos ) * this->_pitch; } else { offset = this->_info._offset + pos * _pitch; } this->_io_dev.seek( offset ); // read data _read_function(this, dst); } /// Skip over a scanline. void skip( byte_t, int ) { // nothing to do. } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { if( this->_info._bits_per_pixel < 8 ) { _pitch = (( this->_info._width this->_info._bits_per_pixel ) + 7 ) >> 3; } else { _pitch = this->_info._width * (( this->_info._bits_per_pixel + 7 ) >> 3); } _pitch = (_pitch + 3) & ~3; // switch( this->_info._bits_per_pixel ) { case 1: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette(); _buffer.resize( _pitch ); _read_function = std::mem_fn(&this_t::read_1_bit_row); break; } case 4: { switch( this->_info._compression ) { case bmp_compression::_rle4: { io_error( "Cannot read run-length encoded images in iterator mode. Try to read as whole image." ); break; } case bmp_compression::_rgb : { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette(); _buffer.resize( _pitch ); _read_function = std::mem_fn(&this_t::read_4_bits_row); break; } default: { io_error( "Unsupported compression mode in BMP file." ); } } break; } case 8: { switch( this->_info._compression ) { case bmp_compression::_rle8: { io_error( "Cannot read run-length encoded images in iterator mode. Try to read as whole image." ); break; } case bmp_compression::_rgb: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette(); _buffer.resize( _pitch ); _read_function = std::mem_fn(&this_t::read_8_bits_row); break; } default: { io_error( "Unsupported compression mode in BMP file." ); break; } } break; } case 15: case 16: { this->_scanline_length = ( this->_info._width * num_channels< rgb8_view_t >::value + 3 ) & ~3; _buffer.resize( _pitch ); if( this->_info._compression == bmp_compression::_bitfield ) { this->_mask.red.mask = this->_io_dev.read_uint32(); this->_mask.green.mask = this->_io_dev.read_uint32(); this->_mask.blue.mask = this->_io_dev.read_uint32(); this->_mask.red.width = detail::count_ones( this->_mask.red.mask ); this->_mask.green.width = detail::count_ones( this->_mask.green.mask ); this->_mask.blue.width = detail::count_ones( this->_mask.blue.mask ); this->_mask.red.shift = detail::trailing_zeros( this->_mask.red.mask ); this->_mask.green.shift = detail::trailing_zeros( this->_mask.green.mask ); this->_mask.blue.shift = detail::trailing_zeros( this->_mask.blue.mask ); } else if( this->_info._compression == bmp_compression::_rgb ) { switch( this->_info._bits_per_pixel ) { case 15: case 16: { this->_mask.red.mask = 0x007C00; this->_mask.red.width = 5; this->_mask.red.shift = 10; this->_mask.green.mask = 0x0003E0; this->_mask.green.width = 5; this->_mask.green.shift = 5; this->_mask.blue.mask = 0x00001F; this->_mask.blue.width = 5; this->_mask.blue.shift = 0; break; } case 24: case 32: { this->_mask.red.mask = 0xFF0000; this->_mask.red.width = 8; this->_mask.red.shift = 16; this->_mask.green.mask = 0x00FF00; this->_mask.green.width = 8; this->_mask.green.shift = 8; this->_mask.blue.mask = 0x0000FF; this->_mask.blue.width = 8; this->_mask.blue.shift = 0; break; } } } else { io_error( "Unsupported BMP compression." ); } _read_function = std::mem_fn(&this_t::read_15_bits_row); break; } case 24: { this->_scanline_length = ( this->_info._width * num_channels< rgb8_view_t >::value + 3 ) & ~3; _read_function = std::mem_fn(&this_t::read_row); break; } case 32: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; _read_function = std::mem_fn(&this_t::read_row); break; } default: { io_error( "Unsupported bits per pixel." ); } } } void read_palette() { if( this->_palette.size() > 0 ) { // palette has been read already. return; } int entries = this->_info._num_colors; if( entries == 0 ) { entries = 1u << this->_info._bits_per_pixel; } this->_palette.resize( entries, rgba8_pixel_t(0,0,0,0) ); for( int i = 0; i < entries; ++i ) { get_color( this->_palette[i], blue_t() ) = this->_io_dev.read_uint8(); get_color( this->_palette[i], green_t() ) = this->_io_dev.read_uint8(); get_color( this->_palette[i], red_t() ) = this->_io_dev.read_uint8(); // there are 4 entries when windows header // but 3 for os2 header if( this->_info._header_size == bmp_header_size::_win32_info_size ) { this->_io_dev.read_uint8(); } } // for } template< typename View > void read_bit_row( byte_t* dst ) { using src_view_t = View; using dst_view_t = rgba8_image_t::view_t; src_view_t src_view = interleaved_view( this->_info._width , 1 , (typename src_view_t::x_iterator) &_buffer.front() , this->_pitch ); dst_view_t dst_view = interleaved_view( this->_info._width , 1 , (typename dst_view_t::value_type) dst , num_channels< dst_view_t >::value this->_info._width ); typename src_view_t::x_iterator src_it = src_view.row_begin( 0 ); typename dst_view_t::x_iterator dst_it = dst_view.row_begin( 0 ); for( dst_view_t::x_coord_t i = 0 ; i < this->_info._width ; ++i, src_it++, dst_it++ ) { unsigned char c = get_color( src_it, gray_color_t() ); dst_it = this->_palette[c]; } } // Read 1 bit image. The colors are encoded by an index. void read_1_bit_row( byte_t* dst ) { this->_io_dev.read( &_buffer.front(), _pitch ); _mirror_bits( _buffer ); read_bit_row< gray1_image_t::view_t >( dst ); } // Read 4 bits image. The colors are encoded by an index. void read_4_bits_row( byte_t* dst ) { this->_io_dev.read( &_buffer.front(), _pitch ); _swap_half_bytes( _buffer ); read_bit_row< gray4_image_t::view_t >( dst ); } /// Read 8 bits image. The colors are encoded by an index. void read_8_bits_row( byte_t* dst ) { this->_io_dev.read( &_buffer.front(), _pitch ); read_bit_row< gray8_image_t::view_t >( dst ); } /// Read 15 or 16 bits image. void read_15_bits_row( byte_t* dst ) { using dst_view_t = rgb8_view_t; dst_view_t dst_view = interleaved_view( this->_info._width , 1 , (typename dst_view_t::value_type) dst , this->_pitch ); typename dst_view_t::x_iterator dst_it = dst_view.row_begin( 0 ); // byte_t src = &_buffer.front(); this->_io_dev.read( src, _pitch ); for( dst_view_t::x_coord_t i = 0 ; i < this->_info._width ; ++i, src += 2 ) { int p = ( src[1] << 8 ) \| src[0]; int r = ((p & this->_mask.red.mask) >> this->_mask.red.shift) << (8 - this->_mask.red.width); int g = ((p & this->_mask.green.mask) >> this->_mask.green.shift) << (8 - this->_mask.green.width); int b = ((p & this->_mask.blue.mask) >> this->_mask.blue.shift) << (8 - this->_mask.blue.width); get_color( dst_it[i], red_t() ) = static_cast< byte_t >( r ); get_color( dst_it[i], green_t() ) = static_cast< byte_t >( g ); get_color( dst_it[i], blue_t() ) = static_cast< byte_t >( b ); } } void read_row( byte_t* dst ) { this->_io_dev.read( dst, _pitch ); } private: // the row pitch must be multiple of 4 bytes int _pitch; std::vector<byte_t> _buffer; detail::mirror_bits <std::vector<byte_t>, std::true_type> _mirror_bits; detail::swap_half_bytes<std::vector<byte_t>, std::true_type> _swap_half_bytes; std::function<void(this_t, byte_t)> _read_function; }; } // namespace gil } // namespace boost #endif PK��p�[7\|��Y��Y�� extension/io/bmp/detail/read.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_READ_HPP #include <boost/gil/extension/io/bmp/detail/is_allowed.hpp> #include <boost/gil/extension/io/bmp/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/typedefs.hpp> #include <boost/assert.hpp> #include <type_traits> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// BMP Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , bmp_tag , ConversionPolicy > : public reader_base< bmp_tag , ConversionPolicy > , public reader_backend< Device , bmp_tag > { private: using this_t = reader<Device, bmp_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend< Device, bmp_tag>; public: // // Constructor // reader( const Device& io_dev , const image_read_settings< bmp_tag >& settings ) : backend_t( io_dev , settings ) , _pitch( 0 ) {} // // Constructor // reader( const Device& io_dev , const ConversionPolicy& cc , const image_read_settings< bmp_tag >& settings ) : reader_base< bmp_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) , _pitch( 0 ) {} /// Read image. template< typename View > void apply( const View& dst_view ) { if( this->_info._valid == false ) { io_error( "Image header was not read." ); } using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_and_convert_t() ) , "Image types aren't compatible." ); // the row pitch must be multiple 4 bytes if( this->_info._bits_per_pixel < 8 ) { _pitch = static_cast<long>((( this->_info._width * this->_info._bits_per_pixel ) + 7 ) >> 3 ); } else { _pitch = static_cast<long>( this->_info._width * (( this->_info._bits_per_pixel + 7 ) >> 3 )); } _pitch = (_pitch + 3) & ~3; switch( this->_info._bits_per_pixel ) { case 1: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette_image < gray1_image_t::view_t, detail::mirror_bits<byte_vector_t, std::true_type> >(dst_view); break; } case 4: { switch ( this->_info._compression ) { case bmp_compression::_rle4: { ///@todo How can we determine that? this->_scanline_length = 0; read_palette_image_rle( dst_view ); break; } case bmp_compression::_rgb: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette_image < gray4_image_t::view_t, detail::swap_half_bytes<byte_vector_t, std::true_type> >(dst_view); break; } default: { io_error( "Unsupported compression mode in BMP file." ); break; } } break; } case 8: { switch ( this->_info._compression ) { case bmp_compression::_rle8: { ///@todo How can we determine that? this->_scanline_length = 0; read_palette_image_rle( dst_view ); break; } case bmp_compression::_rgb: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_palette_image< gray8_image_t::view_t , detail::do_nothing< std::vector< gray8_pixel_t > > > ( dst_view ); break; } default: { io_error( "Unsupported compression mode in BMP file." ); break; } } break; } case 15: case 16: { this->_scanline_length = ( this->_info._width * num_channels< rgb8_view_t >::value + 3 ) & ~3; read_data_15( dst_view ); break; } case 24: { this->_scanline_length = ( this->_info._width * num_channels< rgb8_view_t >::value + 3 ) & ~3; read_data< bgr8_view_t >( dst_view ); break; } case 32: { this->_scanline_length = ( this->_info._width * num_channels< rgba8_view_t >::value + 3 ) & ~3; read_data< bgra8_view_t >( dst_view ); break; } } } private: long get_offset( std::ptrdiff_t pos ) { if( this->_info._height > 0 ) { // the image is upside down return static_cast<long>( ( this->_info._offset + ( this->_info._height - 1 - pos ) * _pitch )); } else { return static_cast<long>( ( this->_info._offset + pos * _pitch )); } } template< typename View_Src , typename Byte_Manipulator , typename View_Dst > void read_palette_image( const View_Dst& view ) { this->read_palette(); using rh_t = detail::row_buffer_helper_view<View_Src>; using it_t = typename rh_t::iterator_t; rh_t rh( _pitch, true ); // we have to swap bits Byte_Manipulator byte_manipulator; for( std::ptrdiff_t y = 0 ; y < this->_settings._dim.y ; ++y ) { this->_io_dev.seek( get_offset( y + this->_settings._top_left.y )); this->_io_dev.read( reinterpret_cast< byte_t* >( rh.data() ) , _pitch ); byte_manipulator( rh.buffer() ); typename View_Dst::x_iterator dst_it = view.row_begin( y ); it_t it = rh.begin() + this->_settings._top_left.x; it_t end = it + this->_settings._dim.x; for( ; it != end; ++it, ++dst_it ) { unsigned char c = get_color( it, gray_color_t() ); dst_it = this->_palette[ c ]; } } } template< typename View > void read_data_15( const View& view ) { byte_vector_t row( _pitch ); // read the color masks if( this->_info._compression == bmp_compression::_bitfield ) { this->_mask.red.mask = this->_io_dev.read_uint32(); this->_mask.green.mask = this->_io_dev.read_uint32(); this->_mask.blue.mask = this->_io_dev.read_uint32(); this->_mask.red.width = detail::count_ones( this->_mask.red.mask ); this->_mask.green.width = detail::count_ones( this->_mask.green.mask ); this->_mask.blue.width = detail::count_ones( this->_mask.blue.mask ); this->_mask.red.shift = detail::trailing_zeros( this->_mask.red.mask ); this->_mask.green.shift = detail::trailing_zeros( this->_mask.green.mask ); this->_mask.blue.shift = detail::trailing_zeros( this->_mask.blue.mask ); } else if( this->_info._compression == bmp_compression::_rgb ) { switch( this->_info._bits_per_pixel ) { case 15: case 16: { this->_mask.red.mask = 0x007C00; this->_mask.red.width = 5; this->_mask.red.shift = 10; this->_mask.green.mask = 0x0003E0; this->_mask.green.width = 5; this->_mask.green.shift = 5; this->_mask.blue.mask = 0x00001F; this->_mask.blue.width = 5; this->_mask.blue.shift = 0; break; } case 24: case 32: { this->_mask.red.mask = 0xFF0000; this->_mask.red.width = 8; this->_mask.red.shift = 16; this->_mask.green.mask = 0x00FF00; this->_mask.green.width = 8; this->_mask.green.shift = 8; this->_mask.blue.mask = 0x0000FF; this->_mask.blue.width = 8; this->_mask.blue.shift = 0; break; } } } else { io_error( "bmp_reader::apply(): unsupported BMP compression" ); } using image_t = rgb8_image_t; using it_t = typename image_t::view_t::x_iterator; for( std::ptrdiff_t y = 0 ; y < this->_settings._dim.y ; ++y ) { this->_io_dev.seek( get_offset( y + this->_settings._top_left.y )); this->_io_dev.read( &row.front() , row.size() ); image_t img_row( this->_info._width, 1 ); image_t::view_t v = gil::view( img_row ); it_t it = v.row_begin( 0 ); it_t beg = v.row_begin( 0 ) + this->_settings._top_left.x; it_t end = beg + this->_settings._dim.x; byte_t* src = &row.front(); for( int32_t i = 0 ; i < this->_info._width; ++i, src += 2 ) { int p = ( src[1] << 8 ) \| src[0]; int r = ((p & this->_mask.red.mask) >> this->_mask.red.shift) << (8 - this->_mask.red.width); int g = ((p & this->_mask.green.mask) >> this->_mask.green.shift) << (8 - this->_mask.green.width); int b = ((p & this->_mask.blue.mask) >> this->_mask.blue.shift) << (8 - this->_mask.blue.width); get_color( it[i], red_t() ) = static_cast< byte_t >( r ); get_color( it[i], green_t() ) = static_cast< byte_t >( g ); get_color( it[i], blue_t() ) = static_cast< byte_t >( b ); } this->_cc_policy.read( beg , end , view.row_begin( y ) ); } } // 8-8-8 BGR // 8-8-8-8 BGRA template< typename View_Src , typename View_Dst > void read_data( const View_Dst& view ) { byte_vector_t row( _pitch ); View_Src v = interleaved_view( this->_info._width , 1 , (typename View_Src::value_type) &row.front() , this->_info._width num_channels< View_Src >::value ); typename View_Src::x_iterator beg = v.row_begin( 0 ) + this->_settings._top_left.x; typename View_Src::x_iterator end = beg + this->_settings._dim.x; for( std::ptrdiff_t y = 0 ; y < this->_settings._dim.y ; ++y ) { this->_io_dev.seek( get_offset( y + this->_settings._top_left.y )); this->_io_dev.read( &row.front() , row.size() ); this->_cc_policy.read( beg , end , view.row_begin( y ) ); } } template< typename Buffer , typename View > void copy_row_if_needed( const Buffer& buf , const View& view , std::ptrdiff_t y ) { if( y >= this->_settings._top_left.y && y < this->_settings._dim.y ) { typename Buffer::const_iterator beg = buf.begin() + this->_settings._top_left.x; typename Buffer::const_iterator end = beg + this->_settings._dim.x; std::copy( beg , end , view.row_begin( y ) ); } } template< typename View_Dst > void read_palette_image_rle( const View_Dst& view ) { BOOST_ASSERT( this->_info._compression == bmp_compression::_rle4 \|\| this->_info._compression == bmp_compression::_rle8); this->read_palette(); // jump to start of rle4 data this->_io_dev.seek( this->_info._offset ); // we need to know the stream position for padding purposes std::size_t stream_pos = this->_info._offset; using Buf_type = std::vector<rgba8_pixel_t>; Buf_type buf( this->_settings._dim.x ); Buf_type::iterator dst_it = buf.begin(); Buf_type::iterator dst_end = buf.end(); // If height is positive, the bitmap is a bottom-up DIB. // If height is negative, the bitmap is a top-down DIB. // The origin of a bottom-up DIB is the bottom left corner of the bitmap image, // which is the first pixel of the first row of bitmap data. // The origin of a top-down DIB is also the bottom left corner of the bitmap image, // but in this case the bottom left corner is the first pixel of the last row of bitmap data. // - "Programming Windows", 5th Ed. by Charles Petzold explains Windows docs ambiguities. std::ptrdiff_t ybeg = 0; std::ptrdiff_t yend = this->_settings._dim.y; std::ptrdiff_t yinc = 1; if( this->_info._height > 0 ) { ybeg = this->_settings._dim.y - 1; yend = -1; yinc = -1; } std::ptrdiff_t y = ybeg; bool finished = false; while ( !finished ) { std::ptrdiff_t count = this->_io_dev.read_uint8(); std::ptrdiff_t second = this->_io_dev.read_uint8(); stream_pos += 2; if ( count ) { // encoded mode // clamp to boundary if( count > dst_end - dst_it ) { count = dst_end - dst_it; } if( this->_info._compression == bmp_compression::_rle4 ) { std::ptrdiff_t cs[2] = { second >> 4, second & 0x0f }; for( int i = 0; i < count; ++i ) { dst_it++ = this->_palette[ cs[i & 1] ]; } } else { for( int i = 0; i < count; ++i ) { dst_it++ = this->_palette[ second ]; } } } else { switch( second ) { case 0: // end of row { copy_row_if_needed( buf, view, y ); y += yinc; if( y == yend ) { finished = true; } else { dst_it = buf.begin(); dst_end = buf.end(); } break; } case 1: // end of bitmap { copy_row_if_needed( buf, view, y ); finished = true; break; } case 2: // offset coordinates { std::ptrdiff_t dx = this->_io_dev.read_uint8(); std::ptrdiff_t dy = this->_io_dev.read_uint8() * yinc; stream_pos += 2; if( dy ) { copy_row_if_needed( buf, view, y ); } std::ptrdiff_t x = dst_it - buf.begin(); x += dx; if( x > this->_info._width ) { io_error( "Mangled BMP file." ); } y += dy; if( yinc > 0 ? y > yend : y < yend ) { io_error( "Mangled BMP file." ); } dst_it = buf.begin() + x; dst_end = buf.end(); break; } default: // absolute mode { count = second; // clamp to boundary if( count > dst_end - dst_it ) { count = dst_end - dst_it; } if ( this->_info._compression == bmp_compression::_rle4 ) { for( int i = 0; i < count; ++i ) { uint8_t packed_indices = this->_io_dev.read_uint8(); ++stream_pos; dst_it++ = this->_palette[ packed_indices >> 4 ]; if( ++i == second ) break; dst_it++ = this->_palette[ packed_indices & 0x0f ]; } } else { for( int i = 0; i < count; ++i ) { uint8_t c = this->_io_dev.read_uint8(); ++stream_pos; dst_it++ = this->_palette[ c ]; } } // pad to word boundary if( ( stream_pos - get_offset( 0 )) & 1 ) { this->_io_dev.seek( 1, SEEK_CUR ); ++stream_pos; } break; } } } } } private: std::size_t _pitch; }; namespace detail { class bmp_type_format_checker { public: bmp_type_format_checker( const bmp_bits_per_pixel::type& bpp ) : _bpp( bpp ) {} template< typename Image > bool apply() { if( _bpp < 32 ) { return pixels_are_compatible< typename Image::value_type, rgb8_pixel_t >::value ? true : false; } else { return pixels_are_compatible< typename Image::value_type, rgba8_pixel_t >::value ? true : false; } } private: // to avoid C4512 bmp_type_format_checker& operator=( const bmp_type_format_checker& ) { return this; } private: const bmp_bits_per_pixel::type _bpp; }; struct bmp_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , bmp_tag > {}; }; } // namespace detail /// /// BMP Dynamic Reader /// template< typename Device > class dynamic_image_reader< Device , bmp_tag > : public reader< Device , bmp_tag , detail::read_and_no_convert > { using parent_t = reader<Device, bmp_tag, detail::read_and_no_convert>; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< bmp_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::bmp_type_format_checker format_checker( this->_info._bits_per_pixel ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::bmp_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[`i�s��s����extension/io/bmp/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/bmp/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// BMP Writer Backend /// template< typename Device > struct writer_backend< Device , bmp_tag > { public: using format_tag_t = bmp_tag; public: writer_backend( const Device& io_dev , const image_write_info< bmp_tag >& info ) : _io_dev( io_dev ) , _info ( info ) {} public: Device _io_dev; image_write_info< bmp_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[d�� +��extension/io/bmp/detail/supported_types.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/bmp/tags.hpp> #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/packed_pixel.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { // Read support template< typename Channel , typename ColorSpace > struct bmp_read_support : read_support_false { static const bmp_bits_per_pixel::type bpp = 0; }; template< typename BitField , bool Mutable > struct bmp_read_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > , gray_t > : read_support_true { static const bmp_bits_per_pixel::type bpp = 1; }; template< typename BitField , bool Mutable > struct bmp_read_support< packed_dynamic_channel_reference< BitField , 4 , Mutable > , gray_t > : read_support_true { static const bmp_bits_per_pixel::type bpp = 4; }; template<> struct bmp_read_support<uint8_t , gray_t > : read_support_true { static const bmp_bits_per_pixel::type bpp = 8; }; template<> struct bmp_read_support<uint8_t , rgb_t > : read_support_true { static const bmp_bits_per_pixel::type bpp = 24; }; template<> struct bmp_read_support<uint8_t , rgba_t > : read_support_true { static const bmp_bits_per_pixel::type bpp = 32; }; // Write support template< typename Channel , typename ColorSpace > struct bmp_write_support : write_support_false {}; template<> struct bmp_write_support<uint8_t , rgb_t > : write_support_true {}; template<> struct bmp_write_support<uint8_t , rgba_t > : write_support_true {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, bmp_tag> : std::integral_constant < bool, detail::bmp_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::bmp_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const typename bmp_bits_per_pixel::type bpp = parent_t::bpp; }; template<typename Pixel> struct is_write_supported<Pixel, bmp_tag> : std::integral_constant < bool, detail::bmp_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > {}; } // namespace gil } // namespace boost #endif PK��p�[cɧ�V��V��&��extension/io/bmp/detail/is_allowed.hppnu��[��// // Copyright 2009 Christian Henning // // 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_EXTENSION_IO_BMP_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/bmp/tags.hpp> #include <boost/gil/channel.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< bmp_tag >& info , std::true_type // is read_and_no_convert ) { bmp_bits_per_pixel::type src_bits_per_pixel = 0; switch( info._bits_per_pixel ) { case 1: case 4: case 8: { if( info._header_size == bmp_header_size::_win32_info_size && info._compression != bmp_compression::_rle8 && info._compression != bmp_compression::_rle4 ) { src_bits_per_pixel = 32; } else { src_bits_per_pixel = 24; } break; } case 15: case 16: { src_bits_per_pixel = 24; break; } case 24: case 32: { src_bits_per_pixel = info._bits_per_pixel; break; } default: { io_error( "Pixel size not supported." ); } } using channel_t = typename channel_traits<typename element_type<typename View::value_type>::type>::value_type; bmp_bits_per_pixel::type dst_bits_per_pixel = detail::unsigned_integral_num_bits< channel_t >::value num_channels< View >::value; return ( dst_bits_per_pixel == src_bits_per_pixel ); } template< typename View > bool is_allowed( const image_read_info< bmp_tag >& /* info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[�b�@Q��Q��extension/io/bmp/read.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_READ_HPP #define BOOST_GIL_EXTENSION_IO_BMP_READ_HPP #define BOOST_GIL_EXTENSION_IO_BMP_READ_ENABLED // TODO: Document, explain, review #include <boost/gil/extension/io/bmp/tags.hpp> #include <boost/gil/extension/io/bmp/detail/read.hpp> #include <boost/gil/extension/io/bmp/detail/scanline_read.hpp> #include <boost/gil/extension/io/bmp/detail/supported_types.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[j:9�K��K��extension/io/bmp/old.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_OLD_HPP #define BOOST_GIL_EXTENSION_IO_BMP_OLD_HPP #include <boost/gil/extension/io/bmp.hpp> namespace boost { namespace gil { /// \ingroup BMP_IO /// \brief Returns the width and height of the BMP file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid BMP file template<typename String> inline point_t bmp_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, bmp_tag>::type; backend_t backend = read_image_info(filename, bmp_tag()); return { backend._info._width, backend._info._height }; } /// \ingroup BMP_IO /// \brief Loads the image specified by the given bmp image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void bmp_read_view( const String& filename , const View& view ) { read_view( filename , view , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given bmp image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void bmp_read_image( const String& filename , Image& img ) { read_image( filename , img , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Loads and color-converts the image specified by the given bmp image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void bmp_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Loads and color-converts the image specified by the given bmp image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void bmp_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given bmp image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid BMP file template< typename String , typename Image , typename CC > inline void bmp_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given bmp image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid BMP file template< typename String , typename Image > inline void bmp_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , bmp_tag() ); } /// \ingroup BMP_IO /// \brief Saves the view to a bmp file specified by the given bmp image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void bmp_write_view( const String& filename , const View& view ) { write_view( filename , view , bmp_tag() ); } } // namespace gil } // namespace boost #endif PK��p�[�= Jf��f��extension/io/targa/tags.hppnu��[��// // Copyright 2010 Kenneth Riddile // // 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_EXTENSION_IO_TARGA_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_TAGS_HPP #include <boost/gil/io/base.hpp> namespace boost { namespace gil { /// Defines targa tag. struct targa_tag : format_tag {}; /// See http://en.wikipedia.org/wiki/Truevision_TGA#Header for reference. /// http://local.wasp.uwa.edu.au/~pbourke/dataformats/tga/ /// Defines type for header sizes. struct targa_header_size : property_base< uint8_t > { static const type _size = 18; /// Constant size for targa file header size. }; /// Defines type for offset value. struct targa_offset : property_base< uint8_t > {}; /// Defines type for color map type property. struct targa_color_map_type : property_base< uint8_t > { static const type _rgb = 0; static const type _indexed = 1; }; /// Defines type for image type property. struct targa_image_type : property_base< uint8_t > { static const type _none = 0; /// no image data static const type _indexed = 1; /// indexed static const type _rgb = 2; /// RGB static const type _greyscale = 3; /// greyscale static const type _rle_indexed = 9; /// indexed with RLE compression static const type _rle_rgb = 10; /// RGB with RLE compression static const type _rle_greyscale = 11; /// greyscale with RLE compression }; /// Defines type for color map start property. struct targa_color_map_start : property_base< uint16_t > {}; /// Defines type for color map length property. struct targa_color_map_length : property_base< uint16_t > {}; /// Defines type for color map bit depth property. struct targa_color_map_depth : property_base< uint8_t > {}; /// Defines type for origin x and y value properties. struct targa_origin_element : property_base< uint16_t > {}; /// Defines type for image dimension properties. struct targa_dimension : property_base< uint16_t > {}; /// Defines type for image bit depth property. struct targa_depth : property_base< uint8_t > {}; /// Defines type for image descriptor property. struct targa_descriptor : property_base< uint8_t > {}; struct targa_screen_origin_bit : property_base< bool > {}; /// Read information for targa images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< targa_tag > { /// Default contructor. image_read_info< targa_tag >() : _screen_origin_bit(false) , _valid( false ) {} /// The size of this header: targa_header_size::type _header_size; /// The offset, i.e. starting address, of the byte where the targa data can be found. targa_offset::type _offset; /// The type of color map used by the image, i.e. RGB or indexed. targa_color_map_type::type _color_map_type; /// The type of image data, i.e compressed, indexed, uncompressed RGB, etc. targa_image_type::type _image_type; /// Index of first entry in the color map table. targa_color_map_start::type _color_map_start; /// Number of entries in the color map table. targa_color_map_length::type _color_map_length; /// Bit depth for each color map entry. targa_color_map_depth::type _color_map_depth; /// X coordinate of the image origin. targa_origin_element::type _x_origin; /// Y coordinate of the image origin. targa_origin_element::type _y_origin; /// Width of the image in pixels. targa_dimension::type _width; /// Height of the image in pixels. targa_dimension::type _height; /// Bit depth of the image. targa_depth::type _bits_per_pixel; /// The targa image descriptor. targa_descriptor::type _descriptor; // false: Origin in lower left-hand corner. // true: Origin in upper left-hand corner. targa_screen_origin_bit::type _screen_origin_bit; /// Used internally to identify if the header has been read. bool _valid; }; /// Read settings for targa images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< targa_tag > : public image_read_settings_base { /// Default constructor image_read_settings() : image_read_settings_base() {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. image_read_settings( const point_t& top_left , const point_t& dim ) : image_read_settings_base( top_left , dim ) {} }; /// Write information for targa images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< targa_tag > { }; } // namespace gil } // namespace boost #endif PK��p�[ �.3_��_��extension/io/targa/write.hppnu��[��// // Copyright 2010 Kenneth Riddile // // 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_EXTENSION_IO_TARGA_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_WRITE_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <boost/gil/extension/io/targa/detail/supported_types.hpp> #include <boost/gil/extension/io/targa/detail//write.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[��d��,��extension/io/targa/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_TARGA_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/targa/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// Targa Backend /// template< typename Device > struct reader_backend< Device , targa_tag > { public: using format_tag_t = targa_tag; public: reader_backend( const Device& io_dev , const image_read_settings< targa_tag >& settings ) : _io_dev ( io_dev ) , _scanline_length(0) , _settings( settings ) , _info() { read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { _info._header_size = targa_header_size::_size; _info._offset = _io_dev.read_uint8() + _info._header_size; _info._color_map_type = _io_dev.read_uint8(); _info._image_type = _io_dev.read_uint8(); _info._color_map_start = _io_dev.read_uint16(); _info._color_map_length = _io_dev.read_uint16(); _info._color_map_depth = _io_dev.read_uint8(); _info._x_origin = _io_dev.read_uint16(); _info._y_origin = _io_dev.read_uint16(); _info._width = _io_dev.read_uint16(); _info._height = _io_dev.read_uint16(); if( _info._width < 1 \|\| _info._height < 1 ) { io_error( "Invalid dimension for targa file" ); } _info._bits_per_pixel = _io_dev.read_uint8(); if( _info._bits_per_pixel != 24 && _info._bits_per_pixel != 32 ) { io_error( "Unsupported bit depth for targa file" ); } _info._descriptor = _io_dev.read_uint8(); // According to TGA specs, http://www.gamers.org/dEngine/quake3/TGA.txt, // the image descriptor byte is: // // For Data Type 1, This entire byte should be set to 0. if (_info._image_type == 1 && _info._descriptor != 0) { io_error("Unsupported descriptor for targa file"); } else if (_info._bits_per_pixel == 24) { // Bits 3-0 - For the Targa 24, it should be 0. if ((_info._descriptor & 0x0FU) != 0) { io_error("Unsupported descriptor for targa file"); } } else if (_info._bits_per_pixel == 32) { // Bits 3-0 - For Targa 32, it should be 8. if (_info._descriptor != 8 && _info._descriptor != 40) { io_error("Unsupported descriptor for targa file"); } } else { io_error("Unsupported descriptor for targa file"); } if (_info._descriptor & 32) { _info._screen_origin_bit = true; } _info._valid = true; } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } public: Device _io_dev; std::size_t _scanline_length; image_read_settings< targa_tag > _settings; image_read_info< targa_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[৫"��"��#��extension/io/targa/detail/write.hppnu��[��// // Copyright 2010-2012 Kenneth Riddile, Christian Henning // // 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_EXTENSION_IO_TARGA_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_WRITE_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <boost/gil/extension/io/targa/detail/writer_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { template < int N > struct get_targa_view_type {}; template <> struct get_targa_view_type< 3 > { using type = bgr8_view_t; }; template <> struct get_targa_view_type< 4 > { using type = bgra8_view_t; }; struct targa_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , targa_tag > {}; }; } // detail /// /// TARGA Writer /// template< typename Device > class writer< Device , targa_tag > : public writer_backend< Device , targa_tag > { private: using backend_t = writer_backend<Device, targa_tag>; public: writer( const Device& io_dev , const image_write_info< targa_tag >& info ) : backend_t( io_dev , info ) {} template<typename View> void apply( const View& view ) { write( view ); } private: template< typename View > void write( const View& view ) { uint8_t bit_depth = static_cast<uint8_t>( num_channels<View>::value 8 ); // write the TGA header this->_io_dev.write_uint8( 0 ); // offset this->_io_dev.write_uint8( targa_color_map_type::_rgb ); this->_io_dev.write_uint8( targa_image_type::_rgb ); this->_io_dev.write_uint16( 0 ); // color map start this->_io_dev.write_uint16( 0 ); // color map length this->_io_dev.write_uint8( 0 ); // color map depth this->_io_dev.write_uint16( 0 ); // x origin this->_io_dev.write_uint16( 0 ); // y origin this->_io_dev.write_uint16( static_cast<uint16_t>( view.width() ) ); // width in pixels this->_io_dev.write_uint16( static_cast<uint16_t>( view.height() ) ); // height in pixels this->_io_dev.write_uint8( bit_depth ); if( 32 == bit_depth ) { this->_io_dev.write_uint8( 8 ); // 8-bit alpha channel descriptor } else { this->_io_dev.write_uint8( 0 ); } write_image< View , typename detail::get_targa_view_type< num_channels< View >::value >::type >( view ); } template< typename View , typename TGA_View > void write_image( const View& view ) { size_t row_size = view.width() * num_channels<View>::value; byte_vector_t buffer( row_size ); std::fill( buffer.begin(), buffer.end(), 0 ); TGA_View row = interleaved_view( view.width() , 1 , reinterpret_cast<typename TGA_View::value_type>( &buffer.front() ) , row_size ); for( typename View::y_coord_t y = view.height() - 1; y > -1; --y ) { copy_pixels( subimage_view( view , 0 , static_cast<int>( y ) , static_cast<int>( view.width() ) , 1 ) , row ); this->_io_dev.write( &buffer.front(), row_size ); } } }; /// /// TARGA Dynamic Image Writer /// template< typename Device > class dynamic_image_writer< Device , targa_tag > : public writer< Device , targa_tag > { using parent_t = writer<Device, targa_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< targa_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::targa_write_is_supported , parent_t > op( this ); apply_operation( views, op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[J������+��extension/io/targa/detail/scanline_read.hppnu��[��// // Copyright 2012 Kenneth Riddile, Christian Henning // // 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_EXTENSION_IO_TARGA_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/targa/detail/is_allowed.hpp> #include <boost/gil/extension/io/targa/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <boost/gil/io/typedefs.hpp> #include <vector> namespace boost { namespace gil { /// /// Targa Scanline Reader /// template< typename Device > class scanline_reader< Device , targa_tag > : public reader_backend< Device , targa_tag > { public: using tag_t = targa_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; // // Constructor // scanline_reader( Device& device , const image_read_settings< targa_tag >& settings ) : backend_t( device , settings ) { initialize(); } /// Read part of image defined by View and return the data. void read( byte_t dst, int pos ) { // jump to scanline long offset = this->_info._offset + ( this->_info._height - 1 - pos ) * static_cast< long >( this->_scanline_length ); this->_io_dev.seek( offset ); read_row( dst ); } /// Skip over a scanline. void skip( byte_t, int ) { this->_io_dev.seek( static_cast<long>( this->_scanline_length ) , SEEK_CUR ); } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { if( this->_info._color_map_type != targa_color_map_type::_rgb ) { io_error( "scanline reader cannot read indexed targa files." ); } if( this->_info._image_type != targa_image_type::_rgb ) { io_error( "scanline reader cannot read this targa image type." ); } switch( this->_info._image_type ) { case targa_image_type::_rgb: { if( this->_info._color_map_type != targa_color_map_type::_rgb ) { io_error( "Inconsistent color map type and image type in targa file." ); } if( this->_info._color_map_length != 0 ) { io_error( "Non-indexed targa files containing a palette are not supported." ); } if( this->_info._screen_origin_bit ) { io_error( "scanline reader cannot read targa files which have screen origin bit set." ); } switch( this->_info._bits_per_pixel ) { case 24: case 32: { this->_scanline_length = this->_info._width ( this->_info._bits_per_pixel / 8 ); // jump to first scanline this->_io_dev.seek( static_cast< long >( this->_info._offset )); break; } default: { io_error( "Unsupported bit depth in targa file." ); break; } } break; } default: { io_error( "Unsupported image type in targa file." ); break; } } } void read_row( byte_t* dst ) { this->_io_dev.read( dst, this->_scanline_length ); } }; } // namespace gil } // namespace boost #endif PK��p�[y^�6)2��)2��"��extension/io/targa/detail/read.hppnu��[��// // Copyright 2012 Kenneth Riddile, Christian Henning // // 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_EXTENSION_IO_TARGA_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_READ_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <boost/gil/extension/io/targa/detail/reader_backend.hpp> #include <boost/gil/extension/io/targa/detail/is_allowed.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/typedefs.hpp> #include <type_traits> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// Targa Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , targa_tag , ConversionPolicy > : public reader_base< targa_tag , ConversionPolicy > , public reader_backend< Device , targa_tag > { private: using this_t = reader<Device, targa_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, targa_tag>; reader( const Device& io_dev , const image_read_settings< targa_tag >& settings ) : reader_base< targa_tag , ConversionPolicy >() , backend_t( io_dev , settings ) {} reader( const Device& io_dev , const cc_t& cc , const image_read_settings< targa_tag >& settings ) : reader_base< targa_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} template< typename View > void apply( const View& dst_view ) { using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info, is_read_and_convert_t() ) , "Image types aren't compatible." ); switch( this->_info._image_type ) { case targa_image_type::_rgb: { if( this->_info._color_map_type != targa_color_map_type::_rgb ) { io_error( "Inconsistent color map type and image type in targa file." ); } if( this->_info._color_map_length != 0 ) { io_error( "Non-indexed targa files containing a palette are not supported." ); } switch( this->_info._bits_per_pixel ) { case 24: { this->_scanline_length = this->_info._width * ( this->_info._bits_per_pixel / 8 ); if( this->_info._screen_origin_bit ) { read_data< bgr8_view_t >( flipped_up_down_view( dst_view ) ); } else { read_data< bgr8_view_t >( dst_view ); } break; } case 32: { this->_scanline_length = this->_info._width * ( this->_info._bits_per_pixel / 8 ); if( this->_info._screen_origin_bit ) { read_data< bgra8_view_t >( flipped_up_down_view( dst_view ) ); } else { read_data< bgra8_view_t >( dst_view ); } break; } default: { io_error( "Unsupported bit depth in targa file." ); break; } } break; } case targa_image_type::_rle_rgb: { if( this->_info._color_map_type != targa_color_map_type::_rgb ) { io_error( "Inconsistent color map type and image type in targa file." ); } if( this->_info._color_map_length != 0 ) { io_error( "Non-indexed targa files containing a palette are not supported." ); } switch( this->_info._bits_per_pixel ) { case 24: { if( this->_info._screen_origin_bit ) { read_rle_data< bgr8_view_t >( flipped_up_down_view( dst_view ) ); } else { read_rle_data< bgr8_view_t >( dst_view ); } break; } case 32: { if( this->_info._screen_origin_bit ) { read_rle_data< bgra8_view_t >( flipped_up_down_view( dst_view ) ); } else { read_rle_data< bgra8_view_t >( dst_view ); } break; } default: { io_error( "Unsupported bit depth in targa file." ); break; } } break; } default: { io_error( "Unsupported image type in targa file." ); break; } } } private: // 8-8-8 BGR // 8-8-8-8 BGRA template< typename View_Src, typename View_Dst > void read_data( const View_Dst& view ) { byte_vector_t row( this->_info._width * (this->_info._bits_per_pixel / 8) ); // jump to first scanline this->_io_dev.seek( static_cast< long >( this->_info._offset )); View_Src v = interleaved_view( this->_info._width, 1, reinterpret_cast<typename View_Src::value_type>( &row.front() ), this->_info._width num_channels< View_Src >::value ); typename View_Src::x_iterator beg = v.row_begin( 0 ) + this->_settings._top_left.x; typename View_Src::x_iterator end = beg + this->_settings._dim.x; // read bottom up since targa origin is bottom left for( std::ptrdiff_t y = this->_settings._dim.y - 1; y > -1; --y ) { // @todo: For now we're reading the whole scanline which is // slightly inefficient. Later versions should try to read // only the bytes which are necessary. this->_io_dev.read( &row.front(), row.size() ); this->_cc_policy.read( beg, end, view.row_begin(y) ); } } // 8-8-8 BGR // 8-8-8-8 BGRA template< typename View_Src, typename View_Dst > void read_rle_data( const View_Dst& view ) { targa_depth::type bytes_per_pixel = this->_info._bits_per_pixel / 8; size_t image_size = this->_info._width * this->_info._height * bytes_per_pixel; byte_vector_t image_data( image_size ); this->_io_dev.seek( static_cast< long >( this->_info._offset )); for( size_t pixel = 0; pixel < image_size; ) { targa_offset::type current_byte = this->_io_dev.read_uint8(); if( current_byte & 0x80 ) // run length chunk (high bit = 1) { uint8_t chunk_length = current_byte - 127; uint8_t pixel_data[4]; for( size_t channel = 0; channel < bytes_per_pixel; ++channel ) { pixel_data[channel] = this->_io_dev.read_uint8(); } // Repeat the next pixel chunk_length times for( uint8_t i = 0; i < chunk_length; ++i, pixel += bytes_per_pixel ) { memcpy( &image_data[pixel], pixel_data, bytes_per_pixel ); } } else // raw chunk { uint8_t chunk_length = current_byte + 1; // Write the next chunk_length pixels directly size_t pixels_written = chunk_length * bytes_per_pixel; this->_io_dev.read( &image_data[pixel], pixels_written ); pixel += pixels_written; } } View_Src v = flipped_up_down_view( interleaved_view( this->_info._width, this->_info._height, reinterpret_cast<typename View_Src::value_type>( &image_data.front() ), this->_info._width num_channels< View_Src >::value ) ); for( std::ptrdiff_t y = 0; y != this->_settings._dim.y; ++y ) { typename View_Src::x_iterator beg = v.row_begin( y ) + this->_settings._top_left.x; typename View_Src::x_iterator end = beg + this->_settings._dim.x; this->_cc_policy.read( beg, end, view.row_begin(y) ); } } }; namespace detail { class targa_type_format_checker { public: targa_type_format_checker( const targa_depth::type& bpp ) : _bpp( bpp ) {} template< typename Image > bool apply() { if( _bpp < 32 ) { return pixels_are_compatible< typename Image::value_type, rgb8_pixel_t >::value ? true : false; } else { return pixels_are_compatible< typename Image::value_type, rgba8_pixel_t >::value ? true : false; } } private: // to avoid C4512 targa_type_format_checker& operator=( const targa_type_format_checker& ) { return this; } private: const targa_depth::type _bpp; }; struct targa_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , targa_tag > {}; }; } // namespace detail /// /// Targa Dynamic Image Reader /// template< typename Device > class dynamic_image_reader< Device , targa_tag > : public reader< Device , targa_tag , detail::read_and_no_convert > { using parent_t = reader<Device, targa_tag, detail::read_and_no_convert>; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< targa_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::targa_type_format_checker format_checker( this->_info._bits_per_pixel ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::targa_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[��p"��,��extension/io/targa/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_TARGA_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/targa/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// TARGA Writer Backend /// template< typename Device > struct writer_backend< Device , targa_tag > { public: using format_tag_t = targa_tag; public: writer_backend( const Device& io_dev , const image_write_info< targa_tag >& info ) : _io_dev( io_dev ) , _info( info ) {} public: Device _io_dev; image_write_info< targa_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[\�A�� -��extension/io/targa/detail/supported_types.hppnu��[��// // Copyright 2010 Kenneth Riddile // // 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_EXTENSION_IO_TARGA_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { // Read support template< typename Channel , typename ColorSpace > struct targa_read_support : read_support_false { static const targa_depth::type bpp = 0; }; template<> struct targa_read_support<uint8_t , rgb_t > : read_support_true { static const targa_depth::type bpp = 24; }; template<> struct targa_read_support<uint8_t , rgba_t > : read_support_true { static const targa_depth::type bpp = 32; }; // Write support template< typename Channel , typename ColorSpace > struct targa_write_support : write_support_false {}; template<> struct targa_write_support<uint8_t , rgb_t > : write_support_true {}; template<> struct targa_write_support<uint8_t , rgba_t > : write_support_true {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, targa_tag> : std::integral_constant < bool, detail::targa_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::targa_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const typename targa_depth::type bpp = parent_t::bpp; }; template<typename Pixel> struct is_write_supported<Pixel, targa_tag> : std::integral_constant < bool, detail::targa_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > {}; }} // namespace boost::gil #endif PK��p�[��X��(��extension/io/targa/detail/is_allowed.hppnu��[��// // Copyright 2010 Kenneth Riddile // // 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_EXTENSION_IO_TARGA_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< targa_tag >& info , std::true_type // is read_and_no_convert ) { targa_depth::type src_bits_per_pixel = 0; switch( info._bits_per_pixel ) { case 24: case 32: { src_bits_per_pixel = info._bits_per_pixel; break; } default: { io_error( "Pixel size not supported." ); break; } } using channel_t = typename channel_traits<typename element_type<typename View::value_type>::type>::value_type; targa_depth::type dst_bits_per_pixel = detail::unsigned_integral_num_bits< channel_t >::value num_channels< View >::value; return ( dst_bits_per_pixel == src_bits_per_pixel ); } template< typename View > bool is_allowed( const image_read_info< targa_tag >& /* info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[˛�+��extension/io/targa/read.hppnu��[��// // Copyright 2010-2012 Kenneth Riddile, Christian Henning // // 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_EXTENSION_IO_TARGA_READ_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_READ_HPP #include <boost/gil/extension/io/targa/tags.hpp> #include <boost/gil/extension/io/targa/detail/read.hpp> #include <boost/gil/extension/io/targa/detail/scanline_read.hpp> #include <boost/gil/extension/io/targa/detail/supported_types.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[�~��extension/io/targa/old.hppnu��[��// // Copyright 2010 Christian Henning // // 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_EXTENSION_IO_TARGA_OLD_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_OLD_HPP #include <boost/gil/extension/io/targa.hpp> namespace boost { namespace gil { /// \ingroup BMP_IO /// \brief Returns the width and height of the BMP file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid BMP file template<typename String> inline point_t targa_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, targa_tag>::type; backend_t backend = read_image_info(filename, targa_tag()); return { backend._info._width, backend._info._height }; } /// \ingroup BMP_IO /// \brief Loads the image specified by the given targa image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void targa_read_view( const String& filename , const View& view ) { read_view( filename , view , targa_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given bmp image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void targa_read_image( const String& filename , Image& img ) { read_image( filename , img , targa_tag() ); } /// \ingroup BMP_IO /// \brief Loads and color-converts the image specified by the given targa image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void targa_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , targa_tag() ); } /// \ingroup BMP_IO /// \brief Loads and color-converts the image specified by the given targa image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid BMP file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void targa_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , targa_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given targa image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid BMP file template< typename String , typename Image , typename CC > inline void targa_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , targa_tag() ); } /// \ingroup BMP_IO /// \brief Allocates a new image whose dimensions are determined by the given targa image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid BMP file template< typename String , typename Image > inline void targa_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , targa_tag() ); } /// \ingroup BMP_IO /// \brief Saves the view to a targa file specified by the given targa image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the BMP library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void targa_write_view( const String& filename , const View& view ) { write_view( filename , view , targa_tag() ); } } // namespace gil } // namespace boost #endif PK��p�[��extension/io/tiff.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_TIFF_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_HPP #include <boost/gil/extension/io/tiff/read.hpp> #include <boost/gil/extension/io/tiff/write.hpp> #endif PK��p�[5L/p?/��?/��extension/io/tiff/tags.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_TAGS_HPP #include <boost/gil/extension/io/tiff/detail/log.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> // taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <tiff.h> #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS } #endif namespace boost { namespace gil { /// Defines tiff tag. struct tiff_tag : format_tag {}; /// http://www.awaresystems.be/imaging/tiff/tifftags/baseline.html /// http://www.remotesensing.org/libtiff/ /// TIFF property base class template< typename T, int Value > struct tiff_property_base : property_base< T > { /// Tag, needed when reading or writing image properties. static const ttag_t tag = Value; /// The list of argument types used in the interface of LibTIFF /// for /// this property: /// http://www.remotesensing.org/libtiff/man/TIFFGetField.3tiff.html /// http://www.remotesensing.org/libtiff/man/TIFFSetField.3tiff.html using arg_types = mp11::mp_list<typename property_base<unsigned short>::type>; }; /// baseline tags /// Defines type for new subfile property. struct tiff_new_subfile_type : tiff_property_base< uint32_t, TIFFTAG_SUBFILETYPE > {}; /// Defines type for subfile property. struct tiff_subfile_type : tiff_property_base< uint16_t, TIFFTAG_OSUBFILETYPE > {}; /// Defines type for image width property. struct tiff_image_width : tiff_property_base< uint32_t, TIFFTAG_IMAGEWIDTH > {}; /// Defines type for image height property. struct tiff_image_height : tiff_property_base< uint32_t, TIFFTAG_IMAGELENGTH > {}; /// Defines type for bits per sample property. struct tiff_bits_per_sample : tiff_property_base< uint16_t, TIFFTAG_BITSPERSAMPLE > {}; /// Defines type for compression property. struct tiff_compression : tiff_property_base< uint16_t, TIFFTAG_COMPRESSION > {}; /// Defines type for photometric interpretation property. struct tiff_photometric_interpretation : tiff_property_base< uint16_t, TIFFTAG_PHOTOMETRIC > {}; /// Defines type for threshold property. struct tiff_thresholding : tiff_property_base< uint16_t, TIFFTAG_THRESHHOLDING > {}; /// Defines type for cell width property. struct tiff_cell_width : tiff_property_base< uint16_t, TIFFTAG_CELLWIDTH > {}; /// Defines type for cell length property. struct tiff_cell_length : tiff_property_base< uint16_t, TIFFTAG_CELLLENGTH > {}; /// Defines type for fill order property. struct tiff_fill_order : tiff_property_base< std::string, TIFFTAG_FILLORDER > {}; /// Defines type for image description. struct tiff_image_description : tiff_property_base< std::string, TIFFTAG_IMAGEDESCRIPTION > {}; /// Defines type for make property. struct tiff_make : tiff_property_base< std::string, TIFFTAG_MAKE > {}; /// Defines type for model property. struct tiff_model : tiff_property_base< std::string, TIFFTAG_MODEL > {}; /// Defines type for image orientation. struct tiff_orientation : tiff_property_base< uint16_t, TIFFTAG_ORIENTATION > {}; /// Defines type for samples per pixel property. struct tiff_samples_per_pixel : tiff_property_base< uint16_t, TIFFTAG_SAMPLESPERPIXEL > {}; /// Defines type for rows per strip property. struct tiff_rows_per_strip : tiff_property_base< uint32_t, TIFFTAG_ROWSPERSTRIP > {}; /// Defines type for min sample property. struct tiff_min_sample_value : tiff_property_base< uint16_t, TIFFTAG_MINSAMPLEVALUE > {}; /// Defines type for max sample property. struct tiff_max_sample_value : tiff_property_base< uint16_t, TIFFTAG_MAXSAMPLEVALUE > {}; /// Defines type for x resolution property. struct tiff_x_resolution : tiff_property_base< float, TIFFTAG_XRESOLUTION > {}; /// Defines type for y resolution property. struct tiff_y_resolution : tiff_property_base< float, TIFFTAG_YRESOLUTION > {}; /// Defines type for resolution unit property. enum class tiff_resolution_unit_value: std:: uint16_t { NONE = RESUNIT_NONE, INCH = RESUNIT_INCH, CENTIMETER = RESUNIT_CENTIMETER }; struct tiff_resolution_unit : tiff_property_base< tiff_resolution_unit_value, TIFFTAG_RESOLUTIONUNIT > {}; /// Defines type for planar configuration property. struct tiff_planar_configuration : tiff_property_base< uint16_t, TIFFTAG_PLANARCONFIG > {}; /// Defines type for gray response unit property. struct tiff_gray_response_unit : tiff_property_base< uint16_t, TIFFTAG_GRAYRESPONSEUNIT > {}; /// Defines type for gray response curve property. struct tiff_gray_response_curve : tiff_property_base< uint16_t, TIFFTAG_GRAYRESPONSECURVE > {}; /// Defines type for software vendor property. struct tiff_software : tiff_property_base< std::string, TIFFTAG_SOFTWARE > {}; /// Defines type for date time property. struct tiff_date_time : tiff_property_base< std::string, TIFFTAG_DATETIME > {}; /// Defines type for artist information property. struct tiff_artist : tiff_property_base< std::string, TIFFTAG_ARTIST > {}; /// Defines type for host computer property. struct tiff_host_computer : tiff_property_base< std::string, TIFFTAG_HOSTCOMPUTER > {}; /// Helper structure for reading a color mapper. struct tiff_color_map { using red_t = uint16_t ; using green_t = uint16_t ; using blue_t = uint16_t ; static const unsigned int tag = TIFFTAG_COLORMAP; }; /// Defines type for extra samples property. struct tiff_extra_samples : tiff_property_base<std::vector<uint16_t>, TIFFTAG_EXTRASAMPLES> { using arg_types = mp11::mp_list<uint16_t, uint16_t const>; }; /// Defines type for copyright property. struct tiff_copyright : tiff_property_base< std::string, TIFFTAG_COPYRIGHT > {}; /// non-baseline tags /// Defines type for sample format property. struct tiff_sample_format : tiff_property_base< uint16_t, TIFFTAG_SAMPLEFORMAT > {}; /// Defines type for indexed property. /// Not supported yet //struct tiff_indexed : tiff_property_base< bool, TIFFTAG_INDEXED > {}; /// Tile related tags /// Defines type for a (not) tiled tiff image struct tiff_is_tiled : tiff_property_base< bool, false > {}; /// Defines type for tile width struct tiff_tile_width : tiff_property_base< long, TIFFTAG_TILEWIDTH > {}; /// Defines type for tile length struct tiff_tile_length : tiff_property_base< long, TIFFTAG_TILELENGTH > {}; /// Defines the page to read in a multipage tiff file. struct tiff_directory : property_base< tdir_t > { using default_value = std::integral_constant<type, 0>; }; /// Non-baseline tags /// Defines type for icc profile property. struct tiff_icc_profile : tiff_property_base<std::vector<uint8_t>, TIFFTAG_ICCPROFILE> { using arg_types = mp11::mp_list<uint32_t, void const>; }; /// Read information for tiff images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< tiff_tag > { image_read_info() : _width( 0 ) , _height( 0 ) , _compression( COMPRESSION_NONE ) , _bits_per_sample( 0 ) , _samples_per_pixel( 0 ) , _sample_format( SAMPLEFORMAT_UINT ) , _planar_configuration( PLANARCONFIG_CONTIG ) , _photometric_interpretation( PHOTOMETRIC_MINISWHITE ) , _is_tiled( false ) , _tile_width ( 0 ) , _tile_length( 0 ) , _x_resolution( 1 ) , _y_resolution( 1 ) , _resolution_unit( tiff_resolution_unit_value:: NONE ) , _icc_profile( ) {} /// The number of rows of pixels in the image. tiff_image_width::type _width; /// The number of columns in the image, i.e., the number of pixels per row. tiff_image_height::type _height; /// Compression scheme used on the image data. tiff_compression::type _compression; /// Number of bits per component. tiff_bits_per_sample::type _bits_per_sample; /// The number of components per pixel. tiff_samples_per_pixel::type _samples_per_pixel; /// Specifies how to interpret each data sample in a pixel. tiff_sample_format::type _sample_format; /// How the components of each pixel are stored. tiff_planar_configuration::type _planar_configuration; /// The color space of the image data. tiff_photometric_interpretation::type _photometric_interpretation; /// Is tiled? tiff_is_tiled::type _is_tiled; /// Tile width tiff_tile_width::type _tile_width; /// Tile length tiff_tile_length::type _tile_length; tiff_x_resolution::type _x_resolution; tiff_y_resolution::type _y_resolution; tiff_resolution_unit::type _resolution_unit; tiff_icc_profile:: type _icc_profile; }; /// Read settings for tiff images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< tiff_tag > : public image_read_settings_base { /// Default constructor image_read_settings< tiff_tag >() : image_read_settings_base() , _directory( tiff_directory::default_value::value ) {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. /// \param directory Defines the page to read in a multipage tiff file. image_read_settings( const point_t& top_left , const point_t& dim , const tiff_directory::type& directory = tiff_directory::default_value::value ) : image_read_settings_base( top_left , dim ) , _directory( directory ) {} /// Defines the page to read in a multipage tiff file. tiff_directory::type _directory; }; /// Write settings for tiff images. /// /// The structure can be used for all write_xxx functions, except write_image_info. template< typename Log > struct image_write_info< tiff_tag, Log > { /// Default constructor image_write_info() : _photometric_interpretation ( PHOTOMETRIC_MINISBLACK ) , _photometric_interpretation_user_defined( false ) , _compression ( COMPRESSION_NONE ) , _orientation ( ORIENTATION_TOPLEFT ) , _planar_configuration ( PLANARCONFIG_CONTIG ) , _is_tiled ( false ) , _tile_width ( 0 ) , _tile_length ( 0 ) , _x_resolution ( 1 ) , _y_resolution ( 1 ) , _resolution_unit ( tiff_resolution_unit_value::NONE ) , _icc_profile ( ) {} /// The color space of the image data. tiff_photometric_interpretation::type _photometric_interpretation; bool _photometric_interpretation_user_defined; /// Compression scheme used on the image data. tiff_compression::type _compression; /// The orientation of the image with respect to the rows and columns. tiff_orientation::type _orientation; /// How the components of each pixel are stored. tiff_planar_configuration::type _planar_configuration; /// Is the image tiled? tiff_is_tiled::type _is_tiled; /// Tiles width tiff_tile_width::type _tile_width; /// Tiles length tiff_tile_length::type _tile_length; /// x, y resolution tiff_x_resolution::type _x_resolution; tiff_y_resolution::type _y_resolution; tiff_resolution_unit::type _resolution_unit; tiff_icc_profile:: type _icc_profile; /// A log to transcript error and warning messages issued by libtiff. Log _log; }; } // namespace gil } // namespace boost #endif PK��p�[�V��`��`��extension/io/tiff/write.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_TIFF_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_WRITE_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/io/tiff/detail/supported_types.hpp> #include <boost/gil/extension/io/tiff/detail/write.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[��+��extension/io/tiff/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_TIFF_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/tiff/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// TIFF Backend /// template< typename Device > struct reader_backend< Device , tiff_tag > { public: using format_tag_t = tiff_tag; public: reader_backend( const Device& io_dev , const image_read_settings< tiff_tag >& settings ) : _io_dev ( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) , _red ( nullptr ) , _green( nullptr ) , _blue ( nullptr ) { init_multipage_read( settings ); read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { io_error_if( _io_dev.template get_property<tiff_image_width> ( _info._width ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_image_height> ( _info._height ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_compression> ( _info._compression ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_samples_per_pixel> ( _info._samples_per_pixel ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_bits_per_sample> ( _info._bits_per_sample ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_sample_format> ( _info._sample_format ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_planar_configuration> ( _info._planar_configuration ) == false , "cannot read tiff tag." ); io_error_if( _io_dev.template get_property<tiff_photometric_interpretation>( _info._photometric_interpretation ) == false , "cannot read tiff tag." ); _info._is_tiled = false; // Tile tags if( _io_dev.is_tiled() ) { _info._is_tiled = true; io_error_if( !_io_dev.template get_property< tiff_tile_width >( _info._tile_width ) , "cannot read tiff_tile_width tag." ); io_error_if( !_io_dev.template get_property< tiff_tile_length >( _info._tile_length ) , "cannot read tiff_tile_length tag." ); } io_error_if( _io_dev.template get_property<tiff_resolution_unit>( _info._resolution_unit) == false , "cannot read tiff tag"); io_error_if( _io_dev. template get_property<tiff_x_resolution>( _info._x_resolution ) == false , "cannot read tiff tag" ); io_error_if( _io_dev. template get_property<tiff_y_resolution>( _info._y_resolution ) == false , "cannot read tiff tag" ); /// optional and non-baseline properties below here _io_dev. template get_property <tiff_icc_profile> ( _info._icc_profile ); } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( (tiff_image_width::type) img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( (tiff_image_height::type) img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } private: void init_multipage_read( const image_read_settings< tiff_tag >& settings ) { if( settings._directory > 0 ) { _io_dev.set_directory( settings._directory ); } } public: Device _io_dev; image_read_settings< tiff_tag > _settings; image_read_info< tiff_tag > _info; std::size_t _scanline_length; // palette tiff_color_map::red_t _red; tiff_color_map::green_t _green; tiff_color_map::blue_t _blue; rgb16_planar_view_t _palette; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[� i�� extension/io/tiff/detail/log.hppnu��[��// // Copyright 2009 Christian Henning // // 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_EXTENSION_IO_TIFF_DETAIL_LOG_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_LOG_HPP #include <iostream> extern "C" { #include "tiffio.h" } namespace boost { namespace gil { class tiff_no_log { public: tiff_no_log() { TIFFSetErrorHandler ( nullptr ); TIFFSetWarningHandler( nullptr ); } }; class console_log { public: console_log() { TIFFSetErrorHandler ( console_log::error ); TIFFSetWarningHandler( console_log::warning ); } private: static void error( const char /* module / , const char fmt , va_list ap ) { char buf[1000]; sprintf(buf, fmt, ap); std::cout << "error: " << buf << std::endl; } static void warning( char const* /* module / , char const fmt , va_list ap ) { char buf[1000]; sprintf(buf, fmt, ap); std::cout << "warning: " << fmt << std::endl; } }; } // namespace gil } // namespace boost #endif PK��p�[�V�-:��-:��"��extension/io/tiff/detail/write.hppnu��[��// // Copyright 2007-2012 Christian Henning, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_WRITE_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/io/tiff/detail/writer_backend.hpp> #include <boost/gil/extension/io/tiff/detail/device.hpp> #include <boost/gil/premultiply.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <algorithm> #include <string> #include <type_traits> #include <vector> extern "C" { #include "tiff.h" #include "tiffio.h" } namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { template <typename PixelReference> struct my_interleaved_pixel_iterator_type_from_pixel_reference { private: using pixel_t = typename std::remove_reference<PixelReference>::type::value_type; public: using type = typename iterator_type_from_pixel < pixel_t, false, false, true >::type; }; template< typename Channel , typename Layout , bool Mutable > struct my_interleaved_pixel_iterator_type_from_pixel_reference< const bit_aligned_pixel_reference< byte_t , Channel , Layout , Mutable > > : public iterator_type_from_pixel< const bit_aligned_pixel_reference< uint8_t , Channel , Layout , Mutable > ,false ,false ,true > {}; struct tiff_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , tiff_tag > {}; }; } // namespace detail /// /// TIFF Writer /// template < typename Device, typename Log > class writer< Device , tiff_tag , Log > : public writer_backend< Device , tiff_tag > { private: using backend_t = writer_backend<Device, tiff_tag>; public: writer( const Device& io_dev , const image_write_info< tiff_tag >& info ) : backend_t( io_dev , info ) {} template<typename View> void apply( const View& view ) { write_view( view ); } private: template< typename View > void write_view( const View& view ) { using pixel_t = typename View::value_type; // get the type of the first channel (heterogeneous pixels might be broken for now!) using channel_t = typename channel_traits<typename element_type<pixel_t>::type>::value_type; tiff_bits_per_sample::type bits_per_sample = detail::unsigned_integral_num_bits< channel_t >::value; tiff_samples_per_pixel::type samples_per_pixel = num_channels< pixel_t >::value; this->write_header( view ); if( this->_info._is_tiled == false ) { write_data( view , (view.width() * samples_per_pixel * bits_per_sample + 7) / 8 , typename is_bit_aligned< pixel_t >::type() ); } else { tiff_tile_width::type tw = this->_info._tile_width; tiff_tile_length::type th = this->_info._tile_length; if(!this->_io_dev.check_tile_size( tw, th )) { io_error( "Tile sizes need to be multiples of 16." ); } // tile related tags this->_io_dev.template set_property<tiff_tile_width> ( tw ); this->_io_dev.template set_property<tiff_tile_length>( th ); write_tiled_data( view , tw , th , typename is_bit_aligned< pixel_t >::type() ); } } ////////////////////////////// template<typename View> void write_bit_aligned_view_to_dev( const View& view , const std::size_t row_size_in_bytes , const std::true_type& // has_alpha ) { byte_vector_t row( row_size_in_bytes ); using x_it_t = typename View::x_iterator; x_it_t row_it = x_it_t( &(row.begin())); auto pm_view = premultiply_view <typename View:: value_type> (view); for( typename View::y_coord_t y = 0; y < pm_view.height(); ++y ) { std::copy( pm_view.row_begin( y ) , pm_view.row_end( y ) , row_it ); this->_io_dev.write_scaline( row , (uint32) y , 0 ); // @todo: do optional bit swapping here if you need to... } } template<typename View> void write_bit_aligned_view_to_dev( const View& view , const std::size_t row_size_in_bytes , const std::false_type& // has_alpha ) { byte_vector_t row( row_size_in_bytes ); using x_it_t = typename View::x_iterator; x_it_t row_it = x_it_t( &(row.begin())); for( typename View::y_coord_t y = 0; y < view.height(); ++y ) { std::copy( view.row_begin( y ) , view.row_end( y ) , row_it ); this->_io_dev.write_scaline( row , (uint32) y , 0 ); // @todo: do optional bit swapping here if you need to... } } ///////////////////////////// template< typename View > void write_data( const View& view , std::size_t row_size_in_bytes , const std::true_type& // bit_aligned ) { using colour_space_t = typename color_space_type<typename View::value_type>::type; using has_alpha_t = mp11::mp_contains<colour_space_t, alpha_t>; write_bit_aligned_view_to_dev(view, row_size_in_bytes, has_alpha_t()); } template< typename View> void write_tiled_data( const View& view , tiff_tile_width::type tw , tiff_tile_length::type th , const std::true_type& // bit_aligned ) { byte_vector_t row( this->_io_dev.get_tile_size() ); using x_it_t = typename View::x_iterator; x_it_t row_it = x_it_t( &(row.begin())); internal_write_tiled_data(view, tw, th, row, row_it); } template< typename View > void write_data( const View& view , std::size_t , const std::false_type& // bit_aligned ) { std::vector< pixel< typename channel_type< View >::type , layout<typename color_space_type< View >::type > > > row( view.size() ); byte_t row_addr = reinterpret_cast< byte_t* >( &row.front() ); // @todo: is there an overhead to doing this when there's no // alpha to premultiply by? I'd hope it's optimised out. auto pm_view = premultiply_view <typename View:: value_type> (view); for( typename View::y_coord_t y = 0; y < pm_view.height(); ++y ) { std::copy( pm_view.row_begin( y ) , pm_view.row_end( y ) , row.begin() ); this->_io_dev.write_scaline( row_addr , (uint32) y , 0 ); // @todo: do optional bit swapping here if you need to... } } template< typename View > void write_tiled_data( const View& view , tiff_tile_width::type tw , tiff_tile_length::type th , const std::false_type& // bit_aligned ) { byte_vector_t row( this->_io_dev.get_tile_size() ); using x_iterator = typename detail::my_interleaved_pixel_iterator_type_from_pixel_reference<typename View::reference>::type; x_iterator row_it = x_iterator( &(row.begin())); internal_write_tiled_data(view, tw, th, row, row_it); } ////////////////////////////// template< typename View , typename IteratorType > void write_tiled_view_to_dev( const View& view , IteratorType it , const std::true_type& // has_alpha ) { auto pm_view = premultiply_view <typename View:: value_type>( view ); std::copy( pm_view.begin() , pm_view.end() , it ); } template< typename View , typename IteratorType > void write_tiled_view_to_dev( const View& view , IteratorType it , const std::false_type& // has_alpha ) { std::copy( view.begin() , view.end() , it ); } ///////////////////////////// template< typename View, typename IteratorType > void internal_write_tiled_data( const View& view , tiff_tile_width::type tw , tiff_tile_length::type th , byte_vector_t& row , IteratorType it ) { std::ptrdiff_t i = 0, j = 0; View tile_subimage_view; while( i < view.height() ) { while( j < view.width() ) { if( j + tw < view.width() && i + th < view.height() ) { // a tile is fully included in the image: just copy values tile_subimage_view = subimage_view( view , static_cast< int >( j ) , static_cast< int >( i ) , static_cast< int >( tw ) , static_cast< int >( th ) ); using colour_space_t = typename color_space_type<typename View::value_type>::type; using has_alpha_t = mp11::mp_contains<colour_space_t, alpha_t>; write_tiled_view_to_dev(tile_subimage_view, it, has_alpha_t()); } else { std::ptrdiff_t width = view.width(); std::ptrdiff_t height = view.height(); std::ptrdiff_t current_tile_width = ( j + tw < width ) ? tw : width - j; std::ptrdiff_t current_tile_length = ( i + th < height) ? th : height - i; tile_subimage_view = subimage_view( view , static_cast< int >( j ) , static_cast< int >( i ) , static_cast< int >( current_tile_width ) , static_cast< int >( current_tile_length ) ); for( typename View::y_coord_t y = 0; y < tile_subimage_view.height(); ++y ) { std::copy( tile_subimage_view.row_begin( y ) , tile_subimage_view.row_end( y ) , it ); std::advance(it, tw); } it = IteratorType( &(row.begin())); } this->_io_dev.write_tile( row , static_cast< uint32 >( j ) , static_cast< uint32 >( i ) , 0 , 0 ); j += tw; } j = 0; i += th; } // @todo: do optional bit swapping here if you need to... } }; /// /// TIFF Dynamic Image Writer /// template< typename Device > class dynamic_image_writer< Device , tiff_tag > : public writer< Device , tiff_tag > { using parent_t = writer<Device, tiff_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< tiff_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::tiff_write_is_supported , parent_t > op( this ); apply_operation( views, op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[#{��>��>����extension/io/tiff/detail/scanline_read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/tiff/detail/device.hpp> #include <boost/gil/extension/io/tiff/detail/is_allowed.hpp> #include <boost/gil/extension/io/tiff/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <algorithm> #include <functional> #include <string> #include <type_traits> #include <vector> // taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <tiff.h> #include <tiffio.h> #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS } #endif namespace boost { namespace gil { /// /// TIFF scanline reader /// template< typename Device > class scanline_reader< Device , tiff_tag > : public reader_backend< Device , tiff_tag > { public: using tag_t = tiff_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; scanline_reader( Device& device , const image_read_settings< tiff_tag >& settings ) : backend_t( device , settings ) { initialize(); } /// Read part of image defined by View and return the data. void read( byte_t dst, int pos ) { _read_function( this, dst, pos ); } /// Skip over a scanline. void skip( byte_t* dst, int pos ) { this->_read_function( this, dst, pos ); } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { io_error_if( this->_info._is_tiled , "scanline_reader doesn't support tiled tiff images." ); if( this->_info._photometric_interpretation == PHOTOMETRIC_PALETTE ) { this->_scanline_length = this->_info._width * num_channels< rgb16_view_t >::value * sizeof( channel_type<rgb16_view_t>::type ); this->_io_dev.get_field_defaulted( this->_red , this->_green , this->_blue ); _buffer = std::vector< byte_t >( this->_io_dev.get_scanline_size() ); switch( this->_info._bits_per_sample ) { case 1: { using channel_t = channel_type<get_pixel_type<gray1_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_1_bit_index_image); break; } case 2: { using channel_t = channel_type<get_pixel_type<gray2_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_2_bits_index_image); break; } case 4: { using channel_t = channel_type<get_pixel_type<gray4_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_4_bits_index_image); break; } case 8: { using channel_t = channel_type<get_pixel_type<gray8_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_8_bits_index_image); break; } case 16: { using channel_t = channel_type<get_pixel_type<gray16_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_16_bits_index_image); break; } case 24: { using channel_t = channel_type<get_pixel_type<gray24_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_24_bits_index_image); break; } case 32: { using channel_t = channel_type<get_pixel_type<gray32_image_t::view_t>::type>::type; int num_colors = channel_traits< channel_t >::max_value() + 1; this->_palette = planar_rgb_view( num_colors , 1 , this->_red , this->_green , this->_blue , sizeof(uint16_t) * num_colors ); _read_function = std::mem_fn(&this_t::read_32_bits_index_image); break; } default: { io_error( "Not supported palette " ); } } } else { this->_scanline_length = this->_io_dev.get_scanline_size(); if( this->_info._planar_configuration == PLANARCONFIG_SEPARATE ) { io_error( "scanline_reader doesn't support planar tiff images." ); } else if( this->_info._planar_configuration == PLANARCONFIG_CONTIG ) { // the read_data function needs to know what gil type the source image is // to have the default color converter function correctly switch( this->_info._photometric_interpretation ) { case PHOTOMETRIC_MINISWHITE: case PHOTOMETRIC_MINISBLACK: { switch( this->_info._bits_per_sample ) { case 1: case 2: case 4: case 6: case 8: case 10: case 12: case 14: case 16: case 24: case 32: { _read_function = std::mem_fn(&this_t::read_row); break; } default: { io_error( "Image type is not supported." ); } } break; } case PHOTOMETRIC_RGB: { switch( this->_info._samples_per_pixel ) { case 3: { switch( this->_info._bits_per_sample ) { case 2: case 4: case 8: case 10: case 12: case 14: case 16: case 24: case 32: { _read_function = std::mem_fn(&this_t::read_row); break; } default: { io_error( "Image type is not supported." ); } } break; } case 4: { switch( this->_info._bits_per_sample ) { case 2: case 4: case 8: case 10: case 12: case 14: case 16: case 24: case 32: { _read_function = std::mem_fn(&this_t::read_row); break; } default: { io_error( "Image type is not supported." ); } } break; } default: { io_error( "Image type is not supported." ); } } break; } case PHOTOMETRIC_SEPARATED: // CYMK { switch( this->_info._bits_per_sample ) { case 2: case 4: case 8: case 10: case 12: case 14: case 16: case 24: case 32: { _read_function = std::mem_fn(&this_t::read_row); break; } default: { io_error( "Image type is not supported." ); } } break; } default: { io_error( "Image type is not supported." ); } } } else { io_error( "Wrong planar configuration setting." ); } } } template< typename Src_View > void read_n_bits_row( byte_t* dst, int pos ) { using dst_view_t = rgb16_view_t; this->_io_dev.read_scanline( _buffer , pos , 0 ); Src_View src_view = interleaved_view( this->_info._width , 1 , (typename Src_View::x_iterator) &_buffer.front() , this->_scanline_length ); dst_view_t dst_view = interleaved_view( this->_info._width , 1 , (typename dst_view_t::value_type) dst , num_channels< dst_view_t >::value 2 * this->_info._width ); typename Src_View::x_iterator src_it = src_view.row_begin( 0 ); typename dst_view_t::x_iterator dst_it = dst_view.row_begin( 0 ); for( dst_view_t::x_coord_t i = 0 ; i < this->_info._width ; ++i, src_it++, dst_it++ ) { auto const c = static_cast<std::uint16_t>(get_color(src_it, gray_color_t())); dst_it = this->_palette[c]; } } void read_1_bit_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray1_image_t::view_t >( dst, pos ); } void read_2_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray2_image_t::view_t >( dst, pos ); } void read_4_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray4_image_t::view_t >( dst, pos ); } void read_8_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray8_image_t::view_t >( dst, pos ); } void read_16_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray16_image_t::view_t >( dst, pos ); } void read_24_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray24_image_t::view_t >( dst, pos ); } void read_32_bits_index_image( byte_t* dst, int pos ) { read_n_bits_row< gray32_image_t::view_t >( dst, pos ); } void read_row(byte_t* dst, int pos ) { this->_io_dev.read_scanline( dst , pos , 0 ); } private: std::vector< byte_t> _buffer; detail::mirror_bits<std::vector<byte_t>, std::true_type> _mirror_bites; std::function<void(this_t, byte_t, int)> _read_function; }; } // namespace gil } // namespace boost #endif PK��p�[�ʞ:�7��7��#��extension/io/tiff/detail/device.hppnu��[��// // Copyright 2007-2008 Andreas Pokorny, Christian Henning // // 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_EXTENSION_IO_TIFF_DETAIL_DEVICE_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_DEVICE_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/io/tiff/detail/log.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <algorithm> #include <memory> #include <sstream> #include <type_traits> // taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <tiff.h> #include <tiffio.h> #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS } #endif #include <tiffio.hxx> namespace boost { namespace gil { namespace detail { template <int n_args> struct get_property_f { template <typename Property> bool call_me(typename Property:: type& value, std::shared_ptr<TIFF>& file); }; template <int n_args> struct set_property_f { template <typename Property> bool call_me(const typename Property:: type& value, std::shared_ptr<TIFF>& file) const; }; template <> struct get_property_f <1> { // For single-valued properties template <typename Property> bool call_me(typename Property::type & value, std::shared_ptr<TIFF>& file) const { // @todo: defaulted, really? return (1 == TIFFGetFieldDefaulted( file.get() , Property:: tag , & value)); } }; template <> struct get_property_f <2> { // Specialisation for multi-valued properties. @todo: add one of // these for the three-parameter fields too. template <typename Property> bool call_me(typename Property::type& vs, std::shared_ptr<TIFF>& file) const { mp11::mp_at<typename Property::arg_types, std::integral_constant<int, 0>> length; mp11::mp_at<typename Property::arg_types, std::integral_constant<int, 1>> pointer; if (1 == TIFFGetFieldDefaulted(file.get(), Property:: tag, & length, & pointer)) { std:: copy_n(static_cast<typename Property::type::const_pointer>(pointer), length, std:: back_inserter(vs)); return true; } else return false; } }; template <> struct set_property_f <1> { // For single-valued properties template <typename Property> inline bool call_me(typename Property:: type const & value, std::shared_ptr<TIFF>& file) const { return (1 == TIFFSetField( file.get() , Property:: tag , value)); } }; template <> struct set_property_f <2> { // Specialisation for multi-valued properties. @todo: add one // of these for the three-parameter fields too. Actually we // will need further templation / specialisation for the // two-element fields which aren't a length and a data buffer // (e.g. http://www.awaresystems.be/imaging/tiff/tifftags/dotrange.html // ) template <typename Property> inline bool call_me(typename Property:: type const & values, std::shared_ptr<TIFF>& file) const { using length_t = mp11::mp_at_c<typename Property::arg_types, 0>; auto const length = static_cast<length_t>(values.size()); using pointer_t = mp11::mp_at_c<typename Property::arg_types, 1>; auto const pointer = static_cast<pointer_t>(&(values.front())); return (1 == TIFFSetField( file.get(), Property:: tag, length, pointer)); } }; template< typename Log > class tiff_device_base { public: using tiff_file_t = std::shared_ptr<TIFF>; tiff_device_base() {} tiff_device_base( TIFF* tiff_file ) : _tiff_file( tiff_file , TIFFClose ) {} template <typename Property> bool get_property( typename Property::type& value ) { return get_property_f<mp11::mp_size<typename Property::arg_types>::value>().template call_me<Property>(value, _tiff_file); } template <typename Property> inline bool set_property( const typename Property::type& value ) { // http://www.remotesensing.org/libtiff/man/TIFFSetField.3tiff.html return set_property_f<mp11::mp_size<typename Property::arg_types>::value>().template call_me<Property>(value, _tiff_file); } // TIFFIsByteSwapped returns a non-zero value if the image data was in a different // byte-order than the host machine. Zero is returned if the TIFF file and local // host byte-orders are the same. Note that TIFFReadTile(), TIFFReadStrip() and TIFFReadScanline() // functions already normally perform byte swapping to local host order if needed. bool are_bytes_swapped() { return ( TIFFIsByteSwapped( _tiff_file.get() )) ? true : false; } bool is_tiled() const { return ( TIFFIsTiled( _tiff_file.get() )) ? true : false; } unsigned int get_default_strip_size() { return TIFFDefaultStripSize( _tiff_file.get() , 0 ); } std::size_t get_scanline_size() { return TIFFScanlineSize( _tiff_file.get() ); } std::size_t get_tile_size() { return TIFFTileSize( _tiff_file.get() ); } int get_field_defaulted( uint16_t& red , uint16_t& green , uint16_t& blue ) { return TIFFGetFieldDefaulted( _tiff_file.get() , TIFFTAG_COLORMAP , &red , &green , &blue ); } template< typename Buffer > void read_scanline( Buffer& buffer , std::ptrdiff_t row , tsample_t plane ) { io_error_if( TIFFReadScanline( _tiff_file.get() , reinterpret_cast< tdata_t >( &buffer.front() ) , (uint32) row , plane ) == -1 , "Read error." ); } void read_scanline( byte_t buffer , std::ptrdiff_t row , tsample_t plane ) { io_error_if( TIFFReadScanline( _tiff_file.get() , reinterpret_cast< tdata_t >( buffer ) , (uint32) row , plane ) == -1 , "Read error." ); } template< typename Buffer > void read_tile( Buffer& buffer , std::ptrdiff_t x , std::ptrdiff_t y , std::ptrdiff_t z , tsample_t plane ) { if( TIFFReadTile( _tiff_file.get() , reinterpret_cast< tdata_t >( &buffer.front() ) , (uint32) x , (uint32) y , (uint32) z , plane ) == -1 ) { std::ostringstream oss; oss << "Read tile error (" << x << "," << y << "," << z << "," << plane << ")."; io_error(oss.str().c_str()); } } template< typename Buffer > void write_scaline( Buffer& buffer , uint32 row , tsample_t plane ) { io_error_if( TIFFWriteScanline( _tiff_file.get() , &buffer.front() , row , plane ) == -1 , "Write error" ); } void write_scaline( byte_t* buffer , uint32 row , tsample_t plane ) { io_error_if( TIFFWriteScanline( _tiff_file.get() , buffer , row , plane ) == -1 , "Write error" ); } template< typename Buffer > void write_tile( Buffer& buffer , uint32 x , uint32 y , uint32 z , tsample_t plane ) { if( TIFFWriteTile( _tiff_file.get() , &buffer.front() , x , y , z , plane ) == -1 ) { std::ostringstream oss; oss << "Write tile error (" << x << "," << y << "," << z << "," << plane << ")."; io_error(oss.str().c_str()); } } void set_directory( tdir_t directory ) { io_error_if( TIFFSetDirectory( _tiff_file.get() , directory ) != 1 , "Failing to set directory" ); } // return false if the given tile width or height is not TIFF compliant (multiple of 16) or larger than image size, true otherwise bool check_tile_size( tiff_tile_width::type& width , tiff_tile_length::type& height ) { bool result = true; uint32 tw = static_cast< uint32 >( width ); uint32 th = static_cast< uint32 >( height ); TIFFDefaultTileSize( _tiff_file.get() , &tw , &th ); if(width==0 \|\| width%16!=0) { width = tw; result = false; } if(height==0 \|\| height%16!=0) { height = th; result = false; } return result; } protected: tiff_file_t _tiff_file; Log _log; }; /! * file_stream_device specialization for tiff images, which are based on TIFF. / template<> class file_stream_device< tiff_tag > : public tiff_device_base< tiff_no_log > { public: struct read_tag {}; struct write_tag {}; file_stream_device( std::string const& file_name, read_tag ) { TIFF* tiff; io_error_if( ( tiff = TIFFOpen( file_name.c_str(), "r" )) == nullptr , "file_stream_device: failed to open file" ); _tiff_file = tiff_file_t( tiff, TIFFClose ); } file_stream_device( std::string const& file_name, write_tag ) { TIFF* tiff; io_error_if( ( tiff = TIFFOpen( file_name.c_str(), "w" )) == nullptr , "file_stream_device: failed to open file" ); _tiff_file = tiff_file_t( tiff, TIFFClose ); } file_stream_device( TIFF* tiff_file ) : tiff_device_base( tiff_file ) {} }; /! * ostream_device specialization for tiff images. / template<> class ostream_device< tiff_tag > : public tiff_device_base< tiff_no_log > { public: ostream_device( std::ostream & out ) : _out( out ) { TIFF tiff; io_error_if( ( tiff = TIFFStreamOpen( "" , &_out ) ) == nullptr , "ostream_device: failed to stream" ); _tiff_file = tiff_file_t( tiff, TIFFClose ); } private: ostream_device& operator=( const ostream_device& ) { return this; } private: std::ostream& _out; }; /! * * ostream_device specialization for tiff images. / template<> class istream_device< tiff_tag > : public tiff_device_base< tiff_no_log > { public: istream_device( std::istream & in ) : _in( in ) { TIFF tiff; io_error_if( ( tiff = TIFFStreamOpen( "" , &_in ) ) == nullptr , "istream_device: failed to stream" ); _tiff_file = tiff_file_t( tiff, TIFFClose ); } private: istream_device& operator=( const istream_device& ) { return this; } private: std::istream& _in; }; / template< typename T, typename D > struct is_adaptable_input_device< tiff_tag, T, D > : std::false_type {}; / template<typename FormatTag> struct is_adaptable_input_device<FormatTag, TIFF, void> : std::true_type { using device_type = file_stream_device<FormatTag>; }; template<typename FormatTag> struct is_adaptable_output_device<FormatTag, TIFF, void> : std::true_type { using device_type = file_stream_device<FormatTag>; }; template <typename Channel> struct sample_format : std::integral_constant<int, SAMPLEFORMAT_UINT> {}; template<> struct sample_format<uint8_t> : std::integral_constant<int, SAMPLEFORMAT_UINT> {}; template<> struct sample_format<uint16_t> : std::integral_constant<int, SAMPLEFORMAT_UINT> {}; template<> struct sample_format<uint32_t> : std::integral_constant<int, SAMPLEFORMAT_UINT> {}; template<> struct sample_format<float32_t> : std::integral_constant<int, SAMPLEFORMAT_IEEEFP> {}; template<> struct sample_format<double> : std::integral_constant<int, SAMPLEFORMAT_IEEEFP> {}; template<> struct sample_format<int8_t> : std::integral_constant<int, SAMPLEFORMAT_INT> {}; template<> struct sample_format<int16_t> : std::integral_constant<int, SAMPLEFORMAT_INT> {}; template<> struct sample_format<int32_t> : std::integral_constant<int, SAMPLEFORMAT_INT> {}; template <typename Channel> struct photometric_interpretation {}; template<> struct photometric_interpretation<gray_t> : std::integral_constant<int, PHOTOMETRIC_MINISBLACK> {}; template<> struct photometric_interpretation<rgb_t> : std::integral_constant<int, PHOTOMETRIC_RGB> {}; template<> struct photometric_interpretation<rgba_t> : std::integral_constant<int, PHOTOMETRIC_RGB> {}; template<> struct photometric_interpretation<cmyk_t> : std::integral_constant<int, PHOTOMETRIC_SEPARATED> {}; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[XN��m��m��!��extension/io/tiff/detail/read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_DETAIL_READER_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_READER_HPP #include <boost/gil/extension/io/tiff/detail/device.hpp> #include <boost/gil/extension/io/tiff/detail/is_allowed.hpp> #include <boost/gil/extension/io/tiff/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/assert.hpp> #include <algorithm> #include <string> #include <type_traits> #include <vector> // taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <tiff.h> #include <tiffio.h> #ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS } #endif namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif template < int K > struct plane_recursion { template< typename View , typename Device , typename ConversionPolicy > static void read_plane( const View& dst_view , reader< Device , tiff_tag , ConversionPolicy > p ) { using plane_t = typename kth_channel_view_type<K, View>::type; plane_t plane = kth_channel_view<K>( dst_view ); p->template read_data< detail::row_buffer_helper_view< plane_t > >( plane, K ); plane_recursion< K - 1 >::read_plane( dst_view, p ); } }; template <> struct plane_recursion< -1 > { template< typename View , typename Device , typename ConversionPolicy > static void read_plane( const View& /* dst_view / , reader< Device , tiff_tag , ConversionPolicy > /* p / ) {} }; /// /// Tiff Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , tiff_tag , ConversionPolicy > : public reader_base< tiff_tag , ConversionPolicy > , public reader_backend< Device , tiff_tag > { private: using this_t = reader<Device, tiff_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, tiff_tag>; reader( const Device& io_dev , const image_read_settings< tiff_tag >& settings ) : reader_base< tiff_tag , ConversionPolicy >() , backend_t( io_dev , settings ) {} reader( const Device& io_dev , const typename ConversionPolicy::color_converter_type& cc , const image_read_settings< tiff_tag >& settings ) : reader_base< tiff_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} // only works for homogeneous image types template< typename View > void apply( View& dst_view ) { if( this->_info._photometric_interpretation == PHOTOMETRIC_PALETTE ) { this->_scanline_length = this->_info._width num_channels< rgb16_view_t >::value * sizeof( channel_type<rgb16_view_t>::type ); // Steps: // 1. Read indices. It's an array of grayX_pixel_t. // 2. Read palette. It's an array of rgb16_pixel_t. // 3. ??? Create virtual image or transform the two arrays // into a rgb16_image_t object. The latter might // be a good first solution. switch( this->_info._bits_per_sample ) { case 1: { read_palette_image< gray1_image_t >( dst_view ); break; } case 2: { read_palette_image< gray2_image_t >( dst_view ); break; } case 4: { read_palette_image< gray4_image_t >( dst_view ); break; } case 8: { read_palette_image< gray8_image_t >( dst_view ); break; } case 16: { read_palette_image< gray16_image_t >( dst_view ); break; } default: { io_error( "Not supported palette " ); } } return; } else { this->_scanline_length = this->_io_dev.get_scanline_size(); // In case we only read the image the user's type and // the tiff type need to compatible. Which means: // color_spaces_are_compatible && channels_are_pairwise_compatible using is_read_only = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_only() ) , "Image types aren't compatible." ); if( this->_info._planar_configuration == PLANARCONFIG_SEPARATE ) { plane_recursion< num_channels< View >::value - 1 >::read_plane( dst_view , this ); } else if( this->_info._planar_configuration == PLANARCONFIG_CONTIG ) { read( dst_view , typename is_read_only::type() ); } else { io_error( "Wrong planar configuration setting." ); } } } private: template< typename View > void read( View v , std::true_type // is_read_only ) { read_data< detail::row_buffer_helper_view< View > >( v, 0 ); } template< typename View > void read( View v , std::false_type // is_read_only ) { // the read_data function needs to know what gil type the source image is // to have the default color converter function correctly switch( this->_info._photometric_interpretation ) { case PHOTOMETRIC_MINISWHITE: case PHOTOMETRIC_MINISBLACK: { switch( this->_info._bits_per_sample ) { case 1: { read_data< detail::row_buffer_helper_view< gray1_image_t::view_t > >( v, 0 ); break; } case 2: { read_data< detail::row_buffer_helper_view< gray2_image_t::view_t > >( v, 0 ); break; } case 4: { read_data< detail::row_buffer_helper_view< gray4_image_t::view_t > >( v, 0 ); break; } case 8: { read_data< detail::row_buffer_helper_view< gray8_view_t > >( v, 0 ); break; } case 16: { read_data< detail::row_buffer_helper_view< gray16_view_t > >( v, 0 ); break; } case 32: { read_data< detail::row_buffer_helper_view< gray32_view_t > >( v, 0 ); break; } default: { io_error( "Image type is not supported." ); } } break; } case PHOTOMETRIC_RGB: { switch( this->_info._samples_per_pixel ) { case 3: { switch( this->_info._bits_per_sample ) { case 8: { read_data< detail::row_buffer_helper_view< rgb8_view_t > >( v, 0 ); break; } case 16: { read_data< detail::row_buffer_helper_view< rgb16_view_t > >( v, 0 ); break; } case 32: { read_data< detail::row_buffer_helper_view< rgb32_view_t > >( v, 0 ); break; } default: { io_error( "Image type is not supported." ); } } break; } case 4: { switch( this->_info._bits_per_sample ) { case 8: { read_data< detail::row_buffer_helper_view< rgba8_view_t > >( v, 0 ); break; } case 16: { read_data< detail::row_buffer_helper_view< rgba16_view_t > >( v, 0 ); break; } case 32: { read_data< detail::row_buffer_helper_view< rgba32_view_t > >( v, 0 ); break; } default: { io_error( "Image type is not supported." ); } } break; } default: { io_error( "Image type is not supported." ); } } break; } case PHOTOMETRIC_SEPARATED: // CYMK { switch( this->_info._bits_per_sample ) { case 8: { read_data< detail::row_buffer_helper_view< cmyk8_view_t > >( v, 0 ); break; } case 16: { read_data< detail::row_buffer_helper_view< cmyk16_view_t > >( v, 0 ); break; } case 32: { read_data< detail::row_buffer_helper_view< cmyk32_view_t > >( v, 0 ); break; } default: { io_error( "Image type is not supported." ); } } break; } default: { io_error( "Image type is not supported." ); } } } template< typename PaletteImage , typename View > void read_palette_image( const View& dst_view ) { PaletteImage indices( this->_info._width - this->_settings._top_left.x , this->_info._height - this->_settings._top_left.y ); // read the palette first read_data< detail::row_buffer_helper_view < typename PaletteImage::view_t> >(view(indices), 0); read_palette_image(dst_view, view(indices), typename std::is_same<View, rgb16_view_t>::type()); } template< typename View , typename Indices_View > void read_palette_image( const View& dst_view , const Indices_View& indices_view , std::true_type // is View rgb16_view_t ) { tiff_color_map::red_t red = nullptr; tiff_color_map::green_t green = nullptr; tiff_color_map::blue_t blue = nullptr; this->_io_dev.get_field_defaulted( red, green, blue ); using channel_t = typename channel_traits<typename element_type<typename Indices_View::value_type>::type>::value_type; int num_colors = channel_traits< channel_t >::max_value(); rgb16_planar_view_t palette = planar_rgb_view( num_colors , 1 , red , green , blue , sizeof(uint16_t) * num_colors ); for( typename rgb16_view_t::y_coord_t y = 0; y < dst_view.height(); ++y ) { typename rgb16_view_t::x_iterator it = dst_view.row_begin( y ); typename rgb16_view_t::x_iterator end = dst_view.row_end( y ); typename Indices_View::x_iterator indices_it = indices_view.row_begin( y ); for( ; it != end; ++it, ++indices_it ) { uint16_t i = gil::at_c<0>( indices_it ); it = palette[i]; } } } template< typename View , typename Indices_View > inline void read_palette_image( const View& /* dst_view / , const Indices_View& / indices_view / , std::false_type // is View rgb16_view_t ) { io_error( "User supplied image type must be rgb16_image_t." ); } template< typename Buffer > void skip_over_rows( Buffer& buffer , int plane ) { if( this->_info._compression != COMPRESSION_NONE ) { // Skipping over rows is not possible for compressed images( no random access ). See man // page ( diagnostics section ) for more information. for( std::ptrdiff_t row = 0; row < this->_settings._top_left.y; ++row ) { this->_io_dev.read_scanline( buffer , row , static_cast< tsample_t >( plane )); } } } template< typename Buffer , typename View > void read_data( const View& dst_view , int / plane / ) { if( this->_io_dev.is_tiled() ) { read_tiled_data< Buffer >( dst_view, 0 ); } else { read_stripped_data< Buffer >( dst_view, 0 ); } } template< typename Buffer , typename View > void read_tiled_data( const View& dst_view , int plane ) { if( dst_view.width() != this->_info._width \|\| dst_view.height() != this->_info._height ) { // read a subimage read_tiled_data_subimage< Buffer >( dst_view, plane ); } else { // read full image read_tiled_data_full< Buffer >( dst_view, plane ); } } template< typename Buffer , typename View > void read_tiled_data_subimage( const View& dst_view , int plane ) { ///@todo: why is /// using row_buffer_helper_t = Buffer; /// not working? I get compiler error with MSVC10. /// read_stripped_data IS working. using row_buffer_helper_t = detail::row_buffer_helper_view<View>; using it_t = typename row_buffer_helper_t::iterator_t; tiff_image_width::type image_width = this->_info._width; tiff_image_height::type image_height = this->_info._height; tiff_tile_width::type tile_width = this->_info._tile_width; tiff_tile_length::type tile_height = this->_info._tile_length; std::ptrdiff_t subimage_x = this->_settings._top_left.x; std::ptrdiff_t subimage_y = this->_settings._top_left.y; std::ptrdiff_t subimage_width = this->_settings._dim.x; std::ptrdiff_t subimage_height = this->_settings._dim.y; row_buffer_helper_t row_buffer_helper(this->_io_dev.get_tile_size(), true ); for( unsigned int y = 0; y < image_height; y += tile_height ) { for( unsigned int x = 0; x < image_width; x += tile_width ) { uint32_t current_tile_width = ( x + tile_width < image_width ) ? tile_width : image_width - x; uint32_t current_tile_length = ( y + tile_height < image_height ) ? tile_height : image_height - y; this->_io_dev.read_tile( row_buffer_helper.buffer() , x , y , 0 , static_cast< tsample_t >( plane ) ); // these are all whole image coordinates point_t tile_top_left ( x, y ); point_t tile_lower_right( x + current_tile_width - 1, y + current_tile_length - 1 ); point_t view_top_left ( subimage_x, subimage_y ); point_t view_lower_right( subimage_x + subimage_width - 1 , subimage_y + subimage_height - 1 ); if( tile_top_left.x > view_lower_right.x \|\| tile_top_left.y > view_lower_right.y \|\| tile_lower_right.x < view_top_left.x \|\| tile_lower_right.y < view_top_left.y ) { // current tile and dst_view do not overlap continue; } else { // dst_view is overlapping the current tile // next is to define the portion in the tile that needs to be copied // get the whole image coordinates std::ptrdiff_t img_x0 = ( tile_top_left.x >= view_top_left.x ) ? tile_top_left.x : view_top_left.x; std::ptrdiff_t img_y0 = ( tile_top_left.y >= view_top_left.y ) ? tile_top_left.y : view_top_left.y; std::ptrdiff_t img_x1 = ( tile_lower_right.x <= view_lower_right.x ) ? tile_lower_right.x : view_lower_right.x; std::ptrdiff_t img_y1 = ( tile_lower_right.y <= view_lower_right.y ) ? tile_lower_right.y : view_lower_right.y; // convert to tile coordinates std::ptrdiff_t tile_x0 = img_x0 - x; std::ptrdiff_t tile_y0 = img_y0 - y; std::ptrdiff_t tile_x1 = img_x1 - x; std::ptrdiff_t tile_y1 = img_y1 - y; BOOST_ASSERT(tile_x0 >= 0 && tile_y0 >= 0 && tile_x1 >= 0 && tile_y1 >= 0); BOOST_ASSERT(tile_x0 <= img_x1 && tile_y0 <= img_y1); BOOST_ASSERT(tile_x0 < tile_width && tile_y0 < tile_height && tile_x1 < tile_width && tile_y1 < tile_height); std::ptrdiff_t tile_subimage_view_width = tile_x1 - tile_x0 + 1; std::ptrdiff_t tile_subimage_view_height = tile_y1 - tile_y0 + 1; // convert to dst_view coordinates std::ptrdiff_t dst_x0 = img_x0 - subimage_x; std::ptrdiff_t dst_y0 = img_y0 - subimage_y; BOOST_ASSERT(dst_x0 >= 0 && dst_y0 >= 0); View dst_subimage_view = subimage_view( dst_view , (int) dst_x0 , (int) dst_y0 , (int) tile_subimage_view_width , (int) tile_subimage_view_height ); // the row_buffer is a 1D array which represents a 2D image. We cannot // use interleaved_view here, since row_buffer could be bit_aligned. // Interleaved_view's fourth parameter "rowsize_in_bytes" doesn't work // for bit_aligned pixels. for( std::ptrdiff_t dst_row = 0; dst_row < dst_subimage_view.height(); ++dst_row ) { std::ptrdiff_t tile_row = dst_row + tile_y0; // jump to the beginning of the current tile row it_t begin = row_buffer_helper.begin() + tile_row tile_width; begin += tile_x0; it_t end = begin + dst_subimage_view.width(); this->_cc_policy.read( begin , end , dst_subimage_view.row_begin( dst_row ) ); } //for } } // for } // for } template< typename Buffer , typename View > void read_tiled_data_full( const View& dst_view , int plane ) { ///@todo: why is /// using row_buffer_helper_t = Buffer; /// not working? I get compiler error with MSVC10. /// read_stripped_data IS working. using row_buffer_helper_t = detail::row_buffer_helper_view<View>; using it_t = typename row_buffer_helper_t::iterator_t; tiff_image_width::type image_width = this->_info._width; tiff_image_height::type image_height = this->_info._height; tiff_tile_width::type tile_width = this->_info._tile_width; tiff_tile_length::type tile_height = this->_info._tile_length; row_buffer_helper_t row_buffer_helper(this->_io_dev.get_tile_size(), true ); for( unsigned int y = 0; y < image_height; y += tile_height ) { for( unsigned int x = 0; x < image_width; x += tile_width ) { uint32_t current_tile_width = ( x + tile_width < image_width ) ? tile_width : image_width - x; uint32_t current_tile_length = ( y + tile_height < image_height ) ? tile_height : image_height - y; this->_io_dev.read_tile( row_buffer_helper.buffer() , x , y , 0 , static_cast< tsample_t >( plane ) ); View dst_subimage_view = subimage_view( dst_view , x , y , current_tile_width , current_tile_length ); // the row_buffer is a 1D array which represents a 2D image. We cannot // use interleaved_view here, since row_buffer could be bit_aligned. // Interleaved_view's fourth parameter "rowsize_in_bytes" doesn't work // for bit_aligned pixels. for( int row = 0; row < dst_subimage_view.height(); ++row ) { it_t begin = row_buffer_helper.begin() + row * tile_width; it_t end = begin + dst_subimage_view.width(); this->_cc_policy.read( begin , end , dst_subimage_view.row_begin( row ) ); } //for } // for } // for } template< typename Buffer , typename View > void read_stripped_data( const View& dst_view , int plane ) { using is_view_bit_aligned_t = typename is_bit_aligned<typename View::value_type>::type; //using row_buffer_helper_t =detail::row_buffer_helper_view<View>; using row_buffer_helper_t = Buffer; using it_t = typename row_buffer_helper_t::iterator_t; std::size_t size_to_allocate = buffer_size< typename View::value_type >( dst_view.width() , is_view_bit_aligned_t() ); row_buffer_helper_t row_buffer_helper( size_to_allocate, true ); it_t begin = row_buffer_helper.begin(); it_t first = begin + this->_settings._top_left.x; it_t last = first + this->_settings._dim.x; // one after last element // I don't think tiff allows for random access of row, that's why we need // to read and discard rows when reading subimages. skip_over_rows( row_buffer_helper.buffer() , plane ); std::ptrdiff_t row = this->_settings._top_left.y; std::ptrdiff_t row_end = row + this->_settings._dim.y; std::ptrdiff_t dst_row = 0; for( ; row < row_end ; ++row, ++dst_row ) { this->_io_dev.read_scanline( row_buffer_helper.buffer() , row , static_cast< tsample_t >( plane ) ); this->_cc_policy.read( first , last , dst_view.row_begin( dst_row )); } } template< typename Pixel > std::size_t buffer_size( std::size_t width , std::false_type // is_bit_aligned ) { std::size_t scanline_size_in_bytes = this->_io_dev.get_scanline_size(); std::size_t element_size = sizeof( Pixel ); std::size_t ret = std::max( width , (( scanline_size_in_bytes + element_size - 1 ) / element_size ) ); return ret; } template< typename Pixel > std::size_t buffer_size( std::size_t /* width / , std::true_type // is_bit_aligned ) { return this->_io_dev.get_scanline_size(); } private: template < int K > friend struct plane_recursion; }; namespace detail { struct tiff_type_format_checker { tiff_type_format_checker( const image_read_info< tiff_tag >& info ) : _info( info ) {} template< typename Image > bool apply() { using view_t = typename Image::view_t; return is_allowed< view_t >( _info , std::true_type() ); } private: tiff_type_format_checker& operator=( const tiff_type_format_checker& ) { return this; } private: const image_read_info< tiff_tag > _info; }; struct tiff_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , tiff_tag > {}; }; } // namespace detail /// /// Tiff Dynamic Image Reader /// template< typename Device > class dynamic_image_reader< Device , tiff_tag > : public reader< Device , tiff_tag , detail::read_and_no_convert > { using parent_t = reader<Device, tiff_tag, detail::read_and_no_convert>; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< tiff_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::tiff_type_format_checker format_checker( this->_info ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::tiff_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[��/��+��extension/io/tiff/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_TIFF_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/io/tiff/detail/device.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// TIFF Writer Backend /// template< typename Device > struct writer_backend< Device , tiff_tag > { public: using format_tag_t = tiff_tag; public: writer_backend( const Device& io_dev , const image_write_info< tiff_tag >& info ) : _io_dev( io_dev ) , _info( info ) {} protected: template< typename View > void write_header( const View& view ) { using pixel_t = typename View::value_type; // get the type of the first channel (heterogeneous pixels might be broken for now!) using channel_t = typename channel_traits<typename element_type<pixel_t>::type>::value_type; using color_space_t = typename color_space_type<View>::type; if(! this->_info._photometric_interpretation_user_defined ) { // write photometric interpretion - Warning: This value is rather // subjective. The user should better set this value itself. There // is no way to decide if a image is PHOTOMETRIC_MINISWHITE or // PHOTOMETRIC_MINISBLACK. If the user has not manually set it, then // this writer will assume PHOTOMETRIC_MINISBLACK for gray_t images, // PHOTOMETRIC_RGB for rgb_t images, and PHOTOMETRIC_SEPARATED (as // is conventional) for cmyk_t images. this->_info._photometric_interpretation = detail::photometric_interpretation< color_space_t >::value; } // write dimensions tiff_image_width::type width = (tiff_image_width::type) view.width(); tiff_image_height::type height = (tiff_image_height::type) view.height(); this->_io_dev.template set_property< tiff_image_width >( width ); this->_io_dev.template set_property< tiff_image_height >( height ); // write planar configuration this->_io_dev.template set_property<tiff_planar_configuration>( this->_info._planar_configuration ); // write samples per pixel tiff_samples_per_pixel::type samples_per_pixel = num_channels< pixel_t >::value; this->_io_dev.template set_property<tiff_samples_per_pixel>( samples_per_pixel ); if /constexpr/ (mp11::mp_contains<color_space_t, alpha_t>::value) { std:: vector <uint16_t> extra_samples {EXTRASAMPLE_ASSOCALPHA}; this->_io_dev.template set_property<tiff_extra_samples>( extra_samples ); } // write bits per sample // @todo: Settings this value usually requires to write for each sample the bit // value seperately in case they are different, like rgb556. tiff_bits_per_sample::type bits_per_sample = detail::unsigned_integral_num_bits< channel_t >::value; this->_io_dev.template set_property<tiff_bits_per_sample>( bits_per_sample ); // write sample format tiff_sample_format::type sampl_format = detail::sample_format< channel_t >::value; this->_io_dev.template set_property<tiff_sample_format>( sampl_format ); // write photometric format this->_io_dev.template set_property<tiff_photometric_interpretation>( this->_info._photometric_interpretation ); // write compression this->_io_dev.template set_property<tiff_compression>( this->_info._compression ); // write orientation this->_io_dev.template set_property<tiff_orientation>( this->_info._orientation ); // write rows per strip this->_io_dev.template set_property<tiff_rows_per_strip>( this->_io_dev.get_default_strip_size() ); // write x, y resolution and units this->_io_dev.template set_property<tiff_resolution_unit>( this->_info._resolution_unit ); this->_io_dev.template set_property<tiff_x_resolution>( this->_info._x_resolution ); this->_io_dev.template set_property<tiff_y_resolution>( this->_info._y_resolution ); /// Optional and / or non-baseline tags below here // write ICC colour profile, if it's there // http://www.color.org/icc_specs2.xalter if ( 0 != this->_info._icc_profile.size()) this->_io_dev.template set_property<tiff_icc_profile>( this->_info._icc_profile ); } public: Device _io_dev; image_write_info< tiff_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[e$�Af��f��,��extension/io/tiff/detail/supported_types.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost{ namespace gil { namespace detail { // Read support // TIFF virtually supports everything struct tiff_read_support : read_support_true {}; // Write support struct tiff_write_support : write_support_true {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, tiff_tag> : std::integral_constant<bool, detail::tiff_read_support::is_supported> {}; template<typename Pixel> struct is_write_supported<Pixel, tiff_tag> : std::integral_constant<bool, detail::tiff_write_support::is_supported> {}; }} // namespace boost::gil #endif PK��p�[jK`�z��z��'��extension/io/tiff/detail/is_allowed.hppnu��[��// // Copyright 2008 Christian Henning, Lubomir Bourdev // // 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_EXTENSION_IO_TIFF_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { using channel_sizes_t = std::vector<tiff_bits_per_sample::type>; template <typename View, typename Channel, typename Enable = void> struct Format_Type {}; // is_bit_aligned< View > template <typename View, typename Channel> struct Format_Type < View, Channel, typename std::enable_if < is_bit_aligned < typename get_pixel_type<View>::type >::value >::type > { static const int value = SAMPLEFORMAT_UINT; }; // is_not_bit_aligned< View > && is_unsigned< Channel > template <typename View, typename Channel> struct Format_Type < View, Channel, typename std::enable_if < mp11::mp_and < mp11::mp_not < typename is_bit_aligned<typename get_pixel_type<View>::type>::type >, std::is_unsigned<Channel> >::value >::type > { static const int value = SAMPLEFORMAT_UINT; }; // is_not_bit_aligned< View > && is_signed< Channel > template <typename View, typename Channel> struct Format_Type < View, Channel, typename std::enable_if < mp11::mp_and < mp11::mp_not < typename is_bit_aligned<typename get_pixel_type<View>::type>::type >, std::is_signed<Channel> >::value >::type > { static const int value = SAMPLEFORMAT_INT; }; // is_not_bit_aligned< View > && is_floating_point< Channel > template <typename View, typename Channel> struct Format_Type < View, Channel, typename std::enable_if < mp11::mp_and < mp11::mp_not < typename is_bit_aligned<typename get_pixel_type<View>::type>::type >, is_floating_point<Channel> >::value >::type > { static const int value = SAMPLEFORMAT_IEEEFP; }; //template< typename Channel > //int format_value( std::true_type ) // is_bit_aligned //{ // return SAMPLEFORMAT_UINT; //} // //template< typename Channel > //int format_value( std::false_type ) // is_bit_aligned //{ // if( is_unsigned< Channel >::value ) // { // return SAMPLEFORMAT_UINT; // } // // if( is_signed< Channel >::value ) // { // return SAMPLEFORMAT_INT; // } // // else if( is_floating_point< Channel >::value ) // { // return SAMPLEFORMAT_IEEEFP; // } // // io_error( "Unkown channel format." ); //} // The following two functions look the same but are different since one is using // a pixel_t as template parameter whereas the other is using reference_t. template< typename View > bool compare_channel_sizes( const channel_sizes_t& channel_sizes // in bits , std::false_type // is_bit_aligned , std::true_type // is_homogeneous ) { using pixel_t = typename View::value_type; using channel_t = typename channel_traits<typename element_type<pixel_t>::type>::value_type; unsigned int s = detail::unsigned_integral_num_bits< channel_t >::value; return ( s == channel_sizes[0] ); } template< typename View > bool compare_channel_sizes( const channel_sizes_t& channel_sizes // in bits , std::true_type // is_bit_aligned , std::true_type // is_homogeneous ) { using ref_t = typename View::reference; using channel_t = typename channel_traits<typename element_type<ref_t>::type>::value_type; unsigned int s = detail::unsigned_integral_num_bits< channel_t >::value; return ( s == channel_sizes[0] ); } struct compare_channel_sizes_fn { compare_channel_sizes_fn( uint16_t* a ) : _a( a ) , _b( true ) {} template< typename ChannelSize > void operator()( ChannelSize x) { if( x != _a++ ) { _b = false; } } uint16_t _a; bool _b; }; template< typename T > struct channel_sizes_type {}; template< typename B, typename C, typename L, bool M > struct channel_sizes_type< bit_aligned_pixel_reference< B, C, L, M > > { using type = C; }; template< typename B, typename C, typename L, bool M > struct channel_sizes_type< const bit_aligned_pixel_reference< B, C, L, M > > { using type = C; }; template< typename View > bool compare_channel_sizes( channel_sizes_t& channel_sizes // in bits , std::true_type // is_bit_aligned , std::false_type // is_homogeneous ) { // loop through all channels and compare using ref_t = typename View::reference; using cs_t = typename channel_sizes_type<ref_t>::type; compare_channel_sizes_fn fn( &channel_sizes.front() ); mp11::mp_for_each<cs_t>(fn); return fn._b; } template< typename View > bool is_allowed( const image_read_info< tiff_tag >& info , std::true_type // is read_and_no_convert ) { channel_sizes_t channel_sizes( info._samples_per_pixel , info._bits_per_sample ); using pixel_t = typename get_pixel_type<View>::type; using channel_t = typename channel_traits<typename element_type<pixel_t>::type>::value_type; using num_channel_t = typename num_channels<pixel_t>::value_type; const num_channel_t dst_samples_per_pixel = num_channels< pixel_t >::value; //const num_channel_t dst_sample_format = format_value< channel_t >( typename is_bit_aligned< pixel_t >::type() ); const num_channel_t dst_sample_format = Format_Type<View, channel_t>::value; return ( dst_samples_per_pixel == info._samples_per_pixel && compare_channel_sizes< View >( channel_sizes , typename is_bit_aligned< pixel_t >::type() , typename is_homogeneous< pixel_t >::type() ) && dst_sample_format == info._sample_format ); } template< typename View > bool is_allowed( const image_read_info< tiff_tag >& /* info / , std::false_type // is read_and_no_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[��]��]��extension/io/tiff/read.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_TIFF_READ_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_READ_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_READ_ENABLED // TODO: Document, explain, review #include <boost/gil/extension/io/tiff/tags.hpp> #include <boost/gil/extension/io/tiff/detail/read.hpp> #include <boost/gil/extension/io/tiff/detail/scanline_read.hpp> #include <boost/gil/extension/io/tiff/detail/supported_types.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[��M��extension/io/tiff/old.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_TIFF_OLD_HPP #define BOOST_GIL_EXTENSION_IO_TIFF_OLD_HPP #include <boost/gil/extension/io/tiff.hpp> namespace boost { namespace gil { /// \ingroup TIFF_IO /// \brief Returns the width and height of the TIFF file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid TIFF file template<typename String> inline point_t tiff_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, tiff_tag>::type; backend_t backend = read_image_info(filename, tiff_tag()); return { backend._info._width, backend._info._height }; } /// \ingroup TIFF_IO /// \brief Loads the image specified by the given tiff image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the TIFF library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void tiff_read_view( const String& filename , const View& view ) { read_view( filename , view , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the TIFF library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void tiff_read_image( const String& filename , Image& img ) { read_image( filename , img , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void tiff_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Loads and color-converts the image specified by the given tiff image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid TIFF file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void tiff_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid TIFF file template< typename String , typename Image , typename CC > inline void tiff_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Allocates a new image whose dimensions are determined by the given tiff image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid TIFF file template< typename String , typename Image > inline void tiff_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , tiff_tag() ); } /// \ingroup TIFF_IO /// \brief Saves the view to a tiff file specified by the given tiff image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the TIFF library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void tiff_write_view( const String& filename , const View& view ) { write_view( filename , view , tiff_tag() ); } } // namespace gil } // namespace boost #endif PK��p�[��oL��L��extension/io/raw.hppnu��[��// // Copyright 2013 Christian Henning // // 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_EXTENSION_IO_RAW_HPP #define BOOST_GIL_EXTENSION_IO_RAW_HPP #include <boost/gil/extension/io/raw/read.hpp> #endif PK��p�[a�hP��extension/io/jpeg/tags.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_JPEG_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_TAGS_HPP // taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp #ifndef BOOST_GIL_EXTENSION_IO_JPEG_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #else // DONT_USE_EXTERN_C introduced in v7 of the IJG library. // By default the v7 IJG headers check for __cplusplus being defined and // wrap the content in an 'extern "C"' block if it's present. // When DONT_USE_EXTERN_C is defined, this wrapping is not performed. #ifndef DONT_USE_EXTERN_C #define DONT_USE_EXTERN_C 1 #endif #endif #include <cstdio> // jpeglib doesn't know about FILE #include <jerror.h> #include <jpeglib.h> #ifndef BOOST_GIL_EXTENSION_IO_JPEG_C_LIB_COMPILED_AS_CPLUSPLUS } #endif #include <boost/gil/io/base.hpp> namespace boost { namespace gil { /// Defines jpeg tag. struct jpeg_tag : format_tag {}; /// see http://en.wikipedia.org/wiki/JPEG for reference /// Defines type for image width property. struct jpeg_image_width : property_base< JDIMENSION > {}; /// Defines type for image height property. struct jpeg_image_height : property_base< JDIMENSION > {}; /// Defines type for number of components property. struct jpeg_num_components : property_base< int > {}; /// Defines type for color space property. struct jpeg_color_space : property_base< J_COLOR_SPACE > {}; /// Defines type for jpeg quality property. struct jpeg_quality : property_base< int > { static const type default_value = 100; }; /// Defines type for data precision property. struct jpeg_data_precision : property_base< int > {}; /// JFIF code for pixel size units struct jpeg_density_unit : property_base< UINT8 > { static const type default_value = 0; }; /// pixel density struct jpeg_pixel_density : property_base< UINT16 > { static const type default_value = 0; }; /// Defines type for dct ( discrete cosine transformation ) method property. struct jpeg_dct_method : property_base< J_DCT_METHOD > { static const type slow = JDCT_ISLOW; static const type fast = JDCT_IFAST; static const type floating_pt = JDCT_FLOAT; static const type fastest = JDCT_FASTEST; static const type default_value = slow; }; /// Read information for jpeg images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< jpeg_tag > { image_read_info() : _width ( 0 ) , _height( 0 ) , _num_components( 0 ) , _color_space( J_COLOR_SPACE( 0 )) , _data_precision( 0 ) , _density_unit ( 0 ) , _x_density ( 0 ) , _y_density ( 0 ) , _pixel_width_mm ( 0.0 ) , _pixel_height_mm( 0.0 ) {} /// The image width. jpeg_image_width::type _width; /// The image height. jpeg_image_height::type _height; /// The number of channels. jpeg_num_components::type _num_components; /// The color space. jpeg_color_space::type _color_space; /// The width of channel. /// I believe this number is always 8 in the case libjpeg is built with 8. /// see: http://www.asmail.be/msg0055405033.html jpeg_data_precision::type _data_precision; /// Density conversion unit. jpeg_density_unit::type _density_unit; jpeg_pixel_density::type _x_density; jpeg_pixel_density::type _y_density; /// Real-world dimensions double _pixel_width_mm; double _pixel_height_mm; }; /// Read settings for jpeg images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< jpeg_tag > : public image_read_settings_base { /// Default constructor image_read_settings<jpeg_tag>() : image_read_settings_base() , _dct_method( jpeg_dct_method::default_value ) {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. /// \param dct_method Specifies dct method. image_read_settings( const point_t& top_left , const point_t& dim , jpeg_dct_method::type dct_method = jpeg_dct_method::default_value ) : image_read_settings_base( top_left , dim ) , _dct_method( dct_method ) {} /// The dct ( discrete cosine transformation ) method. jpeg_dct_method::type _dct_method; }; /// Write information for jpeg images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< jpeg_tag > { /// Constructor /// \param quality Defines the jpeg quality. /// \param dct_method Defines the DCT method. /// \param density_unit Defines the density unit. /// \param x_density Defines the x density. /// \param y_density Defines the y density. image_write_info( const jpeg_quality::type quality = jpeg_quality::default_value , const jpeg_dct_method::type dct_method = jpeg_dct_method::default_value , const jpeg_density_unit::type density_unit = jpeg_density_unit::default_value , const jpeg_pixel_density::type x_density = jpeg_pixel_density::default_value , const jpeg_pixel_density::type y_density = jpeg_pixel_density::default_value ) : _quality ( quality ) , _dct_method( dct_method ) , _density_unit( density_unit ) , _x_density ( x_density ) , _y_density ( y_density ) {} /// The jpeg quality. jpeg_quality::type _quality; /// The dct ( discrete cosine transformation ) method. jpeg_dct_method::type _dct_method; /// Density conversion unit. jpeg_density_unit::type _density_unit; /// Pixel density dimensions. jpeg_pixel_density::type _x_density; jpeg_pixel_density::type _y_density; /// Sets the pixel dimensions. void set_pixel_dimensions( int image_width // in pixels , int image_height // in pixels , double pixel_width // in mm , double pixel_height // in mm ) { _density_unit = 2; // dots per cm _x_density = round( image_width / ( pixel_width / 10 )); _y_density = round( image_height / ( pixel_height / 10 )); } private: UINT16 round( double d ) { return static_cast< UINT16 >( d + 0.5 ); } }; } // namespace gil } // namespace boost #endif PK��p�[��`��`��extension/io/jpeg/write.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_JPEG_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_WRITE_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/supported_types.hpp> #include <boost/gil/extension/io/jpeg/detail/write.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[�zނt$��t$��+��extension/io/jpeg/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_JPEG_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/base.hpp> #include <csetjmp> #include <memory> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif namespace detail { /// /// Wrapper for libjpeg's decompress object. Implements value semantics. /// struct jpeg_decompress_wrapper { protected: using jpeg_decompress_ptr_t = std::shared_ptr<jpeg_decompress_struct> ; protected: /// /// Default Constructor /// jpeg_decompress_wrapper() : _jpeg_decompress_ptr( new jpeg_decompress_struct() , jpeg_decompress_deleter ) {} jpeg_decompress_struct get() { return _jpeg_decompress_ptr.get(); } const jpeg_decompress_struct* get() const { return _jpeg_decompress_ptr.get(); } private: static void jpeg_decompress_deleter( jpeg_decompress_struct* jpeg_decompress_ptr ) { if( jpeg_decompress_ptr ) { jpeg_destroy_decompress( jpeg_decompress_ptr ); delete jpeg_decompress_ptr; jpeg_decompress_ptr = nullptr; } } private: jpeg_decompress_ptr_t _jpeg_decompress_ptr; }; } // namespace detail /// /// JPEG Backend /// template< typename Device > struct reader_backend< Device , jpeg_tag > : public jpeg_io_base , public detail::jpeg_decompress_wrapper { public: using format_tag_t = jpeg_tag; public: // // Constructor // reader_backend( const Device& io_dev , const image_read_settings< jpeg_tag >& settings ) : _io_dev( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) { get()->err = jpeg_std_error( &_jerr ); get()->client_data = this; // Error exit handler: does not return to caller. _jerr.error_exit = &reader_backend::error_exit; if( setjmp( _mark )) { raise_error(); } _src._jsrc.bytes_in_buffer = 0; _src._jsrc.next_input_byte = buffer_; _src._jsrc.init_source = reinterpret_cast< void() ( j_decompress_ptr )>( &reader_backend< Device, jpeg_tag >::init_device ); _src._jsrc.fill_input_buffer = reinterpret_cast< boolean()( j_decompress_ptr )>( &reader_backend< Device, jpeg_tag >::fill_buffer ); _src._jsrc.skip_input_data = reinterpret_cast< void() ( j_decompress_ptr , long num_bytes ) >( &reader_backend< Device, jpeg_tag >::skip_input_data ); _src._jsrc.term_source = reinterpret_cast< void() ( j_decompress_ptr ) >( &reader_backend< Device, jpeg_tag >::close_device ); _src._jsrc.resync_to_restart = jpeg_resync_to_restart; _src._this = this; jpeg_create_decompress( get() ); get()->src = &_src._jsrc; jpeg_read_header( get() , TRUE ); io_error_if( get()->data_precision != 8 , "Image file is not supported." ); // read_header(); // if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } /// Read image header. void read_header() { _info._width = get()->image_width; _info._height = get()->image_height; _info._num_components = get()->num_components; _info._color_space = get()->jpeg_color_space; _info._data_precision = get()->data_precision; _info._density_unit = get()->density_unit; _info._x_density = get()->X_density; _info._y_density = get()->Y_density; // obtain real world dimensions // taken from https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/read.cpp#cl-62 jpeg_calc_output_dimensions( get() ); double units_conversion = 0; if (get()->density_unit == 1) // dots per inch { units_conversion = 25.4; // millimeters in an inch } else if (get()->density_unit == 2) // dots per cm { units_conversion = 10; // millimeters in a centimeter } _info._pixel_width_mm = get()->X_density ? (get()->output_width / double(get()->X_density)) * units_conversion : 0; _info._pixel_height_mm = get()->Y_density ? (get()->output_height / double(get()->Y_density)) * units_conversion : 0; } /// Return image read settings. const image_read_settings< jpeg_tag >& get_settings() { return _settings; } /// Return image header info. const image_read_info< jpeg_tag >& get_info() { return _info; } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( (jpeg_image_width::type) img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( (jpeg_image_height::type) img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } protected: // Taken from jerror.c /* * Error exit handler: must not return to caller. * * Applications may override this if they want to get control back after * an error. Typically one would longjmp somewhere instead of exiting. * The setjmp buffer can be made a private field within an expanded error * handler object. Note that the info needed to generate an error message * is stored in the error object, so you can generate the message now or * later, at your convenience. * You should make sure that the JPEG object is cleaned up (with jpeg_abort * or jpeg_destroy) at some point. / static void error_exit( j_common_ptr cinfo ) { reader_backend< Device, jpeg_tag > mgr = reinterpret_cast< reader_backend< Device, jpeg_tag >* >( cinfo->client_data ); longjmp( mgr->_mark, 1 ); } void raise_error() { // we clean up in the destructor io_error( "jpeg is invalid." ); } private: // See jdatasrc.c for default implementation for the following static member functions. static void init_device( jpeg_decompress_struct* cinfo ) { gil_jpeg_source_mgr* src = reinterpret_cast< gil_jpeg_source_mgr* >( cinfo->src ); src->_jsrc.bytes_in_buffer = 0; src->_jsrc.next_input_byte = src->_this->buffer_; } static boolean fill_buffer( jpeg_decompress_struct* cinfo ) { gil_jpeg_source_mgr* src = reinterpret_cast< gil_jpeg_source_mgr* >( cinfo->src ); size_t count = src->_this->_io_dev.read(src->_this->buffer_, sizeof(src->_this->buffer_) ); if( count <= 0 ) { // libjpeg does that: adding an EOF marker src->_this->buffer_[0] = (JOCTET) 0xFF; src->_this->buffer_[1] = (JOCTET) JPEG_EOI; count = 2; } src->_jsrc.next_input_byte = src->_this->buffer_; src->_jsrc.bytes_in_buffer = count; return TRUE; } static void skip_input_data( jpeg_decompress_struct * cinfo, long num_bytes ) { gil_jpeg_source_mgr* src = reinterpret_cast< gil_jpeg_source_mgr* >( cinfo->src ); if( num_bytes > 0 ) { while( num_bytes > long( src->_jsrc.bytes_in_buffer )) { num_bytes -= (long) src->_jsrc.bytes_in_buffer; fill_buffer( cinfo ); } src->_jsrc.next_input_byte += num_bytes; src->_jsrc.bytes_in_buffer -= num_bytes; } } static void close_device( jpeg_decompress_struct* ) {} public: Device _io_dev; image_read_settings< jpeg_tag > _settings; image_read_info< jpeg_tag > _info; std::size_t _scanline_length; struct gil_jpeg_source_mgr { jpeg_source_mgr _jsrc; reader_backend* _this; }; gil_jpeg_source_mgr _src; // libjpeg default is 4096 - see jdatasrc.c JOCTET buffer_[4096]; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[)4J��!��extension/io/jpeg/detail/base.hppnu��[��// // Copyright 2010 Christian Henning // // 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_EXTENSION_IO_JPEG_DETAIL_BASE_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_BASE_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <csetjmp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4324) //structure was padded due to __declspec(align()) #endif class jpeg_io_base { protected: jpeg_error_mgr _jerr; jmp_buf _mark; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[~c��0��0��"��extension/io/jpeg/detail/write.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_JPEG_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_WRITE_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/supported_types.hpp> #include <boost/gil/extension/io/jpeg/detail/writer_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif namespace detail { struct jpeg_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , jpeg_tag > {}; }; } // detail /// /// JPEG Writer /// template< typename Device > class writer< Device , jpeg_tag > : public writer_backend< Device , jpeg_tag > { public: using backend_t = writer_backend<Device, jpeg_tag>; public: writer( const Device& io_dev , const image_write_info< jpeg_tag >& info ) : backend_t( io_dev , info ) {} template<typename View> void apply( const View& view ) { write_rows( view ); } private: template<typename View> void write_rows( const View& view ) { std::vector< pixel< typename channel_type< View >::type , layout<typename color_space_type< View >::type > > > row_buffer( view.width() ); // In case of an error we'll jump back to here and fire an exception. // @todo Is the buffer above cleaned up when the exception is thrown? // The strategy right now is to allocate necessary memory before // the setjmp. if( setjmp( this->_mark )) { this->raise_error(); } using channel_t = typename channel_type<typename View::value_type>::type; this->get()->image_width = JDIMENSION( view.width() ); this->get()->image_height = JDIMENSION( view.height() ); this->get()->input_components = num_channels<View>::value; this->get()->in_color_space = detail::jpeg_write_support< channel_t , typename color_space_type< View >::type >::_color_space; jpeg_set_defaults( this->get() ); jpeg_set_quality( this->get() , this->_info._quality , TRUE ); // Needs to be done after jpeg_set_defaults() since it's overridding this value back to slow. this->get()->dct_method = this->_info._dct_method; // set the pixel dimensions this->get()->density_unit = this->_info._density_unit; this->get()->X_density = this->_info._x_density; this->get()->Y_density = this->_info._y_density; // done reading header information jpeg_start_compress( this->get() , TRUE ); JSAMPLE* row_addr = reinterpret_cast< JSAMPLE* >( &row_buffer[0] ); for( int y =0; y != view.height(); ++ y ) { std::copy( view.row_begin( y ) , view.row_end ( y ) , row_buffer.begin() ); jpeg_write_scanlines( this->get() , &row_addr , 1 ); } jpeg_finish_compress ( this->get() ); } }; /// /// JPEG Dyamic Image Writer /// template< typename Device > class dynamic_image_writer< Device , jpeg_tag > : public writer< Device , jpeg_tag > { using parent_t = writer<Device, jpeg_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< jpeg_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::jpeg_write_is_supported , parent_t > op( this ); apply_operation( views, op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[��z�������extension/io/jpeg/detail/scanline_read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_JPEG_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/jpeg/detail/base.hpp> #include <boost/gil/extension/io/jpeg/detail/is_allowed.hpp> #include <boost/gil/extension/io/jpeg/detail/reader_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <boost/gil/io/typedefs.hpp> #include <csetjmp> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif /// /// JPEG Scanline Reader /// template< typename Device > class scanline_reader< Device , jpeg_tag > : public reader_backend< Device , jpeg_tag > { public: using tag_t = jpeg_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; public: scanline_reader( Device& device , const image_read_settings< jpeg_tag >& settings ) : reader_backend< Device , jpeg_tag >( device , settings ) { initialize(); } void read( byte_t dst , int ) { // Fire exception in case of error. if( setjmp( this->_mark )) { this->raise_error(); } // read data read_scanline( dst ); } /// Skip over a scanline. void skip( byte_t* dst, int ) { // Fire exception in case of error. if( setjmp( this->_mark )) { this->raise_error(); } // read data read_scanline( dst ); } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { this->get()->dct_method = this->_settings._dct_method; io_error_if( jpeg_start_decompress( this->get() ) == false , "Cannot start decompression." ); switch( this->_info._color_space ) { case JCS_GRAYSCALE: { this->_scanline_length = this->_info._width; break; } case JCS_RGB: //!\todo add Y'CbCr? We loose image quality when reading JCS_YCbCr as JCS_RGB case JCS_YCbCr: { this->_scanline_length = this->_info._width * num_channels< rgb8_view_t >::value; break; } case JCS_CMYK: //!\todo add Y'CbCrK? We loose image quality when reading JCS_YCCK as JCS_CMYK case JCS_YCCK: { this->get()->out_color_space = JCS_CMYK; this->_scanline_length = this->_info._width * num_channels< cmyk8_view_t >::value; break; } default: { io_error( "Unsupported jpeg color space." ); } } } void read_scanline( byte_t* dst ) { JSAMPLE row_adr = reinterpret_cast< JSAMPLE >( dst ); // Read data. io_error_if( jpeg_read_scanlines( this->get() , &row_adr , 1 ) != 1 , "jpeg_read_scanlines: fail to read JPEG file" ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[K+��:$��:$��!��extension/io/jpeg/detail/read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_JPEG_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_READ_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/base.hpp> #include <boost/gil/extension/io/jpeg/detail/is_allowed.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/typedefs.hpp> #include <csetjmp> #include <type_traits> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif /// /// JPEG Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , jpeg_tag , ConversionPolicy > : public reader_base< jpeg_tag , ConversionPolicy > , public reader_backend< Device , jpeg_tag > { private: using this_t = reader<Device, jpeg_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, jpeg_tag>; public: // // Constructor // reader( const Device& io_dev , const image_read_settings< jpeg_tag >& settings ) : reader_base< jpeg_tag , ConversionPolicy >() , backend_t( io_dev , settings ) {} // // Constructor // reader( const Device& io_dev , const typename ConversionPolicy::color_converter_type& cc , const image_read_settings< jpeg_tag >& settings ) : reader_base< jpeg_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} template<typename View> void apply( const View& view ) { // Fire exception in case of error. if( setjmp( this->_mark )) { this->raise_error(); } this->get()->dct_method = this->_settings._dct_method; using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_and_convert_t() ) , "Image types aren't compatible." ); if( jpeg_start_decompress( this->get() ) == false ) { io_error( "Cannot start decompression." ); } switch( this->_info._color_space ) { case JCS_GRAYSCALE: { this->_scanline_length = this->_info._width; read_rows< gray8_pixel_t >( view ); break; } case JCS_RGB: //!\todo add Y'CbCr? We loose image quality when reading JCS_YCbCr as JCS_RGB case JCS_YCbCr: { this->_scanline_length = this->_info._width * num_channels< rgb8_view_t >::value; read_rows< rgb8_pixel_t >( view ); break; } case JCS_CMYK: //!\todo add Y'CbCrK? We loose image quality when reading JCS_YCCK as JCS_CMYK case JCS_YCCK: { this->get()->out_color_space = JCS_CMYK; this->_scanline_length = this->_info._width * num_channels< cmyk8_view_t >::value; read_rows< cmyk8_pixel_t >( view ); break; } default: { io_error( "Unsupported jpeg color space." ); } } jpeg_finish_decompress ( this->get() ); } private: template< typename ImagePixel , typename View > void read_rows( const View& view ) { using buffer_t = std::vector<ImagePixel>; buffer_t buffer( this->_info._width ); // In case of an error we'll jump back to here and fire an exception. // @todo Is the buffer above cleaned up when the exception is thrown? // The strategy right now is to allocate necessary memory before // the setjmp. if( setjmp( this->_mark )) { this->raise_error(); } JSAMPLE row_adr = reinterpret_cast< JSAMPLE >( &buffer[0] ); //Skip scanlines if necessary. for( int y = 0; y < this->_settings._top_left.y; ++y ) { io_error_if( jpeg_read_scanlines( this->get() , &row_adr , 1 ) !=1 , "jpeg_read_scanlines: fail to read JPEG file" ); } // Read data. for( int y = 0; y < view.height(); ++y ) { io_error_if( jpeg_read_scanlines( this->get() , &row_adr , 1 ) != 1 , "jpeg_read_scanlines: fail to read JPEG file" ); typename buffer_t::iterator beg = buffer.begin() + this->_settings._top_left.x; typename buffer_t::iterator end = beg + this->_settings._dim.x; this->_cc_policy.read( beg , end , view.row_begin( y ) ); } //@todo: There might be a better way to do that. while( this->get()->output_scanline < this->get()->image_height ) { io_error_if( jpeg_read_scanlines( this->get() , &row_adr , 1 ) !=1 , "jpeg_read_scanlines: fail to read JPEG file" ); } } }; namespace detail { struct jpeg_type_format_checker { jpeg_type_format_checker( jpeg_color_space::type color_space ) : _color_space( color_space ) {} template< typename Image > bool apply() { return is_read_supported< typename get_pixel_type< typename Image::view_t >::type , jpeg_tag >::_color_space == _color_space; } private: jpeg_color_space::type _color_space; }; struct jpeg_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , jpeg_tag > {}; }; } // namespace detail /// /// JPEG Dynamic Reader /// template< typename Device > class dynamic_image_reader< Device , jpeg_tag > : public reader< Device , jpeg_tag , detail::read_and_no_convert > { using parent_t = reader<Device, jpeg_tag, detail::read_and_no_convert>; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< jpeg_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::jpeg_type_format_checker format_checker( this->_info._color_space != JCS_YCbCr ? this->_info._color_space : JCS_RGB ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::jpeg_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[Q��#��+��extension/io/jpeg/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_JPEG_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/base.hpp> #include <memory> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif namespace detail { /// /// Wrapper for libjpeg's compress object. Implements value semantics. /// struct jpeg_compress_wrapper { protected: using jpeg_compress_ptr_t = std::shared_ptr<jpeg_compress_struct>; protected: /// /// Default Constructor /// jpeg_compress_wrapper() : _jpeg_compress_ptr( new jpeg_compress_struct() , jpeg_compress_deleter ) {} jpeg_compress_struct* get() { return _jpeg_compress_ptr.get(); } const jpeg_compress_struct* get() const { return _jpeg_compress_ptr.get(); } private: static void jpeg_compress_deleter( jpeg_compress_struct* jpeg_compress_ptr ) { if( jpeg_compress_ptr ) { jpeg_destroy_compress( jpeg_compress_ptr ); delete jpeg_compress_ptr; jpeg_compress_ptr = nullptr; } } private: jpeg_compress_ptr_t _jpeg_compress_ptr; }; } // namespace detail /// /// JPEG Writer Backend /// template< typename Device > struct writer_backend< Device , jpeg_tag > : public jpeg_io_base , public detail::jpeg_compress_wrapper { public: using format_tag_t = jpeg_tag; public: /// /// Constructor /// writer_backend( const Device& io_dev , const image_write_info< jpeg_tag >& info ) : _io_dev( io_dev ) , _info( info ) { get()->err = jpeg_std_error( &_jerr ); get()->client_data = this; // Error exit handler: does not return to caller. _jerr.error_exit = &writer_backend< Device, jpeg_tag >::error_exit; // Fire exception in case of error. if( setjmp( _mark )) { raise_error(); } _dest._jdest.free_in_buffer = sizeof( buffer ); _dest._jdest.next_output_byte = buffer; _dest._jdest.init_destination = reinterpret_cast< void() ( j_compress_ptr ) >( &writer_backend< Device, jpeg_tag >::init_device ); _dest._jdest.empty_output_buffer = reinterpret_cast< boolean()( j_compress_ptr ) >( &writer_backend< Device, jpeg_tag >::empty_buffer ); _dest._jdest.term_destination = reinterpret_cast< void() ( j_compress_ptr ) >( &writer_backend< Device, jpeg_tag >::close_device ); _dest._this = this; jpeg_create_compress( get() ); get()->dest = &_dest._jdest; } ~writer_backend() { // JPEG compression object destruction does not signal errors, // unlike jpeg_finish_compress called elsewhere, // so there is no need for the setjmp bookmark here. jpeg_destroy_compress( get() ); } protected: struct gil_jpeg_destination_mgr { jpeg_destination_mgr _jdest; writer_backend< Device , jpeg_tag > _this; }; static void init_device( jpeg_compress_struct* cinfo ) { gil_jpeg_destination_mgr* dest = reinterpret_cast< gil_jpeg_destination_mgr* >( cinfo->dest ); dest->_jdest.free_in_buffer = sizeof( dest->_this->buffer ); dest->_jdest.next_output_byte = dest->_this->buffer; } static boolean empty_buffer( jpeg_compress_struct* cinfo ) { gil_jpeg_destination_mgr* dest = reinterpret_cast< gil_jpeg_destination_mgr* >( cinfo->dest ); dest->_this->_io_dev.write( dest->_this->buffer , buffer_size ); writer_backend<Device,jpeg_tag>::init_device( cinfo ); return static_cast<boolean>(TRUE); } static void close_device( jpeg_compress_struct* cinfo ) { writer_backend< Device , jpeg_tag >::empty_buffer( cinfo ); gil_jpeg_destination_mgr* dest = reinterpret_cast< gil_jpeg_destination_mgr* >( cinfo->dest ); dest->_this->_io_dev.flush(); } void raise_error() { io_error( "Cannot write jpeg file." ); } static void error_exit( j_common_ptr cinfo ) { writer_backend< Device, jpeg_tag >* mgr = reinterpret_cast< writer_backend< Device, jpeg_tag >* >( cinfo->client_data ); longjmp( mgr->_mark, 1 ); } public: Device _io_dev; image_write_info< jpeg_tag > _info; gil_jpeg_destination_mgr _dest; static const unsigned int buffer_size = 1024; JOCTET buffer[buffer_size]; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[��) j��j��,��extension/io/jpeg/detail/supported_types.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_JPEG_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { // Read support template< jpeg_color_space::type ColorSpace > struct jpeg_rw_support_base { static const jpeg_color_space::type _color_space = ColorSpace; }; template< typename Channel , typename ColorSpace > struct jpeg_read_support : read_support_false , jpeg_rw_support_base< JCS_UNKNOWN > {}; template<> struct jpeg_read_support<uint8_t , rgb_t > : read_support_true , jpeg_rw_support_base< JCS_RGB > {}; template<> struct jpeg_read_support<uint8_t , cmyk_t > : read_support_true , jpeg_rw_support_base< JCS_CMYK > {}; template<> struct jpeg_read_support<uint8_t , gray_t > : read_support_true , jpeg_rw_support_base< JCS_GRAYSCALE > {}; // Write support template< typename Channel , typename ColorSpace > struct jpeg_write_support : write_support_false , jpeg_rw_support_base< JCS_UNKNOWN > {}; template<> struct jpeg_write_support<uint8_t , gray_t > : write_support_true , jpeg_rw_support_base< JCS_GRAYSCALE > {}; template<> struct jpeg_write_support<uint8_t , rgb_t > : write_support_true , jpeg_rw_support_base< JCS_RGB > {}; template<> struct jpeg_write_support<uint8_t , cmyk_t > : write_support_true , jpeg_rw_support_base< JCS_CMYK > {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, jpeg_tag> : std::integral_constant < bool, detail::jpeg_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::jpeg_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const typename jpeg_color_space::type _color_space = parent_t::_color_space; }; template<typename Pixel> struct is_write_supported<Pixel, jpeg_tag> : std::integral_constant < bool, detail::jpeg_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > {}; } // namespace gil } // namespace boost #endif PK��p�[��[��'��extension/io/jpeg/detail/is_allowed.hppnu��[��// // Copyright 2009 Christian Henning // // 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_EXTENSION_IO_JPEG_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/jpeg/tags.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< jpeg_tag >& info , std::true_type // is read_and_no_convert ) { if( info._color_space == JCS_YCbCr ) { // We read JCS_YCbCr files as rgb. return ( is_read_supported< typename View::value_type , jpeg_tag >::_color_space == JCS_RGB ); } return ( is_read_supported< typename View::value_type , jpeg_tag >::_color_space == info._color_space ); } template< typename View > bool is_allowed( const image_read_info< jpeg_tag >& /* info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[��c]��]��extension/io/jpeg/read.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_JPEG_READ_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_READ_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_READ_ENABLED // TODO: Document, explain, review #include <boost/gil/extension/io/jpeg/tags.hpp> #include <boost/gil/extension/io/jpeg/detail/read.hpp> #include <boost/gil/extension/io/jpeg/detail/scanline_read.hpp> #include <boost/gil/extension/io/jpeg/detail/supported_types.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[��e ��extension/io/jpeg/old.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_JPEG_OLD_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_OLD_HPP #include <boost/gil/extension/io/jpeg.hpp> namespace boost { namespace gil { /// \ingroup JPEG_IO /// \brief Returns the width and height of the JPEG file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid JPEG file template<typename String> inline point_t jpeg_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, jpeg_tag>::type; backend_t backend = read_image_info(filename, jpeg_tag()); return { backend._info._width, backend._info._height }; } /// \ingroup JPEG_IO /// \brief Loads the image specified by the given jpeg image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the JPEG library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid JPEG file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void jpeg_read_view( const String& filename , const View& view ) { read_view( filename , view , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Allocates a new image whose dimensions are determined by the given jpeg image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the JPEG library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid JPEG file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void jpeg_read_image( const String& filename , Image& img ) { read_image( filename , img , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Loads and color-converts the image specified by the given jpeg image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid JPEG file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void jpeg_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Loads and color-converts the image specified by the given jpeg image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid JPEG file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void jpeg_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Allocates a new image whose dimensions are determined by the given jpeg image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid JPEG file template< typename String , typename Image , typename CC > inline void jpeg_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Allocates a new image whose dimensions are determined by the given jpeg image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid JPEG file template< typename String , typename Image > inline void jpeg_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , jpeg_tag() ); } /// \ingroup JPEG_IO /// \brief Saves the view to a jpeg file specified by the given jpeg image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the JPEG library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void jpeg_write_view( const String& filename , const View& view , int quality = jpeg_quality::default_value ) { write_view( filename , view , image_write_info< jpeg_tag >( quality ) ); } } // namespace gil } // namespace boost #endif PK��p�[��e^��extension/io/jpeg.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_JPEG_HPP #define BOOST_GIL_EXTENSION_IO_JPEG_HPP #include <boost/gil/extension/io/jpeg/read.hpp> #include <boost/gil/extension/io/jpeg/write.hpp> #endif PK��p�[R��extension/io/png.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_PNG_HPP #define BOOST_GIL_EXTENSION_IO_PNG_HPP #include <boost/gil/extension/io/png/read.hpp> #include <boost/gil/extension/io/png/write.hpp> #endif PK��p�[�e\|��\|��extension/io/bmp.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_BMP_HPP #define BOOST_GIL_EXTENSION_IO_BMP_HPP #include <boost/gil/extension/io/bmp/read.hpp> #include <boost/gil/extension/io/bmp/write.hpp> #endif PK��p�[ޑ�2a ��a ��extension/io/pnm/tags.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_PNM_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_PNM_READ_ENABLED // TODO: Document, explain, review #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { /// Defines pnm tag. struct pnm_tag : format_tag {}; /// see http://en.wikipedia.org/wiki/Portable_Bitmap_File_Format for reference /// Defines type for image type property. struct pnm_image_type : property_base< uint32_t > { using mono_asc_t = std::integral_constant<type, 1>; using gray_asc_t = std::integral_constant<type, 2>; using color_asc_t = std::integral_constant<type, 3>; using mono_bin_t = std::integral_constant<type, 4>; using gray_bin_t = std::integral_constant<type, 5>; using color_bin_t = std::integral_constant<type, 6>; }; /// Defines type for image width property. struct pnm_image_width : property_base< uint32_t > {}; /// Defines type for image height property. struct pnm_image_height : property_base< uint32_t > {}; /// Defines type for image max value property. struct pnm_image_max_value : property_base< uint32_t > {}; /// Read information for pnm images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< pnm_tag > { /// The image type. pnm_image_type::type _type; /// The image width. pnm_image_width::type _width; /// The image height. pnm_image_height::type _height; /// The image max value. pnm_image_max_value::type _max_value; }; /// Read settings for pnm images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< pnm_tag > : public image_read_settings_base { /// Default constructor image_read_settings< pnm_tag >() : image_read_settings_base() {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. image_read_settings( const point_t& top_left , const point_t& dim ) : image_read_settings_base( top_left , dim ) {} }; /// Write information for pnm images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< pnm_tag > { }; } // namespace gil } // namespace boost #endif PK��p�[\�V��V��extension/io/pnm/write.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_PNM_WRITE_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <boost/gil/extension/io/pnm/detail/supported_types.hpp> #include <boost/gil/extension/io/pnm/detail/write.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[��s����extension/io/pnm/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/pnm/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// PNM Backend /// template< typename Device > struct reader_backend< Device , pnm_tag > { public: using format_tag_t = pnm_tag; public: reader_backend( const Device& io_dev , const image_read_settings< pnm_tag >& settings ) : _io_dev ( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) { read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { // read signature io_error_if( read_char() != 'P', "Invalid PNM signature" ); _info._type = read_char() - '0'; io_error_if( _info._type < pnm_image_type::mono_asc_t::value \|\| _info._type > pnm_image_type::color_bin_t::value , "Invalid PNM file (supports P1 to P6)" ); _info._width = read_int(); _info._height = read_int(); if( _info._type == pnm_image_type::mono_asc_t::value \|\| _info._type == pnm_image_type::mono_bin_t::value ) { _info._max_value = 1; } else { _info._max_value = read_int(); io_error_if( _info._max_value > 255 , "Unsupported PNM format (supports maximum value 255)" ); } } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } private: // Read a character and skip a comment if necessary. char read_char() { char ch; if(( ch = _io_dev.getc() ) == '#' ) { // skip comment to EOL do { ch = _io_dev.getc(); } while (ch != '\n' && ch != '\r'); } return ch; } unsigned int read_int() { char ch; // skip whitespaces, tabs, and new lines do { ch = read_char(); } while (ch == ' ' \|\| ch == '\t' \|\| ch == '\n' \|\| ch == '\r'); if( ch < '0' \|\| ch > '9' ) { io_error( "Unexpected characters reading decimal digits" ); } unsigned val = 0; do { unsigned dig = ch - '0'; if( val > INT_MAX / 10 - dig ) { io_error( "Integer too large" ); } val = val * 10 + dig; ch = read_char(); } while( '0' <= ch && ch <= '9' ); return val; } public: Device _io_dev; image_read_settings< pnm_tag > _settings; image_read_info< pnm_tag > _info; std::size_t _scanline_length; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[ ��hI��I��!��extension/io/pnm/detail/write.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_WRITE_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <boost/gil/extension/io/pnm/detail/writer_backend.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstdlib> #include <string> #include <type_traits> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { struct pnm_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , pnm_tag > {}; }; } // namespace detail /// /// PNM Writer /// template< typename Device > class writer< Device , pnm_tag > : public writer_backend< Device , pnm_tag > { private: using backend_t = writer_backend<Device, pnm_tag>; public: writer( const Device& io_dev , const image_write_info< pnm_tag >& info ) : backend_t( io_dev , info ) {} template< typename View > void apply( const View& view ) { using pixel_t = typename get_pixel_type<View>::type; std::size_t width = view.width(); std::size_t height = view.height(); std::size_t chn = num_channels< View >::value; std::size_t pitch = chn * width; unsigned int type = get_type< num_channels< View >::value >( is_bit_aligned< pixel_t >() ); // write header // Add a white space at each string so read_int() can decide when a numbers ends. std::string str( "P" ); str += std::to_string( type ) + std::string( " " ); this->_io_dev.print_line( str ); str.clear(); str += std::to_string( width ) + std::string( " " ); this->_io_dev.print_line( str ); str.clear(); str += std::to_string( height ) + std::string( " " ); this->_io_dev.print_line( str ); if( type != pnm_image_type::mono_bin_t::value ) { this->_io_dev.print_line( "255 "); } // write data write_data( view , pitch , typename is_bit_aligned< pixel_t >::type() ); } private: template< int Channels > unsigned int get_type( std::true_type /* is_bit_aligned / ) { return mp11::mp_if_c < Channels == 1, pnm_image_type::mono_bin_t, pnm_image_type::color_bin_t >::value; } template< int Channels > unsigned int get_type( std::false_type / is_bit_aligned / ) { return mp11::mp_if_c < Channels == 1, pnm_image_type::gray_bin_t, pnm_image_type::color_bin_t >::value; } template< typename View > void write_data( const View& src , std::size_t pitch , const std::true_type& // bit_aligned ) { static_assert(std::is_same<View, typename gray1_image_t::view_t>::value, ""); byte_vector_t row( pitch / 8 ); using x_it_t = typename View::x_iterator; x_it_t row_it = x_it_t( &( row.begin() )); detail::negate_bits<byte_vector_t, std::true_type> negate; detail::mirror_bits<byte_vector_t, std::true_type> mirror; for (typename View::y_coord_t y = 0; y < src.height(); ++y) { std::copy(src.row_begin(y), src.row_end(y), row_it); mirror(row); negate(row); this->_io_dev.write(&row.front(), pitch / 8); } } template< typename View > void write_data( const View& src , std::size_t pitch , const std::false_type& // bit_aligned ) { std::vector< pixel< typename channel_type< View >::type , layout<typename color_space_type< View >::type > > > buf( src.width() ); // using pixel_t = typename View::value_type; // using view_t = typename view_type_from_pixel< pixel_t >::type; //view_t row = interleaved_view( src.width() // , 1 // , reinterpret_cast< pixel_t* >( &buf.front() ) // , pitch // ); byte_t* row_addr = reinterpret_cast< byte_t* >( &buf.front() ); for( typename View::y_coord_t y = 0 ; y < src.height() ; ++y ) { //copy_pixels( subimage_view( src // , 0 // , (int) y // , (int) src.width() // , 1 // ) // , row // ); std::copy( src.row_begin( y ) , src.row_end ( y ) , buf.begin() ); this->_io_dev.write( row_addr, pitch ); } } }; /// /// PNM Writer /// template< typename Device > class dynamic_image_writer< Device , pnm_tag > : public writer< Device , pnm_tag > { using parent_t = writer<Device, pnm_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< pnm_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::pnm_write_is_supported , parent_t > op( this ); apply_operation( views, op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[��ʵB��B��)��extension/io/pnm/detail/scanline_read.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/pnm/detail/is_allowed.hpp> #include <boost/gil/extension/io/pnm/detail/reader_backend.hpp> #include <boost/gil.hpp> // FIXME: Include what you use! #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <boost/gil/io/typedefs.hpp> #include <functional> #include <type_traits> #include <vector> namespace boost { namespace gil { /// /// PNM Reader /// template< typename Device > class scanline_reader< Device , pnm_tag > : public reader_backend< Device , pnm_tag > { public: using tag_t = pnm_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; public: scanline_reader( Device& device , const image_read_settings< pnm_tag >& settings ) : backend_t( device , settings ) { initialize(); } /// Read part of image defined by View and return the data. void read( byte_t* dst , int ) { _read_function( this, dst ); } /// Skip over a scanline. void skip( byte_t, int ) { _skip_function( this ); } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { switch( this->_info._type ) { // reading mono text is reading grayscale but with only two values case pnm_image_type::mono_asc_t::value: case pnm_image_type::gray_asc_t::value: { this->_scanline_length = this->_info._width; _read_function = std::mem_fn(&this_t::read_text_row); _skip_function = std::mem_fn(&this_t::skip_text_row); break; } case pnm_image_type::color_asc_t::value: { this->_scanline_length = this->_info._width num_channels< rgb8_view_t >::value; _read_function = std::mem_fn(&this_t::read_text_row); _skip_function = std::mem_fn(&this_t::skip_text_row); break; } case pnm_image_type::mono_bin_t::value: { //gray1_image_t this->_scanline_length = ( this->_info._width + 7 ) >> 3; _read_function = std::mem_fn(&this_t::read_binary_bit_row); _skip_function = std::mem_fn(&this_t::skip_binary_row); break; } case pnm_image_type::gray_bin_t::value: { // gray8_image_t this->_scanline_length = this->_info._width; _read_function = std::mem_fn(&this_t::read_binary_byte_row); _skip_function = std::mem_fn(&this_t::skip_binary_row); break; } case pnm_image_type::color_bin_t::value: { // rgb8_image_t this->_scanline_length = this->_info._width * num_channels< rgb8_view_t >::value; _read_function = std::mem_fn(&this_t::read_binary_byte_row); _skip_function = std::mem_fn(&this_t::skip_binary_row); break; } default: { io_error( "Unsupported pnm file." ); break; } } } void read_text_row( byte_t* dst ) { for( std::size_t x = 0; x < this->_scanline_length; ++x ) { for( uint32_t k = 0; ; ) { int ch = this->_io_dev.getc_unchecked(); if( isdigit( ch )) { _text_buffer[ k++ ] = static_cast< char >( ch ); } else if( k ) { _text_buffer[ k ] = 0; break; } else if( ch == EOF \|\| !isspace( ch )) { return; } } int value = atoi( _text_buffer ); if( this->_info._max_value == 1 ) { // for pnm format 0 is white dst[x] = ( value != 0 ) ? 0 : 255; } else { dst[x] = static_cast< byte_t >( value ); } } } void skip_text_row() { for( std::size_t x = 0; x < this->_scanline_length; ++x ) { for( uint32_t k = 0; ; ) { int ch = this->_io_dev.getc_unchecked(); if( isdigit( ch )) { k++; } else if( k ) { break; } else if( ch == EOF \|\| !isspace( ch )) { return; } } } } void read_binary_bit_row( byte_t* dst ) { this->_io_dev.read( dst , this->_scanline_length ); _negate_bits ( dst, this->_scanline_length ); _swap_half_bytes( dst, this->_scanline_length ); } void read_binary_byte_row( byte_t* dst ) { this->_io_dev.read( dst , this->_scanline_length ); } void skip_binary_row() { this->_io_dev.seek( static_cast<long>( this->_scanline_length ), SEEK_CUR ); } private: char _text_buffer[16]; // For bit_aligned images we need to negate all bytes in the row_buffer // to make sure that 0 is black and 255 is white. detail::negate_bits<std::vector<byte_t>, std::true_type> _negate_bits; detail::swap_half_bytes<std::vector<byte_t>, std::true_type> _swap_half_bytes; std::function<void(this_t, byte_t)> _read_function; std::function<void(this_t)> _skip_function; }; } // namespace gil } // namespace boost #endif PK��p�[r�I�2��2�� extension/io/pnm/detail/read.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_READ_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <boost/gil/extension/io/pnm/detail/reader_backend.hpp> #include <boost/gil/extension/io/pnm/detail/is_allowed.hpp> #include <boost/gil.hpp> // FIXME: Include what you use! #include <boost/gil/io/base.hpp> #include <boost/gil/io/bit_operations.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/typedefs.hpp> #include <type_traits> #include <vector> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// PNM Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , pnm_tag , ConversionPolicy > : public reader_base< pnm_tag , ConversionPolicy > , public reader_backend< Device , pnm_tag > { private: using this_t = reader<Device, pnm_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, pnm_tag>; reader( const Device& io_dev , const image_read_settings< pnm_tag >& settings ) : reader_base< pnm_tag , ConversionPolicy >() , backend_t( io_dev , settings ) {} reader( const Device& io_dev , const cc_t& cc , const image_read_settings< pnm_tag >& settings ) : reader_base< pnm_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} template<typename View> void apply( const View& view ) { using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_and_convert_t() ) , "Image types aren't compatible." ); switch( this->_info._type ) { // reading mono text is reading grayscale but with only two values case pnm_image_type::mono_asc_t::value: case pnm_image_type::gray_asc_t::value: { this->_scanline_length = this->_info._width; read_text_data< gray8_view_t >( view ); break; } case pnm_image_type::color_asc_t::value: { this->_scanline_length = this->_info._width num_channels< rgb8_view_t >::value; read_text_data< rgb8_view_t >( view ); break; } case pnm_image_type::mono_bin_t::value: { //gray1_image_t this->_scanline_length = ( this->_info._width + 7 ) >> 3; read_bin_data< gray1_image_t::view_t >( view ); break; } case pnm_image_type::gray_bin_t::value: { // gray8_image_t this->_scanline_length = this->_info._width; read_bin_data< gray8_view_t >( view ); break; } case pnm_image_type::color_bin_t::value: { // rgb8_image_t this->_scanline_length = this->_info._width * num_channels< rgb8_view_t >::value; read_bin_data< rgb8_view_t >( view ); break; } } } private: template< typename View_Src , typename View_Dst > void read_text_data( const View_Dst& dst ) { using y_t = typename View_Dst::y_coord_t; byte_vector_t row( this->_scanline_length ); //Skip scanlines if necessary. for( int y = 0; y < this->_settings._top_left.y; ++y ) { read_text_row< View_Src >( dst, row, y, false ); } for( y_t y = 0; y < dst.height(); ++y ) { read_text_row< View_Src >( dst, row, y, true ); } } template< typename View_Src , typename View_Dst > void read_text_row( const View_Dst& dst , byte_vector_t& row , typename View_Dst::y_coord_t y , bool process ) { View_Src src = interleaved_view( this->_info._width , 1 , (typename View_Src::value_type) &row.front() , this->_scanline_length ); for( uint32_t x = 0; x < this->_scanline_length; ++x ) { for( uint32_t k = 0; ; ) { int ch = this->_io_dev.getc_unchecked(); if( isdigit( ch )) { buf[ k++ ] = static_cast< char >( ch ); } else if( k ) { buf[ k ] = 0; break; } else if( ch == EOF \|\| !isspace( ch )) { return; } } if( process ) { int value = atoi( buf ); if( this->_info._max_value == 1 ) { using channel_t = typename channel_type<typename get_pixel_type<View_Dst>::type>::type; // for pnm format 0 is white row[x] = ( value != 0 ) ? typename channel_traits< channel_t >::value_type( 0 ) : channel_traits< channel_t >::max_value(); } else { row[x] = static_cast< byte_t >( value ); } } } if( process ) { // We are reading a gray1_image like a gray8_image but the two pixel_t // aren't compatible. Though, read_and_no_convert::read(...) wont work. copy_data< View_Dst , View_Src >( dst , src , y , typename std::is_same< View_Dst , gray1_image_t::view_t >::type() ); } } template< typename View_Dst , typename View_Src > void copy_data( const View_Dst& dst , const View_Src& src , typename View_Dst::y_coord_t y , std::true_type // is gray1_view ) { if( this->_info._max_value == 1 ) { typename View_Dst::x_iterator it = dst.row_begin( y ); for( typename View_Dst::x_coord_t x = 0 ; x < dst.width() ; ++x ) { it[x] = src[x]; } } else { copy_data(dst, src, y, std::false_type{}); } } template< typename View_Dst , typename View_Src > void copy_data( const View_Dst& view , const View_Src& src , typename View_Dst::y_coord_t y , std::false_type // is gray1_view ) { typename View_Src::x_iterator beg = src.row_begin( 0 ) + this->_settings._top_left.x; typename View_Src::x_iterator end = beg + this->_settings._dim.x; this->_cc_policy.read( beg , end , view.row_begin( y ) ); } template< typename View_Src , typename View_Dst > void read_bin_data( const View_Dst& view ) { using y_t = typename View_Dst::y_coord_t; using is_bit_aligned_t = typename is_bit_aligned<typename View_Src::value_type>::type; using rh_t = detail::row_buffer_helper_view<View_Src>; rh_t rh( this->_scanline_length, true ); typename rh_t::iterator_t beg = rh.begin() + this->_settings._top_left.x; typename rh_t::iterator_t end = beg + this->_settings._dim.x; // For bit_aligned images we need to negate all bytes in the row_buffer // to make sure that 0 is black and 255 is white. detail::negate_bits < typename rh_t::buffer_t, std::integral_constant<bool, is_bit_aligned_t::value> // TODO: Simplify after MPL removal > neg; detail::swap_half_bytes < typename rh_t::buffer_t, std::integral_constant<bool, is_bit_aligned_t::value> // TODO: Simplify after MPL removal > swhb; //Skip scanlines if necessary. for( y_t y = 0; y < this->_settings._top_left.y; ++y ) { this->_io_dev.read( reinterpret_cast< byte_t >( rh.data() ) , this->_scanline_length ); } for( y_t y = 0; y < view.height(); ++y ) { this->_io_dev.read( reinterpret_cast< byte_t* >( rh.data() ) , this->_scanline_length ); neg( rh.buffer() ); swhb( rh.buffer() ); this->_cc_policy.read( beg , end , view.row_begin( y ) ); } } private: char buf[16]; }; namespace detail { struct pnm_type_format_checker { pnm_type_format_checker( pnm_image_type::type type ) : _type( type ) {} template< typename Image > bool apply() { using is_supported_t = is_read_supported < typename get_pixel_type<typename Image::view_t>::type, pnm_tag >; return is_supported_t::_asc_type == _type \|\| is_supported_t::_bin_type == _type; } private: pnm_image_type::type _type; }; struct pnm_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , pnm_tag > {}; }; } // namespace detail /// /// PNM Dynamic Image Reader /// template< typename Device > class dynamic_image_reader< Device , pnm_tag > : public reader< Device , pnm_tag , detail::read_and_no_convert > { using parent_t = reader < Device, pnm_tag, detail::read_and_no_convert >; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< pnm_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::pnm_type_format_checker format_checker( this->_info._type ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::pnm_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // gil } // boost #endif PK��p�[�"�o��o����extension/io/pnm/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/pnm/tags.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// PNM Writer Backend /// template< typename Device > struct writer_backend< Device , pnm_tag > { public: using format_tag_t = pnm_tag; public: writer_backend( const Device& io_dev , const image_write_info< pnm_tag >& info ) : _io_dev( io_dev ) , _info( info ) {} public: Device _io_dev; image_write_info< pnm_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[��_n��+��extension/io/pnm/detail/supported_types.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/color_base.hpp> #include <boost/gil/io/base.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { // Read Support template< pnm_image_type::type ASCII_Type , pnm_image_type::type Binary_Type > struct pnm_rw_support_base { static const pnm_image_type::type _asc_type = ASCII_Type; static const pnm_image_type::type _bin_type = Binary_Type; }; template< typename Channel , typename ColorSpace > struct pnm_read_support : read_support_false , pnm_rw_support_base< 0 , 0 > {}; template< typename BitField, bool Mutable > struct pnm_read_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > , gray_t > : read_support_true , pnm_rw_support_base< pnm_image_type::mono_asc_t::value , pnm_image_type::mono_bin_t::value > {}; template<> struct pnm_read_support<uint8_t , gray_t > : read_support_true , pnm_rw_support_base< pnm_image_type::gray_asc_t::value , pnm_image_type::gray_bin_t::value > {}; template<> struct pnm_read_support<uint8_t , rgb_t > : read_support_true , pnm_rw_support_base< pnm_image_type::color_asc_t::value , pnm_image_type::color_bin_t::value > {}; // Write support template< typename Channel , typename ColorSpace > struct pnm_write_support : write_support_false {}; template< typename BitField, bool Mutable > struct pnm_write_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > , gray_t > : write_support_true , pnm_rw_support_base< pnm_image_type::mono_asc_t::value , pnm_image_type::mono_bin_t::value > {}; template<> struct pnm_write_support<uint8_t , gray_t > : write_support_true , pnm_rw_support_base< pnm_image_type::gray_asc_t::value , pnm_image_type::gray_bin_t::value > {}; template<> struct pnm_write_support<uint8_t , rgb_t > : write_support_true , pnm_rw_support_base< pnm_image_type::color_asc_t::value , pnm_image_type::color_bin_t::value > {}; } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, pnm_tag> : std::integral_constant < bool, detail::pnm_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::pnm_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const pnm_image_type::type _asc_type = parent_t::_asc_type; static const pnm_image_type::type _bin_type = parent_t::_bin_type; }; template<typename Pixel> struct is_write_supported<Pixel, pnm_tag> : std::integral_constant < bool, detail::pnm_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > {}; } // namespace gil } // namespace boost #endif PK��p�[��Le/��/��&��extension/io/pnm/detail/is_allowed.hppnu��[��// // Copyright 2009 Christian Henning // // 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_EXTENSION_IO_PNM_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_PNM_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< pnm_tag >& info , std::true_type // is read_and_no_convert ) { pnm_image_type::type asc_type = is_read_supported< typename get_pixel_type< View >::type , pnm_tag >::_asc_type; pnm_image_type::type bin_type = is_read_supported< typename get_pixel_type< View >::type , pnm_tag >::_bin_type; if( info._type == pnm_image_type::mono_asc_t::value ) { // ascii mono images are read gray8_image_t return ( asc_type == pnm_image_type::gray_asc_t::value ); } return ( asc_type == info._type \|\| bin_type == info._type ); } template< typename View > bool is_allowed( const image_read_info< pnm_tag >& / info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[��extension/io/pnm/read.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNM_READ_HPP #include <boost/gil/extension/io/pnm/tags.hpp> #include <boost/gil/extension/io/pnm/detail/supported_types.hpp> #include <boost/gil/extension/io/pnm/detail/read.hpp> #include <boost/gil/extension/io/pnm/detail/scanline_read.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[��=��=��extension/io/pnm/old.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_OLD_HPP #define BOOST_GIL_EXTENSION_IO_PNM_OLD_HPP #include <boost/gil/extension/io/pnm.hpp> namespace boost { namespace gil { /// \ingroup PNM_IO /// \brief Returns the width and height of the PNM file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid PNM file template<typename String> inline point_t pnm_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, pnm_tag>::type; backend_t backend = read_image_info(filename, pnm_tag()); return { backend._info._width, backend._info._height }; } /// \ingroup PNM_IO /// \brief Loads the image specified by the given pnm image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the PNM library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid PNM file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void pnm_read_view( const String& filename , const View& view ) { read_view( filename , view , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Allocates a new image whose dimensions are determined by the given pnm image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the PNM library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid PNM file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void pnm_read_image( const String& filename , Image& img ) { read_image( filename , img , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Loads and color-converts the image specified by the given pnm image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid PNM file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void pnm_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Loads and color-converts the image specified by the given pnm image file name into the given view. /// Throws std::ios_base::failure if the file is not a valid PNM file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void pnm_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Allocates a new image whose dimensions are determined by the given pnm image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid PNM file template< typename String , typename Image , typename CC > inline void pnm_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Allocates a new image whose dimensions are determined by the given pnm image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid PNM file template< typename String , typename Image > inline void pnm_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , pnm_tag() ); } /// \ingroup PNM_IO /// \brief Saves the view to a pnm file specified by the given pnm image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the PNM library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void pnm_write_view( const String& filename , const View& view ) { write_view( filename , view , pnm_tag() ); } } // namespace gil } // namespace boost #endif PK��p�[F� \|��\|��extension/io/pnm.hppnu��[��// // Copyright 2008 Christian Henning // // 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_EXTENSION_IO_PNM_HPP #define BOOST_GIL_EXTENSION_IO_PNM_HPP #include <boost/gil/extension/io/pnm/read.hpp> #include <boost/gil/extension/io/pnm/write.hpp> #endif PK��p�[��k��k��extension/io/png/tags.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_TAGS_HPP #define BOOST_GIL_EXTENSION_IO_PNG_TAGS_HPP #include <boost/gil/io/base.hpp> #include <string> #include <vector> #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED #ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED # error "Cannot set both symbols" #endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED #ifndef BOOST_GIL_EXTENSION_IO_PNG_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <png.h> #ifndef BOOST_GIL_EXTENSION_IO_PNG_C_LIB_COMPILED_AS_CPLUSPLUS } #endif #ifndef BOOST_GIL_EXTENSION_IO_ZLIB_C_LIB_COMPILED_AS_CPLUSPLUS extern "C" { #endif #include <zlib.h> #ifndef BOOST_GIL_EXTENSION_IO_ZLIB_C_LIB_COMPILED_AS_CPLUSPLUS } #endif #if PNG_LIBPNG_VER_MAJOR == 1 #if PNG_LIBPNG_VER_MINOR <= 4 #define BOOST_GIL_IO_PNG_1_4_OR_LOWER #endif // PNG_LIBPNG_VER_MAJOR == 1 #endif // PNG_LIBPNG_VER_MINOR <= 4 namespace boost { namespace gil { /// Defines png tag. struct png_tag : format_tag {}; /// see http://en.wikipedia.org/wiki/Portable_Network_Graphics for reference /// Defines type for image width property. struct png_image_width : property_base< png_uint_32 > {}; /// Defines type for image height property. struct png_image_height : property_base< png_uint_32 > {}; /// Defines type for interlace method property. struct png_interlace_method : property_base< int > {}; /// Defines type for filter method property. struct png_filter_method : property_base< int > {}; /// Defines type for bit depth method property. struct png_bitdepth : property_base< int > {}; /// Defines type for bit depth method property. struct png_color_type : property_base< int > {}; /// Defines type for number of channels property. struct png_num_channels : property_base< png_byte > {}; #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED /// Defines type for CIE chromacities property. struct png_chromacities_type : property_base< double > {}; /// Defines type for gamma correction property. struct png_gamma : property_base< double > {}; /// Defines type for physical scale unit property. struct png_unit : property_base< int > {}; /// Defines type for physical scale property. struct png_scale : property_base< double > {}; #else /// Defines type for CIE chromacities property. struct png_chromacities_type : property_base< png_fixed_point > {}; /// Defines type for gamma correction property. struct png_gamma : property_base< png_fixed_point > {}; /// Defines type for physical scale unit property. struct png_unit : property_base< int > {}; #ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED /// Defines type for physical scale property. struct png_scale : property_base< png_fixed_point > {}; #else /// Defines type for physical scale property. struct png_scale : property_base< std::string > {}; #endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED /// Returns image resolution in pixels per meter, from pHYs chunk data. struct png_pixels_per_meter : property_base< png_uint_32 > {}; /// Defines type for ICC profile name property. struct png_ICC_name : property_base< std::string > {}; /// Defines type for ICC profile property. #if PNG_LIBPNG_VER_MINOR >= 5 struct png_ICC_profile : property_base< std:: vector <uint8_t> > {}; #else struct png_ICC_profile : property_base< std:: vector <char> > {}; #endif /// Defines type for ICC profile length property. struct png_ICC_profile_length : property_base< png_uint_32 > {}; /// Defines type for ICC compression property. struct png_ICC_compression_type : property_base< int > {}; /// Defines type for rendering intent property. struct png_intent : property_base< int > {}; /// Defines type for color palette property. struct png_color_palette : property_base< std::vector< png_color > > {}; /// Defines type for number of colors property. struct png_num_palette : property_base< int > {}; /// Defines type for background property. struct png_background : property_base< png_color_16 > {}; /// Defines type for histogram property. struct png_histrogram : property_base< std::vector< png_uint_16 > > {}; /// Defines type for screen offset property. struct png_offset : property_base< png_int_32 > {}; /// Defines type for screen offset type property. struct png_offset_type : property_base< int > {}; /// Defines type pixel calibration for property. struct png_CAL : property_base< std::string > {}; /// Defines type for pixel calibration parameters property. struct png_CAL_params : property_base< std::vector< std::string > > {}; /// Defines type for pixel calibration x property. struct png_CAL_X : property_base< png_int_32 > {}; /// Defines type for pixel calibration type property. struct png_CAL_type : property_base< int > {}; /// Defines type for number of pixel calibration properties. struct png_CAL_nparam : property_base< int > {}; /// Defines type for physical resolution property. struct png_resolution : property_base< png_uint_32 > {}; /// Defines type for physical resolution unit property. struct png_unit_type : property_base< int > {}; /// Defines type for significant bits property. struct png_significant_bits : property_base< png_color_8 > {}; /// Helper structure for reading text property. struct gil_io_png_text { /// Compression type int _compression; // Key std::string _key; /// Text std::string _text; }; /// Defines type for text property. struct png_text_ : property_base< std::vector< gil_io_png_text > > {}; /// Defines type for number of text property. struct png_num_text : property_base< int > {}; /// Defines type for modification time property. struct png_mod_time : property_base< png_time > {}; /// Defines type for transparency data property. struct png_trans : property_base< std::vector< png_byte > > {}; /// Defines type for number of transparency data property. struct png_num_trans : property_base< int > {}; /// Defines type for transparency data values property. struct png_trans_values : property_base< std::vector< png_color_16 > > {}; /// Defines type for png function return type. struct png_return_value : property_base< png_uint_32 > {}; //////////////////////// // Write properties //////////////////////// // relates to info_ptr->compression_type struct png_compression_type : property_base< png_byte > { static const type default_value = PNG_COMPRESSION_TYPE_BASE; }; // compression level - default values taken from libpng manual. // Look for png_set_compression_level struct png_compression_level : property_base< int > { static const type default_value = 3; }; struct png_compression_mem_level : property_base< int > { static const type default_value = MAX_MEM_LEVEL; }; struct png_compression_strategy : property_base< int > { static const type default_value = Z_DEFAULT_STRATEGY; }; struct png_compression_window_bits : property_base< int > { static const type default_value = 9; }; struct png_compression_method : property_base< int > { static const type default_value = 8; }; struct png_compression_buffer_size : property_base< int > { static const type default_value = 8192; }; // dithering struct png_dithering_palette : property_base< std::vector< png_color > > {}; struct png_dithering_num_palette : property_base< int > { static const type default_value = 0; }; struct png_dithering_maximum_colors : property_base< int > { static const type default_value = 0; }; struct png_dithering_histogram : property_base< std::vector< png_uint_16 > > {}; struct png_full_dither : property_base< int > { static const type default_value = 0; }; // filter struct png_filter : property_base< int > { static const type default_value = 0; }; // invert mono struct png_invert_mono : property_base< bool > { static const type default_value = false; }; // true bits struct png_true_bits : property_base< std::vector< png_color_8 > > {}; // sRGB Intent struct png_srgb_intent : property_base< int > { static const type default_value = 0; }; // strip alpha struct png_strip_alpha : property_base< bool > { static const type default_value = false; }; struct png_swap_alpha : property_base< bool > { static const type default_value = false; }; /// PNG info base class. Containing all header information both for reading and writing. /// /// This base structure was created to avoid code doubling. struct png_info_base { /// Default constructor png_info_base() : _width ( 0 ) , _height( 0 ) , _bit_depth ( 0 ) , _color_type ( 0 ) , _interlace_method ( PNG_INTERLACE_NONE ) , _compression_method( PNG_COMPRESSION_TYPE_DEFAULT ) , _filter_method ( PNG_FILTER_TYPE_DEFAULT ) , _num_channels( 0 ) #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED , _valid_cie_colors( 0 ) , _white_x ( 0.0 ) , _white_y ( 0.0 ) , _red_x ( 0.0 ) , _red_y ( 0.0 ) , _green_x ( 0.0 ) , _green_y ( 0.0 ) , _blue_x ( 0.0 ) , _blue_y ( 0.0 ) , _valid_file_gamma( 0 ) , _file_gamma ( 1.0 ) #else , _valid_cie_colors( 0 ) , _white_x ( 0 ) , _white_y ( 0 ) , _red_x ( 0 ) , _red_y ( 0 ) , _green_x ( 0 ) , _green_y ( 0 ) , _blue_x ( 0 ) , _blue_y ( 0 ) , _valid_file_gamma( 0 ) , _file_gamma ( 1 ) #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED , _valid_icc_profile ( 0 ) , _icc_name ( ) , _iccp_compression_type( PNG_COMPRESSION_TYPE_BASE ) , _profile ( ) , _profile_length ( 0 ) , _valid_intent( 0 ) , _intent ( 0 ) , _valid_palette( 0 ) , _palette ( ) , _num_palette ( 0 ) , _valid_background( 0 ) , _background ( ) , _valid_histogram( 0 ) , _histogram ( ) , _valid_offset ( 0 ) , _offset_x ( 0 ) , _offset_y ( 0 ) , _off_unit_type( PNG_OFFSET_PIXEL ) , _valid_pixel_calibration( 0 ) , _purpose ( ) , _X0 ( 0 ) , _X1 ( 0 ) , _cal_type ( 0 ) , _num_params ( 0 ) , _units ( ) , _params ( ) , _valid_resolution( 0 ) , _res_x ( 0 ) , _res_y ( 0 ) , _phy_unit_type ( PNG_RESOLUTION_UNKNOWN ) , _pixels_per_meter( 0 ) , _valid_significant_bits( 0 ) , _sig_bits ( ) , _valid_scale_factors( 0 ) , _scale_unit ( PNG_SCALE_UNKNOWN ) #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED , _scale_width ( 0.0 ) , _scale_height( 0.0 ) #else #ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED , _scale_width ( 0 ) , _scale_height( 0 ) #else , _scale_width () , _scale_height() #endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED , _valid_text( 0 ) , _text ( ) , _num_text ( 0 ) , _valid_modification_time( 0 ) , _mod_time ( ) , _valid_transparency_factors( 0 ) , _trans ( ) , _num_trans ( 0 ) , _trans_values ( ) {} /// The image width. png_image_width::type _width; /// The image height. png_image_height::type _height; /// The bit depth per channel. png_bitdepth::type _bit_depth; /// The color space type. png_color_type::type _color_type; /// The interlace methos. png_interlace_method::type _interlace_method; /// The compression method. png_compression_method::type _compression_method; /// The filer method. png_filter_method::type _filter_method; /// The number of channels. png_num_channels::type _num_channels; // CIE chromacities /// The return value when reading CIE chromacities. png_return_value::type _valid_cie_colors; /// The white x value. png_chromacities_type::type _white_x; /// The white y value. png_chromacities_type::type _white_y; /// The red x value. png_chromacities_type::type _red_x; /// The red y value. png_chromacities_type::type _red_y; /// The green x value. png_chromacities_type::type _green_x; /// The green y value. png_chromacities_type::type _green_y; /// The blue x value. png_chromacities_type::type _blue_x; /// The blue y value. png_chromacities_type::type _blue_y; // Gamma Value /// The return value when reading gamma value. png_return_value::type _valid_file_gamma; /// The file gamma value. png_gamma::type _file_gamma; // Embedded ICC profile /// The return value when reading ICC profile. png_return_value::type _valid_icc_profile; /// The ICC name. png_ICC_name::type _icc_name; /// The icc compression type. png_ICC_compression_type::type _iccp_compression_type; /// The ICC profile. png_ICC_profile::type _profile; /// The ICC profile length. png_ICC_profile_length::type _profile_length; // Rendering intent /// The return value when reading rendering intent. png_return_value::type _valid_intent; /// The rendering intent value. png_intent::type _intent; // Image palette /// The return value when reading image palette. png_return_value::type _valid_palette; /// The color palette. png_color_palette::type _palette; /// The number of colors in the palettes. png_num_palette::type _num_palette; // Background /// The return value when reading background. png_return_value::type _valid_background; /// The background color. png_background::type _background; // Histogram /// The return value when reading histogram. png_return_value::type _valid_histogram; /// The histogram. png_histrogram::type _histogram; // Screen offsets /// The return value when reading screen offsets. png_return_value::type _valid_offset; /// The x offset. png_offset::type _offset_x; /// The y offset. png_offset::type _offset_y; /// The offset unit. png_offset_type::type _off_unit_type; // Pixel Calibration /// The return value when reading pixel calibration. png_return_value::type _valid_pixel_calibration; /// The purpose. png_CAL::type _purpose; /// The x_0 value. png_CAL_X::type _X0; /// The x_1 value. png_CAL_X::type _X1; /// The calibration type. png_CAL_type::type _cal_type; /// The number of calibration parameters. png_CAL_nparam::type _num_params; /// The calibration unit type. png_CAL::type _units; /// The calibration parameters. png_CAL_params::type _params; // Physical resolution /// The return value when reading physical resolution properties. png_return_value::type _valid_resolution; /// The x physical resolution. png_resolution::type _res_x; /// The y physical resolution. png_resolution::type _res_y; /// The physical resolution unit. png_unit_type::type _phy_unit_type; /// The Image resolution in pixels per meter. png_pixels_per_meter::type _pixels_per_meter; // Number of significant bits /// The return value when reading significant bits. png_return_value::type _valid_significant_bits; /// The significant bits. png_significant_bits::type _sig_bits; // Scale Factors /// The return value when reading scale factors. png_return_value::type _valid_scale_factors; /// The scaling unit. png_unit::type _scale_unit; /// The scaling width. png_scale::type _scale_width; /// The scaling height. png_scale::type _scale_height; // Comments information /// The return value when reading image comments. png_return_value::type _valid_text; /// The comments. png_text_::type _text; /// The number of comments. png_num_text::type _num_text; // Last modification time /// The return value when reading modification time. png_return_value::type _valid_modification_time; /// The modification time. png_mod_time::type _mod_time; // Transparency data /// The return value when reading transparency data. png_return_value::type _valid_transparency_factors; /// The transparency data. png_trans::type _trans; /// The number of transparency data. png_num_trans::type _num_trans; /// The transparency data values. png_trans_values::type _trans_values; }; /// Read information for png images. /// /// The structure is returned when using read_image_info. template<> struct image_read_info< png_tag > : public png_info_base { /// Default constructor. image_read_info< png_tag >() : png_info_base() {} }; /// PNG settings base class. /// /// This base structure was created to avoid code doubling. struct png_read_settings_base { /// Default Constructor. png_read_settings_base() { _read_cie_chromacities = false; _read_file_gamma = false; _read_icc_profile = false; _read_intent = false; _read_palette = false; _read_background = false; _read_histogram = false; _read_screen_offsets = false; _read_pixel_calibration = false; _read_physical_resolution = false; _read_pixels_per_meter = false; _read_number_of_significant_bits = false; _read_scale_factors = false; _read_comments = false; _read_last_modification_time = false; _read_transparency_data = false; } /// Helper function to enabling reading all png properties. void set_read_members_true() { _read_cie_chromacities = true; _read_file_gamma = true; _read_icc_profile = true; _read_intent = true; _read_palette = true; _read_background = true; _read_histogram = true; _read_screen_offsets = true; _read_pixel_calibration = true; _read_physical_resolution = true; _read_pixels_per_meter = true; _read_number_of_significant_bits = true; _read_scale_factors = true; _read_comments = true; _read_last_modification_time = true; _read_transparency_data = true; } /// Enable reading CIE chromacities. bool _read_cie_chromacities; /// Enable reading file gamma. bool _read_file_gamma; /// Enable reading ICC profile. bool _read_icc_profile; /// Enable reading rendering intent. bool _read_intent; /// Enable reading color palette. bool _read_palette; /// Enable reading background color. bool _read_background; /// Enable reading histogram. bool _read_histogram; /// Enable reading screen offsets. bool _read_screen_offsets; /// Enable reading pixel calibration. bool _read_pixel_calibration; /// Enable reading physical resolution. bool _read_physical_resolution; /// Enable reading pixels per meter information. bool _read_pixels_per_meter; /// Enable reading significant bits. bool _read_number_of_significant_bits; /// Enable reading scaling factors. bool _read_scale_factors; /// Enable reading comments. bool _read_comments; /// Enable reading modification time. bool _read_last_modification_time; /// Enable reading transparency data. bool _read_transparency_data; }; #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED /// Read settings for png images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< png_tag > : public image_read_settings_base , public png_read_settings_base { /// Default Constructor image_read_settings< png_tag >() : image_read_settings_base() , png_read_settings_base() , _screen_gamma( 1.0 ) {} /// Constructor /// \param top_left Top left coordinate for reading partial image. /// \param dim Dimensions for reading partial image. /// \param gamma Screen gamma value. image_read_settings( const point_t& top_left , const point_t& dim , const bool apply_screen_gamma = false , const png_gamma::type& screen_gamma = 1.0 ) : image_read_settings_base( top_left , dim ) , png_read_settings_base() , _apply_screen_gamma( apply_screen_gamma ) , _screen_gamma( screen_gamma ) {} /// Apply screen gamma value. bool _apply_screen_gamma; /// The screen gamma value. png_gamma::type _screen_gamma; }; #else /// Read settings for png images. /// /// The structure can be used for all read_xxx functions, except read_image_info. template<> struct image_read_settings< png_tag > : public image_read_settings_base , public png_read_settings_base { /// Default Constructor. image_read_settings< png_tag >() : image_read_settings_base() , png_read_settings_base() , _apply_screen_gamma( false ) , _screen_gamma ( 2 ) {} image_read_settings( const point_t& top_left , const point_t& dim ) : image_read_settings_base( top_left , dim ) , png_read_settings_base() , _apply_screen_gamma( false ) , _screen_gamma ( 2 ) {} /// Apply screen gamma value. bool _apply_screen_gamma; /// The screen gamma value. png_gamma::type _screen_gamma; }; #endif /// Write information for png images. /// /// The structure can be used for write_view() function. template<> struct image_write_info< png_tag > : public png_info_base { image_write_info( const png_compression_type::type compression_type = png_compression_type::default_value , const png_compression_level::type compression_level = png_compression_level::default_value , const png_compression_mem_level::type compression_mem_level = png_compression_mem_level::default_value , const png_compression_strategy::type compression_strategy = png_compression_strategy::default_value , const png_compression_window_bits::type compression_window_bits = png_compression_window_bits::default_value , const png_compression_method::type compression_method = png_compression_method::default_value , const png_compression_buffer_size::type compression_buffer_size = png_compression_buffer_size::default_value , const png_dithering_num_palette::type num_palette = png_dithering_num_palette::default_value , const png_dithering_maximum_colors::type maximum_colors = png_dithering_maximum_colors::default_value , const png_full_dither::type full_dither = png_full_dither::default_value , const png_filter::type filter = png_filter::default_value , const png_invert_mono::type invert_mono = png_invert_mono::default_value , const png_srgb_intent::type srgb_intent = png_srgb_intent::default_value , const png_strip_alpha::type strip_alpha = png_strip_alpha::default_value , const png_swap_alpha::type swap_alpha = png_swap_alpha::default_value ) : png_info_base() , _compression_type( compression_type ) , _compression_level( compression_level ) , _compression_mem_level( compression_mem_level ) , _compression_strategy( compression_strategy ) , _compression_window_bits( compression_window_bits ) , _compression_method( compression_method ) , _compression_buffer_size( compression_buffer_size ) , _set_dithering( false ) , _dithering_palette() , _dithering_num_palette( num_palette ) , _dithering_maximum_colors( maximum_colors ) , _dithering_histogram() , _full_dither( full_dither ) , _set_filter( false ) , _filter( filter ) , _invert_mono( invert_mono ) , _set_true_bits( false ) , _true_bits() , _set_srgb_intent( false ) , _srgb_intent( srgb_intent ) , _strip_alpha( strip_alpha ) , _swap_alpha( swap_alpha ) {} // compression stuff png_compression_type::type _compression_type; png_compression_level::type _compression_level; png_compression_mem_level::type _compression_mem_level; png_compression_strategy::type _compression_strategy; png_compression_window_bits::type _compression_window_bits; png_compression_method::type _compression_method; png_compression_buffer_size::type _compression_buffer_size; // png_set_dither bool _set_dithering; png_dithering_palette::type _dithering_palette; png_dithering_num_palette::type _dithering_num_palette; png_dithering_maximum_colors::type _dithering_maximum_colors; png_dithering_histogram::type _dithering_histogram; png_full_dither::type _full_dither; //png_set_filter bool _set_filter; png_filter::type _filter; // png_set_invert_mono png_invert_mono::type _invert_mono; // png_set_sBIT bool _set_true_bits; png_true_bits::type _true_bits; // png_set_sRGB bool _set_srgb_intent; png_srgb_intent::type _srgb_intent; // png_set_strip_alpha png_strip_alpha::type _strip_alpha; // png_set_swap_alpha png_swap_alpha::type _swap_alpha; }; } // namespace gil } // namespace boost #endif PK��p�[��&�[��[��extension/io/png/write.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_PNG_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_PNG_WRITE_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <boost/gil/extension/io/png/detail/supported_types.hpp> #include <boost/gil/extension/io/png/detail/write.hpp> #include <boost/gil/io/make_dynamic_image_writer.hpp> #include <boost/gil/io/make_writer.hpp> #include <boost/gil/io/write_view.hpp> #endif PK��p�[�6�f��f����extension/io/png/detail/reader_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_DETAIL_READER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_DETAIL_READER_BACKEND_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <boost/gil/extension/io/png/detail/base.hpp> #include <boost/gil/extension/io/png/detail/supported_types.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif /// /// PNG Backend /// template<typename Device > struct reader_backend< Device , png_tag > : public detail::png_struct_info_wrapper { public: using format_tag_t = png_tag; using this_t = reader_backend<Device, png_tag>; public: reader_backend( const Device& io_dev , const image_read_settings< png_tag >& settings ) : _io_dev( io_dev ) , _settings( settings ) , _info() , _scanline_length( 0 ) , _number_passes( 0 ) { read_header(); if( _settings._dim.x == 0 ) { _settings._dim.x = _info._width; } if( _settings._dim.y == 0 ) { _settings._dim.y = _info._height; } } void read_header() { using boost::gil::detail::PNG_BYTES_TO_CHECK; // check the file's first few bytes byte_t buf[PNG_BYTES_TO_CHECK]; io_error_if( _io_dev.read( buf , PNG_BYTES_TO_CHECK ) != PNG_BYTES_TO_CHECK , "png_check_validity: failed to read image" ); io_error_if( png_sig_cmp( png_bytep(buf) , png_size_t(0) , PNG_BYTES_TO_CHECK ) != 0 , "png_check_validity: invalid png image" ); // Create and initialize the png_struct with the desired error handler // functions. If you want to use the default stderr and longjump method, // you can supply NULL for the last three parameters. We also supply the // the compiler header file version, so that we know if the application // was compiled with a compatible version of the library. REQUIRED get()->_struct = png_create_read_struct( PNG_LIBPNG_VER_STRING , nullptr // user_error_ptr , nullptr // user_error_fn , nullptr // user_warning_fn ); io_error_if( get()->_struct == nullptr , "png_reader: fail to call png_create_write_struct()" ); png_uint_32 user_chunk_data[4]; user_chunk_data[0] = 0; user_chunk_data[1] = 0; user_chunk_data[2] = 0; user_chunk_data[3] = 0; png_set_read_user_chunk_fn( get_struct() , user_chunk_data , this_t::read_user_chunk_callback ); // Allocate/initialize the memory for image information. REQUIRED. get()->_info = png_create_info_struct( get_struct() ); if( get_info() == nullptr ) { png_destroy_read_struct( &get()->_struct , nullptr , nullptr ); io_error( "png_reader: fail to call png_create_info_struct()" ); } // Set error handling if you are using the setjmp/longjmp method (this is // the normal method of doing things with libpng). REQUIRED unless you // set up your own error handlers in the png_create_read_struct() earlier. if( setjmp( png_jmpbuf( get_struct() ))) { //free all of the memory associated with the png_ptr and info_ptr png_destroy_read_struct( &get()->_struct , &get()->_info , nullptr ); io_error( "png is invalid" ); } png_set_read_fn( get_struct() , static_cast< png_voidp >( &this->_io_dev ) , this_t::read_data ); // Set up a callback function that will be // called after each row has been read, which you can use to control // a progress meter or the like. png_set_read_status_fn( get_struct() , this_t::read_row_callback ); // Set up a callback which implements user defined transformation. // @todo png_set_read_user_transform_fn( get_struct() , png_user_transform_ptr( nullptr ) ); png_set_keep_unknown_chunks( get_struct() , PNG_HANDLE_CHUNK_ALWAYS , nullptr , 0 ); // Make sure we read the signature. // @todo make it an option png_set_sig_bytes( get_struct() , PNG_BYTES_TO_CHECK ); // The call to png_read_info() gives us all of the information from the // PNG file before the first IDAT (image data chunk). REQUIRED png_read_info( get_struct() , get_info() ); /// /// Start reading the image information /// // get PNG_IHDR chunk information from png_info structure png_get_IHDR( get_struct() , get_info() , &this->_info._width , &this->_info._height , &this->_info._bit_depth , &this->_info._color_type , &this->_info._interlace_method , &this->_info._compression_method , &this->_info._filter_method ); // get number of color channels in image this->_info._num_channels = png_get_channels( get_struct() , get_info() ); #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED // Get CIE chromacities and referenced white point if( this->_settings._read_cie_chromacities ) { this->_info._valid_cie_colors = png_get_cHRM( get_struct() , get_info() , &this->_info._white_x, &this->_info._white_y , &this->_info._red_x, &this->_info._red_y , &this->_info._green_x, &this->_info._green_y , &this->_info._blue_x, &this->_info._blue_y ); } // get the gamma value if( this->_settings._read_file_gamma ) { this->_info._valid_file_gamma = png_get_gAMA( get_struct() , get_info() , &this->_info._file_gamma ); if( this->_info._valid_file_gamma == false ) { this->_info._file_gamma = 1.0; } } #else // Get CIE chromacities and referenced white point if( this->_settings._read_cie_chromacities ) { this->_info._valid_cie_colors = png_get_cHRM_fixed( get_struct() , get_info() , &this->_info._white_x, &this->_info._white_y , &this->_info._red_x, &this->_info._red_y , &this->_info._green_x, &this->_info._green_y , &this->_info._blue_x, &this->_info._blue_y ); } // get the gamma value if( this->_settings._read_file_gamma ) { this->_info._valid_file_gamma = png_get_gAMA_fixed( get_struct() , get_info() , &this->_info._file_gamma ); if( this->_info._valid_file_gamma == false ) { this->_info._file_gamma = 1; } } #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED // get the embedded ICC profile data if( this->_settings._read_icc_profile ) { #if PNG_LIBPNG_VER_MINOR >= 5 png_charp icc_name = png_charp( nullptr ); png_bytep profile = png_bytep( nullptr ); this->_info._valid_icc_profile = png_get_iCCP( get_struct() , get_info() , &icc_name , &this->_info._iccp_compression_type , &profile , &this->_info._profile_length ); #else png_charp icc_name = png_charp( NULL ); png_charp profile = png_charp( NULL ); this->_info._valid_icc_profile = png_get_iCCP( get_struct() , get_info() , &icc_name , &this->_info._iccp_compression_type , &profile , &this->_info._profile_length ); #endif if( icc_name ) { this->_info._icc_name.append( icc_name , std::strlen( icc_name ) ); } if( this->_info._profile_length != 0 ) { std:: copy_n (profile, this->_info._profile_length, std:: back_inserter (this->_info._profile)); } } // get the rendering intent if( this->_settings._read_intent ) { this->_info._valid_intent = png_get_sRGB( get_struct() , get_info() , &this->_info._intent ); } // get image palette information from png_info structure if( this->_settings._read_palette ) { png_colorp palette = png_colorp( nullptr ); this->_info._valid_palette = png_get_PLTE( get_struct() , get_info() , &palette , &this->_info._num_palette ); if( this->_info._num_palette > 0 ) { this->_info._palette.resize( this->_info._num_palette ); std::copy( palette , palette + this->_info._num_palette , &this->_info._palette.front() ); } } // get background color if( this->_settings._read_background ) { png_color_16p background = png_color_16p( nullptr ); this->_info._valid_background = png_get_bKGD( get_struct() , get_info() , &background ); if( background ) { this->_info._background = background; } } // get the histogram if( this->_settings._read_histogram ) { png_uint_16p histogram = png_uint_16p( nullptr ); this->_info._valid_histogram = png_get_hIST( get_struct() , get_info() , &histogram ); if( histogram ) { // the number of values is set by the number of colors inside // the palette. if( this->_settings._read_palette == false ) { png_colorp palette = png_colorp( nullptr ); png_get_PLTE( get_struct() , get_info() , &palette , &this->_info._num_palette ); } std::copy( histogram , histogram + this->_info._num_palette , &this->_info._histogram.front() ); } } // get screen offsets for the given image if( this->_settings._read_screen_offsets ) { this->_info._valid_offset = png_get_oFFs( get_struct() , get_info() , &this->_info._offset_x , &this->_info._offset_y , &this->_info._off_unit_type ); } // get pixel calibration settings if( this->_settings._read_pixel_calibration ) { png_charp purpose = png_charp ( nullptr ); png_charp units = png_charp ( nullptr ); png_charpp params = png_charpp( nullptr ); this->_info._valid_pixel_calibration = png_get_pCAL( get_struct() , get_info() , &purpose , &this->_info._X0 , &this->_info._X1 , &this->_info._cal_type , &this->_info._num_params , &units , &params ); if( purpose ) { this->_info._purpose.append( purpose , std::strlen( purpose ) ); } if( units ) { this->_info._units.append( units , std::strlen( units ) ); } if( this->_info._num_params > 0 ) { this->_info._params.resize( this->_info._num_params ); for( png_CAL_nparam::type i = 0 ; i < this->_info._num_params ; ++i ) { this->_info._params[i].append( params[i] , std::strlen( params[i] ) ); } } } // get the physical resolution if( this->_settings._read_physical_resolution ) { this->_info._valid_resolution = png_get_pHYs( get_struct() , get_info() , &this->_info._res_x , &this->_info._res_y , &this->_info._phy_unit_type ); } // get the image resolution in pixels per meter. if( this->_settings._read_pixels_per_meter ) { this->_info._pixels_per_meter = png_get_pixels_per_meter( get_struct() , get_info() ); } // get number of significant bits for each color channel if( this->_settings._read_number_of_significant_bits ) { png_color_8p sig_bits = png_color_8p( nullptr ); this->_info._valid_significant_bits = png_get_sBIT( get_struct() , get_info() , &sig_bits ); // @todo Is there one or more colors? if( sig_bits ) { this->_info._sig_bits = sig_bits; } } #ifndef BOOST_GIL_IO_PNG_1_4_OR_LOWER #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED // get physical scale settings if( this->_settings._read_scale_factors ) { this->_info._valid_scale_factors = png_get_sCAL( get_struct() , get_info() , &this->_info._scale_unit , &this->_info._scale_width , &this->_info._scale_height ); } #else #ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED if( this->_settings._read_scale_factors ) { this->_info._valid_scale_factors = png_get_sCAL_fixed( get_struct() , get_info() , &this->_info._scale_unit , &this->_info._scale_width , &this->_info._scale_height ); } #else if( this->_settings._read_scale_factors ) { png_charp scale_width = nullptr; png_charp scale_height = nullptr; this->_info._valid_scale_factors = png_get_sCAL_s( get_struct(), get_info(), &this->_info._scale_unit, &scale_width, &scale_height); if (this->_info._valid_scale_factors) { if( scale_width ) { this->_info._scale_width.append( scale_width , std::strlen( scale_width ) ); } if( scale_height ) { this->_info._scale_height.append( scale_height , std::strlen( scale_height ) ); } } } #endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_1_4_OR_LOWER // get comments information from png_info structure if( this->_settings._read_comments ) { png_textp text = png_textp( nullptr ); this->_info._valid_text = png_get_text( get_struct() , get_info() , &text , &this->_info._num_text ); if( this->_info._num_text > 0 ) { this->_info._text.resize( this->_info._num_text ); for( png_num_text::type i = 0 ; i < this->_info._num_text ; ++i ) { this->_info._text[i]._compression = text[i].compression; this->_info._text[i]._key.append( text[i].key , std::strlen( text[i].key ) ); this->_info._text[i]._text.append( text[i].text , std::strlen( text[i].text ) ); } } } // get last modification time if( this->_settings._read_last_modification_time ) { png_timep mod_time = png_timep( nullptr ); this->_info._valid_modification_time = png_get_tIME( get_struct() , get_info() , &mod_time ); if( mod_time ) { this->_info._mod_time = mod_time; } } // get transparency data if( this->_settings._read_transparency_data ) { png_bytep trans = png_bytep ( nullptr ); png_color_16p trans_values = png_color_16p( nullptr ); this->_info._valid_transparency_factors = png_get_tRNS( get_struct() , get_info() , &trans , &this->_info._num_trans , &trans_values ); if( trans ) { //@todo What to do, here? How do I know the length of the "trans" array? } if( this->_info._num_trans ) { this->_info._trans_values.resize( this->_info._num_trans ); std::copy( trans_values , trans_values + this->_info._num_trans , &this->_info._trans_values.front() ); } } // @todo One day! / if( false ) { png_unknown_chunkp unknowns = png_unknown_chunkp( NULL ); int num_unknowns = static_cast< int >( png_get_unknown_chunks( get_struct() , get_info() , &unknowns ) ); } / } /// Check if image is large enough. void check_image_size( const point_t& img_dim ) { if( _settings._dim.x > 0 ) { if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); } } if( _settings._dim.y > 0 ) { if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); } } else { if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); } } } protected: static void read_data( png_structp png_ptr , png_bytep data , png_size_t length ) { static_cast<Device>(png_get_io_ptr(png_ptr) )->read( data , length ); } static void flush( png_structp png_ptr ) { static_cast<Device>(png_get_io_ptr(png_ptr) )->flush(); } static int read_user_chunk_callback( png_struct /* png_ptr / , png_unknown_chunkp / chunk / ) { // @todo return 0; } static void read_row_callback( png_structp / png_ptr / , png_uint_32 / row_number / , int / pass / ) { // @todo } public: Device _io_dev; image_read_settings< png_tag > _settings; image_read_info < png_tag > _info; std::size_t _scanline_length; std::size_t _number_passes; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[aV�� extension/io/png/detail/base.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNG_DETAIL_BASE_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_BASE_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <boost/assert.hpp> #include <memory> namespace boost { namespace gil { namespace detail { struct png_ptr_wrapper { png_ptr_wrapper() : _struct( nullptr ) , _info ( nullptr ) {} png_structp _struct; png_infop _info; }; /// /// Wrapper for libpng's png_struct and png_info object. Implements value semantics. /// struct png_struct_info_wrapper { protected: using png_ptr_t = std::shared_ptr<png_ptr_wrapper>; protected: /// /// Default Constructor /// png_struct_info_wrapper( bool read = true ) : _png_ptr( new png_ptr_wrapper() , ( ( read ) ? png_ptr_read_deleter : png_ptr_write_deleter ) ) {} png_ptr_wrapper get() { return _png_ptr.get(); } png_ptr_wrapper const* get() const { return _png_ptr.get(); } png_struct* get_struct() { return get()->_struct; } png_struct const* get_struct() const { return get()->_struct; } png_info* get_info() { return get()->_info; } png_info const* get_info() const { return get()->_info; } private: static void png_ptr_read_deleter( png_ptr_wrapper* png_ptr ) { if( png_ptr ) { if( png_ptr->_struct && png_ptr->_info ) { png_destroy_read_struct( &png_ptr->_struct , &png_ptr->_info , nullptr ); } delete png_ptr; png_ptr = nullptr; } } static void png_ptr_write_deleter( png_ptr_wrapper* png_ptr ) { if( png_ptr ) { if( png_ptr->_struct && png_ptr->_info ) { png_destroy_write_struct( &png_ptr->_struct , &png_ptr->_info ); } delete png_ptr; png_ptr = nullptr; } } private: png_ptr_t _png_ptr; }; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[l_nR��R��!��extension/io/png/detail/write.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_DETAIL_WRITE_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_WRITE_HPP #include <boost/gil/extension/io/png/detail/writer_backend.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif namespace detail { struct png_write_is_supported { template< typename View > struct apply : public is_write_supported< typename get_pixel_type< View >::type , png_tag > {}; }; } // namespace detail /// /// PNG Writer /// template< typename Device > class writer< Device , png_tag > : public writer_backend< Device , png_tag > { public: using backend_t = writer_backend<Device, png_tag>; writer( const Device& io_dev , const image_write_info< png_tag >& info ) : backend_t( io_dev , info ) {} template< typename View > void apply( const View& view ) { io_error_if( view.width() == 0 && view.height() == 0 , "png format cannot handle empty views." ); this->write_header( view ); write_view( view , typename is_bit_aligned< typename View::value_type >::type() ); } private: template<typename View> void write_view( const View& view , std::false_type // is bit aligned ) { using pixel_t = typename get_pixel_type<View>::type; using png_rw_info = detail::png_write_support < typename channel_type<pixel_t>::type, typename color_space_type<pixel_t>::type >; if( little_endian() ) { set_swap< png_rw_info >(); } std::vector< pixel< typename channel_type< View >::type , layout<typename color_space_type< View >::type > > > row_buffer( view.width() ); for( int y = 0; y != view.height(); ++ y) { std::copy( view.row_begin( y ) , view.row_end ( y ) , row_buffer.begin() ); png_write_row( this->get_struct() , reinterpret_cast< png_bytep >( row_buffer.data() ) ); } png_write_end( this->get_struct() , this->get_info() ); } template<typename View> void write_view( const View& view , std::true_type // is bit aligned ) { using png_rw_info = detail::png_write_support < typename kth_semantic_element_type<typename View::value_type, 0>::type, typename color_space_type<View>::type >; if (little_endian() ) { set_swap< png_rw_info >(); } detail::row_buffer_helper_view< View > row_buffer( view.width() , false ); for( int y = 0; y != view.height(); ++y ) { std::copy( view.row_begin( y ) , view.row_end ( y ) , row_buffer.begin() ); png_write_row( this->get_struct() , reinterpret_cast< png_bytep >( row_buffer.data() ) ); } png_free_data( this->get_struct() , this->get_info() , PNG_FREE_UNKN , -1 ); png_write_end( this->get_struct() , this->get_info() ); } template<typename Info> struct is_less_than_eight : mp11::mp_less < std::integral_constant<int, Info::_bit_depth>, std::integral_constant<int, 8> > {}; template<typename Info> struct is_equal_to_sixteen : mp11::mp_less < std::integral_constant<int, Info::_bit_depth>, std::integral_constant<int, 16> > {}; template <typename Info> void set_swap(typename std::enable_if<is_less_than_eight<Info>::value>::type* /ptr/ = 0) { png_set_packswap(this->get_struct()); } template <typename Info> void set_swap(typename std::enable_if<is_equal_to_sixteen<Info>::value>::type* /ptr/ = 0) { png_set_swap(this->get_struct()); } template <typename Info> void set_swap( typename std::enable_if < mp11::mp_and < mp11::mp_not<is_less_than_eight<Info>>, mp11::mp_not<is_equal_to_sixteen<Info>> >::value >::type* /ptr/ = nullptr) { } }; /// /// PNG Dynamic Image Writer /// template< typename Device > class dynamic_image_writer< Device , png_tag > : public writer< Device , png_tag > { using parent_t = writer<Device, png_tag>; public: dynamic_image_writer( const Device& io_dev , const image_write_info< png_tag >& info ) : parent_t( io_dev , info ) {} template< typename ...Views > void apply( const any_image_view< Views... >& views ) { detail::dynamic_io_fnobj< detail::png_write_is_supported , parent_t > op( this ); apply_operation( views, op ); } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[t��a��a��)��extension/io/png/detail/scanline_read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_DETAIL_SCANLINE_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_SCANLINE_READ_HPP #include <boost/gil/extension/io/png/detail/is_allowed.hpp> #include <boost/gil/extension/io/png/detail/reader_backend.hpp> #include <boost/gil.hpp> // FIXME: Include what you use! #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #include <boost/gil/io/typedefs.hpp> namespace boost { namespace gil { /// /// PNG Reader /// template< typename Device > class scanline_reader< Device , png_tag > : public reader_backend< Device , png_tag > { public: using tag_t = png_tag; using backend_t = reader_backend<Device, tag_t>; using this_t = scanline_reader<Device, tag_t>; using iterator_t = scanline_read_iterator<this_t>; // // Constructor // scanline_reader( const Device& io_dev , const image_read_settings< png_tag >& settings ) : reader_backend< Device , png_tag >( io_dev , settings ) { initialize(); } void read( byte_t* dst , int ) { read_scanline( dst ); } /// Skip over a scanline. void skip( byte_t* dst, int ) { read_scanline( dst ); } iterator_t begin() { return iterator_t( this ); } iterator_t end() { return iterator_t( this, this->_info._height ); } private: void initialize() { // Now it's time for some transformations. if( little_endian() ) { if( this->_info._bit_depth == 16 ) { // Swap bytes of 16 bit files to least significant byte first. png_set_swap( this->get()->_struct ); } if( this->_info._bit_depth < 8 ) { // swap bits of 1, 2, 4 bit packed pixel formats png_set_packswap( this->get()->_struct ); } } if( this->_info._color_type == PNG_COLOR_TYPE_PALETTE ) { png_set_palette_to_rgb( this->get()->_struct ); } if( this->_info._num_trans > 0 ) { png_set_tRNS_to_alpha( this->get()->_struct ); } // Tell libpng to handle the gamma conversion for you. The final call // is a good guess for PC generated images, but it should be configurable // by the user at run time by the user. It is strongly suggested that // your application support gamma correction. if( this->_settings._apply_screen_gamma ) { // png_set_gamma will change the image data! #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED png_set_gamma( this->get()->_struct , this->_settings._screen_gamma , this->_info._file_gamma ); #else png_set_gamma( this->get()->_struct , this->_settings._screen_gamma , this->_info._file_gamma ); #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED } // Interlaced images are not supported. this->_number_passes = png_set_interlace_handling( this->get()->_struct ); io_error_if( this->_number_passes != 1 , "scanline_read_iterator cannot read interlaced png images." ); // The above transformation might have changed the bit_depth and color type. png_read_update_info( this->get()->_struct , this->get()->_info ); this->_info._bit_depth = png_get_bit_depth( this->get()->_struct , this->get()->_info ); this->_info._num_channels = png_get_channels( this->get()->_struct , this->get()->_info ); this->_info._color_type = png_get_color_type( this->get()->_struct , this->get()->_info ); this->_scanline_length = png_get_rowbytes( this->get()->_struct , this->get()->_info ); } void read_scanline( byte_t* dst ) { png_read_row( this->get()->_struct , dst , NULL ); } }; } // namespace gil } // namespace boost #endif PK��p�[M�%�:��:�� extension/io/png/detail/read.hppnu��[��// // Copyright 2007-2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_DETAIL_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_READ_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <boost/gil/extension/io/png/detail/reader_backend.hpp> #include <boost/gil/extension/io/png/detail/is_allowed.hpp> #include <boost/gil.hpp> // FIXME: Include what you use! #include <boost/gil/io/base.hpp> #include <boost/gil/io/conversion_policies.hpp> #include <boost/gil/io/device.hpp> #include <boost/gil/io/dynamic_io_new.hpp> #include <boost/gil/io/error.hpp> #include <boost/gil/io/reader_base.hpp> #include <boost/gil/io/row_buffer_helper.hpp> #include <boost/gil/io/typedefs.hpp> #include <type_traits> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// /// PNG Reader /// template< typename Device , typename ConversionPolicy > class reader< Device , png_tag , ConversionPolicy > : public reader_base< png_tag , ConversionPolicy > , public reader_backend< Device , png_tag > { private: using this_t = reader<Device, png_tag, ConversionPolicy>; using cc_t = typename ConversionPolicy::color_converter_type; public: using backend_t = reader_backend<Device, png_tag>; public: reader( const Device& io_dev , const image_read_settings< png_tag >& settings ) : reader_base< png_tag , ConversionPolicy >() , backend_t( io_dev , settings ) {} reader( const Device& io_dev , const typename ConversionPolicy::color_converter_type& cc , const image_read_settings< png_tag >& settings ) : reader_base< png_tag , ConversionPolicy >( cc ) , backend_t( io_dev , settings ) {} template< typename View > void apply( const View& view ) { // guard from errors in the following functions if (setjmp( png_jmpbuf( this->get_struct() ))) { io_error("png is invalid"); } // The info structures are filled at this point. // Now it's time for some transformations. if( little_endian() ) { if( this->_info._bit_depth == 16 ) { // Swap bytes of 16 bit files to least significant byte first. png_set_swap( this->get_struct() ); } if( this->_info._bit_depth < 8 ) { // swap bits of 1, 2, 4 bit packed pixel formats png_set_packswap( this->get_struct() ); } } if( this->_info._color_type == PNG_COLOR_TYPE_PALETTE ) { png_set_palette_to_rgb( this->get_struct() ); } if( png_get_valid( this->get_struct(), this->get_info(), PNG_INFO_tRNS ) ) { png_set_tRNS_to_alpha( this->get_struct() ); } // Tell libpng to handle the gamma conversion for you. The final call // is a good guess for PC generated images, but it should be configurable // by the user at run time by the user. It is strongly suggested that // your application support gamma correction. if( this->_settings._apply_screen_gamma ) { // png_set_gamma will change the image data! #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED png_set_gamma( this->get_struct() , this->_settings._screen_gamma , this->_info._file_gamma ); #else png_set_gamma( this->get_struct() , this->_settings._screen_gamma , this->_info._file_gamma ); #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED } // Turn on interlace handling. REQUIRED if you are not using // png_read_image(). To see how to handle interlacing passes, // see the png_read_row() method below: this->_number_passes = png_set_interlace_handling( this->get_struct() ); // The above transformation might have changed the bit_depth and color type. png_read_update_info( this->get_struct() , this->get_info() ); this->_info._bit_depth = png_get_bit_depth( this->get_struct() , this->get_info() ); this->_info._num_channels = png_get_channels( this->get_struct() , this->get_info() ); this->_info._color_type = png_get_color_type( this->get_struct() , this->get_info() ); this->_scanline_length = png_get_rowbytes( this->get_struct() , this->get_info() ); switch( this->_info._color_type ) { case PNG_COLOR_TYPE_GRAY: { switch( this->_info._bit_depth ) { case 1: read_rows< gray1_image_t::view_t::reference >( view ); break; case 2: read_rows< gray2_image_t::view_t::reference >( view ); break; case 4: read_rows< gray4_image_t::view_t::reference >( view ); break; case 8: read_rows< gray8_pixel_t >( view ); break; case 16: read_rows< gray16_pixel_t >( view ); break; default: io_error( "png_reader::read_data(): unknown combination of color type and bit depth" ); } break; } case PNG_COLOR_TYPE_GA: { #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA switch( this->_info._bit_depth ) { case 8: read_rows< gray_alpha8_pixel_t > ( view ); break; case 16: read_rows< gray_alpha16_pixel_t >( view ); break; default: io_error( "png_reader::read_data(): unknown combination of color type and bit depth" ); } #else io_error( "gray_alpha isn't enabled. Define BOOST_GIL_IO_ENABLE_GRAY_ALPHA when building application." ); #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA break; } case PNG_COLOR_TYPE_RGB: { switch( this->_info._bit_depth ) { case 8: read_rows< rgb8_pixel_t > ( view ); break; case 16: read_rows< rgb16_pixel_t >( view ); break; default: io_error( "png_reader::read_data(): unknown combination of color type and bit depth" ); } break; } case PNG_COLOR_TYPE_RGBA: { switch( this->_info._bit_depth ) { case 8: read_rows< rgba8_pixel_t > ( view ); break; case 16: read_rows< rgba16_pixel_t >( view ); break; default: io_error( "png_reader_color_convert::read_data(): unknown combination of color type and bit depth" ); } break; } default: io_error( "png_reader_color_convert::read_data(): unknown color type" ); } // read rest of file, and get additional chunks in info_ptr png_read_end( this->get_struct() , nullptr ); } private: template< typename ImagePixel , typename View > void read_rows( const View& view ) { // guard from errors in the following functions if (setjmp( png_jmpbuf( this->get_struct() ))) { io_error("png is invalid"); } using row_buffer_helper_t = detail::row_buffer_helper_view<ImagePixel>; using it_t = typename row_buffer_helper_t::iterator_t; using is_read_and_convert_t = typename std::is_same < ConversionPolicy, detail::read_and_no_convert >::type; io_error_if( !detail::is_allowed< View >( this->_info , is_read_and_convert_t() ) , "Image types aren't compatible." ); std::size_t rowbytes = png_get_rowbytes( this->get_struct() , this->get_info() ); row_buffer_helper_t buffer( rowbytes , true ); png_bytep row_ptr = (png_bytep)( &( buffer.data()[0])); for( std::size_t pass = 0; pass < this->_number_passes; pass++ ) { if( pass == this->_number_passes - 1 ) { // skip lines if necessary for( std::ptrdiff_t y = 0; y < this->_settings._top_left.y; ++y ) { // Read the image using the "sparkle" effect. png_read_rows( this->get_struct() , &row_ptr , nullptr , 1 ); } for( std::ptrdiff_t y = 0 ; y < this->_settings._dim.y ; ++y ) { // Read the image using the "sparkle" effect. png_read_rows( this->get_struct() , &row_ptr , nullptr , 1 ); it_t first = buffer.begin() + this->_settings._top_left.x; it_t last = first + this->_settings._dim.x; // one after last element this->_cc_policy.read( first , last , view.row_begin( y )); } // Read the rest of the image. libpng needs that. std::ptrdiff_t remaining_rows = static_cast< std::ptrdiff_t >( this->_info._height ) - this->_settings._top_left.y - this->_settings._dim.y; for( std::ptrdiff_t y = 0 ; y < remaining_rows ; ++y ) { // Read the image using the "sparkle" effect. png_read_rows( this->get_struct() , &row_ptr , nullptr , 1 ); } } else { for( int y = 0; y < view.height(); ++y ) { // Read the image using the "sparkle" effect. png_read_rows( this->get_struct() , &row_ptr , nullptr , 1 ); } } } } }; namespace detail { struct png_type_format_checker { png_type_format_checker( png_bitdepth::type bit_depth , png_color_type::type color_type ) : _bit_depth ( bit_depth ) , _color_type( color_type ) {} template< typename Image > bool apply() { using is_supported_t = is_read_supported < typename get_pixel_type<typename Image::view_t>::type, png_tag >; return is_supported_t::_bit_depth == _bit_depth && is_supported_t::_color_type == _color_type; } private: png_bitdepth::type _bit_depth; png_color_type::type _color_type; }; struct png_read_is_supported { template< typename View > struct apply : public is_read_supported< typename get_pixel_type< View >::type , png_tag > {}; }; } // namespace detail /// /// PNG Dynamic Image Reader /// template< typename Device > class dynamic_image_reader< Device , png_tag > : public reader< Device , png_tag , detail::read_and_no_convert > { using parent_t = reader < Device, png_tag, detail::read_and_no_convert >; public: dynamic_image_reader( const Device& io_dev , const image_read_settings< png_tag >& settings ) : parent_t( io_dev , settings ) {} template< typename ...Images > void apply( any_image< Images... >& images ) { detail::png_type_format_checker format_checker( this->_info._bit_depth , this->_info._color_type ); if( !construct_matched( images , format_checker )) { io_error( "No matching image type between those of the given any_image and that of the file" ); } else { this->init_image( images , this->_settings ); detail::dynamic_io_fnobj< detail::png_read_is_supported , parent_t > op( this ); apply_operation( view( images ) , op ); } } }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[p#U"�A��A����extension/io/png/detail/writer_backend.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_IO_PNG_DETAIL_WRITER_BACKEND_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_WRITER_BACKEND_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <boost/gil/extension/io/png/detail/base.hpp> #include <boost/gil/extension/io/png/detail/supported_types.hpp> #include <boost/gil/io/base.hpp> #include <boost/gil/io/typedefs.hpp> namespace boost { namespace gil { #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #pragma warning(disable:4611) //interaction between '_setjmp' and C++ object destruction is non-portable #endif /// /// PNG Writer Backend /// template< typename Device > struct writer_backend< Device , png_tag > : public detail::png_struct_info_wrapper { private: using this_t = writer_backend<Device, png_tag>; public: using format_tag_t = png_tag; /// /// Constructor /// writer_backend( const Device& io_dev , const image_write_info< png_tag >& info ) : png_struct_info_wrapper( false ) , _io_dev( io_dev ) , _info( info ) { // Create and initialize the png_struct with the desired error handler // functions. If you want to use the default stderr and longjump method, // you can supply NULL for the last three parameters. We also check that // the library version is compatible with the one used at compile time, // in case we are using dynamically linked libraries. REQUIRED. get()->_struct = png_create_write_struct( PNG_LIBPNG_VER_STRING , nullptr // user_error_ptr , nullptr // user_error_fn , nullptr // user_warning_fn ); io_error_if( get_struct() == nullptr , "png_writer: fail to call png_create_write_struct()" ); // Allocate/initialize the image information data. REQUIRED get()->_info = png_create_info_struct( get_struct() ); if( get_info() == nullptr ) { png_destroy_write_struct( &get()->_struct , nullptr ); io_error( "png_writer: fail to call png_create_info_struct()" ); } // Set error handling. REQUIRED if you aren't supplying your own // error handling functions in the png_create_write_struct() call. if( setjmp( png_jmpbuf( get_struct() ))) { //free all of the memory associated with the png_ptr and info_ptr png_destroy_write_struct( &get()->_struct , &get()->_info ); io_error( "png_writer: fail to call setjmp()" ); } init_io( get_struct() ); } protected: template< typename View > void write_header( const View& view ) { using png_rw_info_t = detail::png_write_support < typename channel_type<typename get_pixel_type<View>::type>::type, typename color_space_type<View>::type >; // Set the image information here. Width and height are up to 2^31, // bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on // the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, // PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, // or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or // PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST // currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED png_set_IHDR( get_struct() , get_info() , static_cast< png_image_width::type >( view.width() ) , static_cast< png_image_height::type >( view.height() ) , static_cast< png_bitdepth::type >( png_rw_info_t::_bit_depth ) , static_cast< png_color_type::type >( png_rw_info_t::_color_type ) , _info._interlace_method , _info._compression_type , _info._filter_method ); #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED if( _info._valid_cie_colors ) { png_set_cHRM( get_struct() , get_info() , _info._white_x , _info._white_y , _info._red_x , _info._red_y , _info._green_x , _info._green_y , _info._blue_x , _info._blue_y ); } if( _info._valid_file_gamma ) { png_set_gAMA( get_struct() , get_info() , _info._file_gamma ); } #else if( _info._valid_cie_colors ) { png_set_cHRM_fixed( get_struct() , get_info() , _info._white_x , _info._white_y , _info._red_x , _info._red_y , _info._green_x , _info._green_y , _info._blue_x , _info._blue_y ); } if( _info._valid_file_gamma ) { png_set_gAMA_fixed( get_struct() , get_info() , _info._file_gamma ); } #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED if( _info._valid_icc_profile ) { #if PNG_LIBPNG_VER_MINOR >= 5 png_set_iCCP( get_struct() , get_info() , const_cast< png_charp >( _info._icc_name.c_str() ) , _info._iccp_compression_type , reinterpret_cast< png_const_bytep >( & (_info._profile.front ()) ) , _info._profile_length ); #else png_set_iCCP( get_struct() , get_info() , const_cast< png_charp >( _info._icc_name.c_str() ) , _info._iccp_compression_type , const_cast< png_charp >( & (_info._profile.front()) ) , _info._profile_length ); #endif } if( _info._valid_intent ) { png_set_sRGB( get_struct() , get_info() , _info._intent ); } if( _info._valid_palette ) { png_set_PLTE( get_struct() , get_info() , const_cast< png_colorp >( &_info._palette.front() ) , _info._num_palette ); } if( _info._valid_background ) { png_set_bKGD( get_struct() , get_info() , const_cast< png_color_16p >( &_info._background ) ); } if( _info._valid_histogram ) { png_set_hIST( get_struct() , get_info() , const_cast< png_uint_16p >( &_info._histogram.front() ) ); } if( _info._valid_offset ) { png_set_oFFs( get_struct() , get_info() , _info._offset_x , _info._offset_y , _info._off_unit_type ); } if( _info._valid_pixel_calibration ) { std::vector< const char > params( _info._num_params ); for( std::size_t i = 0; i < params.size(); ++i ) { params[i] = _info._params[ i ].c_str(); } png_set_pCAL( get_struct() , get_info() , const_cast< png_charp >( _info._purpose.c_str() ) , _info._X0 , _info._X1 , _info._cal_type , _info._num_params , const_cast< png_charp >( _info._units.c_str() ) , const_cast< png_charpp >( &params.front() ) ); } if( _info._valid_resolution ) { png_set_pHYs( get_struct() , get_info() , _info._res_x , _info._res_y , _info._phy_unit_type ); } if( _info._valid_significant_bits ) { png_set_sBIT( get_struct() , get_info() , const_cast< png_color_8p >( &_info._sig_bits ) ); } #ifndef BOOST_GIL_IO_PNG_1_4_OR_LOWER #ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED if( _info._valid_scale_factors ) { png_set_sCAL( get_struct() , get_info() , this->_info._scale_unit , this->_info._scale_width , this->_info._scale_height ); } #else #ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED if( _info._valid_scale_factors ) { png_set_sCAL_fixed( get_struct() , get_info() , this->_info._scale_unit , this->_info._scale_width , this->_info._scale_height ); } #else if( _info._valid_scale_factors ) { png_set_sCAL_s( get_struct() , get_info() , this->_info._scale_unit , const_cast< png_charp >( this->_info._scale_width.c_str() ) , const_cast< png_charp >( this->_info._scale_height.c_str() ) ); } #endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED #endif // BOOST_GIL_IO_PNG_1_4_OR_LOWER if( _info._valid_text ) { std::vector< png_text > texts( _info._num_text ); for( std::size_t i = 0; i < texts.size(); ++i ) { png_text pt; pt.compression = _info._text[i]._compression; pt.key = const_cast< png_charp >( this->_info._text[i]._key.c_str() ); pt.text = const_cast< png_charp >( this->_info._text[i]._text.c_str() ); pt.text_length = _info._text[i]._text.length(); texts[i] = pt; } png_set_text( get_struct() , get_info() , &texts.front() , _info._num_text ); } if( _info._valid_modification_time ) { png_set_tIME( get_struct() , get_info() , const_cast< png_timep >( &_info._mod_time ) ); } if( _info._valid_transparency_factors ) { int sample_max = ( 1u << _info._bit_depth ); /* libpng doesn't reject a tRNS chunk with out-of-range samples / if( !( ( _info._color_type == PNG_COLOR_TYPE_GRAY && (int) _info._trans_values[0].gray > sample_max ) \|\| ( _info._color_type == PNG_COLOR_TYPE_RGB &&( (int) _info._trans_values[0].red > sample_max \|\| (int) _info._trans_values[0].green > sample_max \|\| (int) _info._trans_values[0].blue > sample_max ) ) ) ) { //@todo Fix that once reading transparency values works / png_set_tRNS( get_struct() , get_info() , trans , num_trans , trans_values ); / } } // Compression Levels - valid values are [0,9] png_set_compression_level( get_struct() , _info._compression_level ); png_set_compression_mem_level( get_struct() , _info._compression_mem_level ); png_set_compression_strategy( get_struct() , _info._compression_strategy ); png_set_compression_window_bits( get_struct() , _info._compression_window_bits ); png_set_compression_method( get_struct() , _info._compression_method ); png_set_compression_buffer_size( get_struct() , _info._compression_buffer_size ); #ifdef BOOST_GIL_IO_PNG_DITHERING_SUPPORTED // Dithering if( _info._set_dithering ) { png_set_dither( get_struct() , &_info._dithering_palette.front() , _info._dithering_num_palette , _info._dithering_maximum_colors , &_info._dithering_histogram.front() , _info._full_dither ); } #endif // BOOST_GIL_IO_PNG_DITHERING_SUPPORTED // Filter if( _info._set_filter ) { png_set_filter( get_struct() , 0 , _info._filter ); } // Invert Mono if( _info._invert_mono ) { png_set_invert_mono( get_struct() ); } // True Bits if( _info._set_true_bits ) { png_set_sBIT( get_struct() , get_info() , &_info._true_bits.front() ); } // sRGB Intent if( _info._set_srgb_intent ) { png_set_sRGB( get_struct() , get_info() , _info._srgb_intent ); } // Strip Alpha if( _info._strip_alpha ) { png_set_strip_alpha( get_struct() ); } // Swap Alpha if( _info._swap_alpha ) { png_set_swap_alpha( get_struct() ); } png_write_info( get_struct() , get_info() ); } protected: static void write_data( png_structp png_ptr , png_bytep data , png_size_t length ) { static_cast< Device >( png_get_io_ptr( png_ptr ))->write( data , length ); } static void flush( png_structp png_ptr ) { static_cast< Device* >(png_get_io_ptr(png_ptr) )->flush(); } private: void init_io( png_structp png_ptr ) { png_set_write_fn( png_ptr , static_cast< void* > ( &this->_io_dev ) , static_cast< png_rw_ptr > ( &this_t::write_data ) , static_cast< png_flush_ptr >( &this_t::flush ) ); } public: Device _io_dev; image_write_info< png_tag > _info; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace gil } // namespace boost #endif PK��p�[G�/�3��3��+��extension/io/png/detail/supported_types.hppnu��[��// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_DETAIL_SUPPORTED_TYPES_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_SUPPORTED_TYPES_HPP #include <boost/gil/extension/io/png/tags.hpp> #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA #include <boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp> #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA #include <cstddef> #include <type_traits> namespace boost { namespace gil { namespace detail { static const size_t PNG_BYTES_TO_CHECK = 4; // Read support template< png_bitdepth::type BitDepth , png_color_type::type ColorType > struct png_rw_support_base { static const png_bitdepth::type _bit_depth = BitDepth; static const png_color_type::type _color_type = ColorType; }; template< typename Channel , typename ColorSpace > struct png_read_support : read_support_false , png_rw_support_base< 1 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_read_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > , gray_t > : read_support_true , png_rw_support_base< 1 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_read_support< packed_dynamic_channel_reference< BitField , 2 , Mutable > , gray_t > : read_support_true , png_rw_support_base< 2 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_read_support< packed_dynamic_channel_reference< BitField , 4 , Mutable > , gray_t > : read_support_true , png_rw_support_base< 4 , PNG_COLOR_TYPE_GRAY > {}; template<> struct png_read_support<uint8_t , gray_t > : read_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_GRAY > {}; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_read_support<uint8_t , gray_alpha_t > : read_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_GA > {}; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_read_support<uint8_t , rgb_t > : read_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_RGB > {}; template<> struct png_read_support<uint8_t , rgba_t > : read_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_RGBA > {}; template<> struct png_read_support<uint16_t , gray_t > : read_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_GRAY > {}; template<> struct png_read_support<uint16_t , rgb_t > : read_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_RGB > {}; template<> struct png_read_support<uint16_t , rgba_t > : read_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_RGBA > {}; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_read_support<uint16_t , gray_alpha_t > : read_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_GA > {}; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA // Write support template< typename Channel , typename ColorSpace > struct png_write_support : write_support_false , png_rw_support_base< 1 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > , gray_t > : write_support_true , png_rw_support_base< 1 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 1 , Mutable > const , gray_t > : write_support_true , png_rw_support_base< 1 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 2 , Mutable > , gray_t > : write_support_true , png_rw_support_base< 2 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 2 , Mutable > const , gray_t > : write_support_true , png_rw_support_base< 2 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 4 , Mutable > , gray_t > : write_support_true , png_rw_support_base< 4 , PNG_COLOR_TYPE_GRAY > {}; template< typename BitField , bool Mutable > struct png_write_support< packed_dynamic_channel_reference< BitField , 4 , Mutable > const , gray_t > : write_support_true , png_rw_support_base< 4 , PNG_COLOR_TYPE_GRAY > {}; template<> struct png_write_support<uint8_t , gray_t > : write_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_GRAY > {}; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_write_support<uint8_t , gray_alpha_t > : write_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_GA > {}; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_write_support<uint8_t , rgb_t > : write_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_RGB > {}; template<> struct png_write_support<uint8_t , rgba_t > : write_support_true , png_rw_support_base< 8 , PNG_COLOR_TYPE_RGBA > {}; template<> struct png_write_support<uint16_t , gray_t > : write_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_GRAY > {}; template<> struct png_write_support<uint16_t , rgb_t > : write_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_RGB > {}; template<> struct png_write_support<uint16_t , rgba_t > : write_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_RGBA > {}; #ifdef BOOST_GIL_IO_ENABLE_GRAY_ALPHA template<> struct png_write_support<uint16_t , gray_alpha_t > : write_support_true , png_rw_support_base< 16 , PNG_COLOR_TYPE_GA > {}; #endif // BOOST_GIL_IO_ENABLE_GRAY_ALPHA } // namespace detail template<typename Pixel> struct is_read_supported<Pixel, png_tag> : std::integral_constant < bool, detail::png_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::png_read_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const png_bitdepth::type _bit_depth = parent_t::_bit_depth; static const png_color_type::type _color_type = parent_t::_color_type; }; template<typename Pixel> struct is_write_supported<Pixel, png_tag> : std::integral_constant < bool, detail::png_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >::is_supported > { using parent_t = detail::png_write_support < typename channel_type<Pixel>::type, typename color_space_type<Pixel>::type >; static const png_bitdepth::type _bit_depth = parent_t::_bit_depth; static const png_color_type::type _color_type = parent_t::_color_type; }; } // namespace gil } // namespace boost #endif PK��p�[ϝo-��-��&��extension/io/png/detail/is_allowed.hppnu��[��// // Copyright 2008 Christian Henning, Lubomir Bourdev // // 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_EXTENSION_IO_PNG_DETAIL_IS_ALLOWED_HPP #define BOOST_GIL_EXTENSION_IO_PNG_DETAIL_IS_ALLOWED_HPP #include <boost/gil/extension/io/png/tags.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template< typename View > bool is_allowed( const image_read_info< png_tag >& info , std::true_type // is read_and_no_convert ) { using pixel_t = typename get_pixel_type<View>::type; using channel_t = typename channel_traits<typename element_type<pixel_t>::type>::value_type; const png_num_channels::type dst_num_channels = num_channels< pixel_t >::value; const png_bitdepth::type dst_bit_depth = detail::unsigned_integral_num_bits< channel_t >::value; return dst_num_channels == info._num_channels && dst_bit_depth == info._bit_depth; } template< typename View > bool is_allowed( const image_read_info< png_tag >& /* info / , std::false_type // is read_and_convert ) { return true; } } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[7vX�V��V��extension/io/png/read.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_PNG_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNG_READ_HPP #define BOOST_GIL_EXTENSION_IO_PNG_READ_ENABLED // TODO: Document, explain, review #include <boost/gil/extension/io/png/tags.hpp> #include <boost/gil/extension/io/png/detail/read.hpp> #include <boost/gil/extension/io/png/detail/scanline_read.hpp> #include <boost/gil/extension/io/png/detail/supported_types.hpp> #include <boost/gil/io/get_reader.hpp> #include <boost/gil/io/make_backend.hpp> #include <boost/gil/io/make_dynamic_image_reader.hpp> #include <boost/gil/io/make_reader.hpp> #include <boost/gil/io/make_scanline_reader.hpp> #include <boost/gil/io/read_and_convert_image.hpp> #include <boost/gil/io/read_and_convert_view.hpp> #include <boost/gil/io/read_image.hpp> #include <boost/gil/io/read_image_info.hpp> #include <boost/gil/io/read_view.hpp> #include <boost/gil/io/scanline_read_iterator.hpp> #endif PK��p�[j��ӑ��extension/io/png/old.hppnu��[��// // Copyright 2007-2008 Christian Henning // // 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_EXTENSION_IO_PNG_OLD_HPP #define BOOST_GIL_EXTENSION_IO_PNG_OLD_HPP #include <boost/gil/extension/io/png.hpp> namespace boost { namespace gil { /// \ingroup PNG_IO /// \brief Returns the width and height of the PNG file at the specified location. /// Throws std::ios_base::failure if the location does not correspond to a valid PNG file template<typename String> inline point_t png_read_dimensions(String const& filename) { using backend_t = typename get_reader_backend<String, png_tag>::type; backend_t backend = read_image_info(filename, png_tag()); return { static_cast<std::ptrdiff_t>(backend._info._width), static_cast<std::ptrdiff_t>(backend._info._height) }; } /// \ingroup PNG_IO /// \brief Loads the image specified by the given png image file name into the given view. /// Triggers a compile assert if the view color space and channel depth are not supported by the PNG library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid PNG file, or if its color space or channel depth are not /// compatible with the ones specified by View, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void png_read_view( const String& filename , const View& view ) { read_view( filename , view , png_tag() ); } /// \ingroup PNG_IO /// \brief Allocates a new image whose dimensions are determined by the given png image file, and loads the pixels into it. /// Triggers a compile assert if the image color space or channel depth are not supported by the PNG library or by the I/O extension. /// Throws std::ios_base::failure if the file is not a valid PNG file, or if its color space or channel depth are not /// compatible with the ones specified by Image template< typename String , typename Image > inline void png_read_image( const String& filename , Image& img ) { read_image( filename , img , png_tag() ); } /// \ingroup PNG_IO /// \brief Loads the image specified by the given png image file name and color-converts it into the given view. /// Throws std::ios_base::failure if the file is not a valid PNG file, or if its dimensions don't match the ones of the view. template< typename String , typename View , typename CC > inline void png_read_and_convert_view( const String& filename , const View& view , CC cc ) { read_and_convert_view( filename , view , cc , png_tag() ); } /// \ingroup PNG_IO /// \brief Loads the image specified by the given png image file name and color-converts it into the given view. /// Throws std::ios_base::failure if the file is not a valid PNG file, or if its dimensions don't match the ones of the view. template< typename String , typename View > inline void png_read_and_convert_view( const String& filename , const View& view ) { read_and_convert_view( filename , view , png_tag() ); } /// \ingroup PNG_IO /// \brief Allocates a new image whose dimensions are determined by the given png image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid PNG file template< typename String , typename Image , typename CC > inline void png_read_and_convert_image( const String& filename , Image& img , CC cc ) { read_and_convert_image( filename , img , cc , png_tag() ); } /// \ingroup PNG_IO /// \brief Allocates a new image whose dimensions are determined by the given png image file, loads and color-converts the pixels into it. /// Throws std::ios_base::failure if the file is not a valid PNG file template< typename String , typename Image > inline void png_read_and_convert_image( const String filename , Image& img ) { read_and_convert_image( filename , img , png_tag() ); } /// \ingroup PNG_IO /// \brief Saves the view to a png file specified by the given png image file name. /// Triggers a compile assert if the view color space and channel depth are not supported by the PNG library or by the I/O extension. /// Throws std::ios_base::failure if it fails to create the file. template< typename String , typename View > inline void png_write_view( const String& filename , const View& view ) { write_view( filename , view , png_tag() ); } } // namespace gil } // namespace boost #endif PK��p�[.�d��extension/io/targa.hppnu��[��// // Copyright 2010 Kenneth Riddile // // 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_EXTENSION_IO_TARGA_HPP #define BOOST_GIL_EXTENSION_IO_TARGA_HPP #include <boost/gil/extension/io/targa/read.hpp> #include <boost/gil/extension/io/targa/write.hpp> #endif PK��p�[�]ٕ��$��extension/toolbox/dynamic_images.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_EXTENSION_TOOLBOX_DYNAMIC_IMAGES_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_DYNAMIC_IMAGES_HPP #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp> namespace boost { namespace gil { // need this for various meta functions. struct any_image_pixel_t {}; struct any_image_channel_t {}; struct any_image_color_space_t {}; template<> struct color_space_type< any_image_pixel_t > { using type = any_image_color_space_t; }; }} // namespace boost::gil #endif PK��p�[j��7��extension/toolbox/color_converters/rgb_to_luminance.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_COLOR_CONVERTERS_RGB_TO_LUMINANCE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_RGB_TO_LUMINANCE_HPP #include <boost/gil/color_convert.hpp> namespace boost{ namespace gil { namespace detail { /// - performance specialization double /// - to eliminate compiler warning 4244 template <typename GrayChannelValue> struct rgb_to_luminance_fn< double, double, double, GrayChannelValue > { GrayChannelValue operator()( const double& red , const double& green , const double& blue ) const { return channel_convert<GrayChannelValue>( red 0.30 + green * 0.59 + blue * 0.11 ); } }; } // namespace detail } // namespace gil } // namespace boost #endif PK��p�[3~G��3��extension/toolbox/color_converters/gray_to_rgba.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP #include <boost/gil/color_convert.hpp> namespace boost{ namespace gil { /// This one is missing in gil ( color_convert.hpp ). template <> struct default_color_converter_impl<gray_t,rgba_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,red_t()) = channel_convert<typename color_element_type<P2, red_t >::type>(get_color(src,gray_color_t())); get_color(dst,green_t())= channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t())); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2, blue_t >::type>(get_color(src,gray_color_t())); using channel_t = typename channel_type<P2>::type; get_color(dst,alpha_t()) = channel_traits< channel_t >::max_value(); } }; }} // namespace boost::gil #endif PK��p�[��SE��E��(��extension/toolbox/color_spaces/cmyka.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_CMYKA_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_CMYKA_HPP #include <boost/gil/cmyk.hpp> #include <boost/gil/color_convert.hpp> #include <boost/gil/rgba.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { /// \ingroup ColorSpaceModel using cmyka_t = mp11::mp_list<cyan_t, magenta_t, yellow_t, black_t, alpha_t>; /// \ingroup LayoutModel using cmyka_layout_t = layout<cmyka_t>; BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, cmyka) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, cmyka) ///// \ingroup ColorConvert ///// \brief Converting CMYKA to any pixel type. Note: Supports homogeneous pixels only. //template <typename C2> //struct default_color_converter_impl<cmyka_t,C2> { // template <typename P1, typename P2> // void operator()(const P1& src, P2& dst) const { // using T1 = typename channel_type<P1>::type; // default_color_converter_impl<cmyk_t,C2>()( // pixel<T1,cmyk_layout_t>(channel_multiply(get_color(src,cyan_t()), get_color(src,alpha_t())), // channel_multiply(get_color(src,magenta_t()),get_color(src,alpha_t())), // channel_multiply(get_color(src,yellow_t()), get_color(src,alpha_t())), // channel_multiply(get_color(src,black_t()), get_color(src,alpha_t()))) // ,dst); // } //}; template <> struct default_color_converter_impl<cmyka_t,rgba_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { using T1 = typename channel_type<P1>::type; default_color_converter_impl<cmyk_t,rgba_t>()( pixel<T1,cmyk_layout_t>(get_color(src,cyan_t()), get_color(src,magenta_t()), get_color(src,yellow_t()), get_color(src,black_t())) ,dst); } }; /// \ingroup ColorConvert /// \brief Unfortunately CMYKA to CMYKA must be explicitly provided - otherwise we get ambiguous specialization error. template <> struct default_color_converter_impl<cmyka_t,cmyka_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { static_for_each(src,dst,default_channel_converter()); } }; } // namespace gil } // namespace boost #endif PK��p�[Siv��&��extension/toolbox/color_spaces/xyz.hppnu��[��// // Copyright 2012 Chung-Lin Wen, Davide Anastasia // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP #include <boost/gil/color_convert.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { /// \addtogroup ColorNameModel /// \{ namespace xyz_color_space { /// \brief x Color Component struct x_t {}; /// \brief y Color Component struct y_t {}; /// \brief z Color Component struct z_t {}; } /// \} /// \ingroup ColorSpaceModel using xyz_t = mp11::mp_list < xyz_color_space::x_t, xyz_color_space::y_t, xyz_color_space::z_t >; /// \ingroup LayoutModel using xyz_layout_t = layout<xyz_t>; BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, xyz) /// \ingroup ColorConvert /// \brief RGB to XYZ /// <a href="http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html">Link</a> /// \note rgb_t is assumed to be sRGB D65 template <> struct default_color_converter_impl< rgb_t, xyz_t > { private: BOOST_FORCEINLINE float32_t inverse_companding(float32_t sample) const { if ( sample > 0.04045f ) { return powf((( sample + 0.055f ) / 1.055f ), 2.4f); } else { return ( sample / 12.92f ); } } public: template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace xyz_color_space; float32_t red( inverse_companding( channel_convert<float32_t>(get_color(src, red_t())))); float32_t green( inverse_companding( channel_convert<float32_t>(get_color(src, green_t())))); float32_t blue( inverse_companding( channel_convert<float32_t>(get_color(src, blue_t())))); get_color( dst, x_t() ) = red * 0.4124564f + green * 0.3575761f + blue * 0.1804375f; get_color( dst, y_t() ) = red * 0.2126729f + green * 0.7151522f + blue * 0.0721750f; get_color( dst, z_t() ) = red * 0.0193339f + green * 0.1191920f + blue * 0.9503041f; } }; /// \ingroup ColorConvert /// \brief XYZ to RGB template <> struct default_color_converter_impl<xyz_t,rgb_t> { private: BOOST_FORCEINLINE float32_t companding(float32_t sample) const { if ( sample > 0.0031308f ) { return ( 1.055f * powf( sample, 1.f/2.4f ) - 0.055f ); } else { return ( 12.92f * sample ); } } public: template <typename P1, typename P2> void operator()( const P1& src, P2& dst) const { using namespace xyz_color_space; // Note: ideally channel_convert should be compiled out, because xyz_t // is float32_t natively only float32_t x( channel_convert<float32_t>( get_color( src, x_t() ) ) ); float32_t y( channel_convert<float32_t>( get_color( src, y_t() ) ) ); float32_t z( channel_convert<float32_t>( get_color( src, z_t() ) ) ); get_color(dst,red_t()) = channel_convert<typename color_element_type<P2, red_t>::type>( companding( x * 3.2404542f + y * -1.5371385f + z * -0.4985314f ) ); get_color(dst,green_t()) = channel_convert<typename color_element_type<P2, green_t>::type>( companding( x * -0.9692660f + y * 1.8760108f + z * 0.0415560f ) ); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2, blue_t>::type>( companding( x * 0.0556434f + y * -0.2040259f + z * 1.0572252f ) ); } }; } // namespace gil } // namespace boost #endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP PK��p�[=��X��&��extension/toolbox/color_spaces/lab.hppnu��[��// // Copyright 2012 Chung-Lin Wen // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_LAB_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_LAB_HPP #include <boost/gil/extension/toolbox/color_spaces/xyz.hpp> #include <boost/gil/color_convert.hpp> #include <boost/gil.hpp> // FIXME: Include what you use, not everything, even in extensions! #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { /// \addtogroup ColorNameModel /// \{ namespace lab_color_space { /// \brief Luminance struct luminance_t {}; /// \brief a Color Component struct a_color_opponent_t {}; /// \brief b Color Component struct b_color_opponent_t {}; } /// \} /// \ingroup ColorSpaceModel using lab_t = mp11::mp_list < lab_color_space::luminance_t, lab_color_space::a_color_opponent_t, lab_color_space::b_color_opponent_t >; /// \ingroup LayoutModel using lab_layout_t = layout<lab_t>; BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, lab) /// \ingroup ColorConvert /// \brief LAB to XYZ template <> struct default_color_converter_impl< lab_t, xyz_t > { template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace lab_color_space; using namespace xyz_color_space; float32_t p = ((get_color(src, luminance_t()) + 16.f)/116.f); get_color(dst, y_t()) = 1.f * powf(p, 3.f); get_color(dst, x_t()) = 0.95047f * powf((p + (get_color(src, a_color_opponent_t())/500.f) ), 3.f); get_color(dst, z_t()) = 1.08883f * powf((p - (get_color(src, b_color_opponent_t())/200.f) ), 3.f); } }; /// \ingroup ColorConvert /// \brief XYZ to LAB /// \note I assume \c xyz_t template <> struct default_color_converter_impl< xyz_t, lab_t > { private: /// \ref http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_Lab.html BOOST_FORCEINLINE float32_t forward_companding(float32_t value) const { if (value > 216.f/24389.f) { return powf(value, 1.f/3.f); } else { return ((24389.f/27.f * value + 16.f)/116.f); } } public: template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace lab_color_space; float32_t f_y = forward_companding( channel_convert<float32_t>( get_color(src, xyz_color_space::y_t()) ) // / 1.f ); float32_t f_x = forward_companding( channel_convert<float32_t>( get_color(src, xyz_color_space::x_t()) ) * (1.f / 0.95047f) // if the compiler is smart, it should // precalculate this, no? ); float32_t f_z = forward_companding( channel_convert<float32_t>( get_color(src, xyz_color_space::z_t()) ) * (1.f / 1.08883f) // if the compiler is smart, it should // precalculate this, no? ); get_color(dst, luminance_t()) = 116.f * f_y - 16.f; get_color(dst, a_color_opponent_t()) = 500.f * (f_x - f_y); get_color(dst, b_color_opponent_t()) = 200.f * (f_y - f_z); } }; /// \ingroup ColorConvert /// \brief RGB to LAB template <> struct default_color_converter_impl< rgb_t, lab_t > { template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace lab_color_space; xyz32f_pixel_t xyz32f_temp_pixel; default_color_converter_impl<rgb_t, xyz_t>()(src, xyz32f_temp_pixel); default_color_converter_impl<xyz_t, lab_t>()(xyz32f_temp_pixel, dst); } }; /// \ingroup ColorConvert /// \brief LAB to RGB template <> struct default_color_converter_impl<lab_t,rgb_t> { template <typename P1, typename P2> void operator()( const P1& src, P2& dst) const { using namespace lab_color_space; xyz32f_pixel_t xyz32f_temp_pixel; default_color_converter_impl<lab_t, xyz_t>()(src, xyz32f_temp_pixel); default_color_converter_impl<xyz_t, rgb_t>()(xyz32f_temp_pixel, dst); } }; } // namespace gil } // namespace boost #endif PK��p�[��"��"��(��extension/toolbox/color_spaces/ycbcr.hppnu��[��// // Copyright 2013 Juan V. Puertos G-Cluster, Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_YCBCR_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_YCBCR_HPP #include <boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp> #include <boost/gil/color_convert.hpp> #include <boost/gil.hpp> // FIXME: Include what you use! #include <boost/gil/detail/mp11.hpp> #include <boost/config.hpp> #include <cstdint> #include <type_traits> namespace boost { namespace gil { /// \addtogroup ColorNameModel /// \{ namespace ycbcr_601_color_space { /// \brief Luminance struct y_t {}; /// \brief Blue chrominance component struct cb_t {}; /// \brief Red chrominance component struct cr_t {}; } namespace ycbcr_709_color_space { /// \brief Luminance struct y_t {}; /// \brief Blue chrominance component struct cb_t {}; /// \brief Red chrominance component struct cr_t {}; } /// \} /// \ingroup ColorSpaceModel using ycbcr_601__t = mp11::mp_list < ycbcr_601_color_space::y_t, ycbcr_601_color_space::cb_t, ycbcr_601_color_space::cr_t >; /// \ingroup ColorSpaceModel using ycbcr_709__t = mp11::mp_list < ycbcr_709_color_space::y_t, ycbcr_709_color_space::cb_t, ycbcr_709_color_space::cr_t >; /// \ingroup LayoutModel using ycbcr_601__layout_t = boost::gil::layout<ycbcr_601__t>; using ycbcr_709__layout_t = boost::gil::layout<ycbcr_709__t>; //The channel depth is ALWAYS 8bits ofr YCbCr! BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, ycbcr_601_) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, ycbcr_709_) namespace detail { // Source:boost/algorithm/clamp.hpp template<typename T> BOOST_CXX14_CONSTEXPR T const& clamp( T const& val, typename boost::mp11::mp_identity<T>::type const & lo, typename boost::mp11::mp_identity<T>::type const & hi) { // assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal auto const p = std::less<T>(); return p(val, lo) ? lo : p(hi, val) ? hi : val; } } // namespace detail /* * 601 Source: http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion * 709 Source: http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.709_conversion * (using values coming directly from ITU-R BT.601 recommendation) * (using values coming directly from ITU-R BT.709 recommendation) / /* * @brief Convert YCbCr ITU.BT-601 to RGB. / template<> struct default_color_converter_impl<ycbcr_601__t, rgb_t> { // Note: the RGB_t channels range can be set later on by the users. We dont want to cast to uint8_t or anything here. template < typename SRCP, typename DSTP > void operator()( const SRCP& src, DSTP& dst ) const { using dst_channel_t = typename channel_type<DSTP>::type; convert(src, dst, typename std::is_same < std::integral_constant<int, sizeof(dst_channel_t)>, std::integral_constant<int, 1> >::type()); } private: // optimization for bit8 channels template< typename Src_Pixel , typename Dst_Pixel > void convert( const Src_Pixel& src , Dst_Pixel& dst , std::true_type // is 8 bit channel ) const { using namespace ycbcr_601_color_space; using src_channel_t = typename channel_type<Src_Pixel>::type; using dst_channel_t = typename channel_type<Dst_Pixel>::type; src_channel_t y = channel_convert<src_channel_t>( get_color(src, y_t())); src_channel_t cb = channel_convert<src_channel_t>( get_color(src, cb_t())); src_channel_t cr = channel_convert<src_channel_t>( get_color(src, cr_t())); // The intermediate results of the formulas require at least 16bits of precission. std::int_fast16_t c = y - 16; std::int_fast16_t d = cb - 128; std::int_fast16_t e = cr - 128; std::int_fast16_t red = detail::clamp((( 298 c + 409 * e + 128) >> 8), 0, 255); std::int_fast16_t green = detail::clamp((( 298 * c - 100 * d - 208 * e + 128) >> 8), 0, 255); std::int_fast16_t blue = detail::clamp((( 298 * c + 516 * d + 128) >> 8), 0, 255); get_color( dst, red_t() ) = (dst_channel_t) red; get_color( dst, green_t() ) = (dst_channel_t) green; get_color( dst, blue_t() ) = (dst_channel_t) blue; } template< typename Src_Pixel , typename Dst_Pixel > void convert( const Src_Pixel& src , Dst_Pixel& dst , std::false_type // is 8 bit channel ) const { using namespace ycbcr_601_color_space; using dst_channel_t = typename channel_type<Dst_Pixel>::type; double y = get_color( src, y_t() ); double cb = get_color( src, cb_t() ); double cr = get_color( src, cr_t() ); get_color(dst, red_t()) = static_cast<dst_channel_t>( detail::clamp(1.6438 * (y - 16.0) + 1.5960 * (cr -128.0), 0.0, 255.0)); get_color(dst, green_t()) = static_cast<dst_channel_t>( detail::clamp(1.6438 * (y - 16.0) - 0.3917 * (cb - 128.0) + 0.8129 * (cr -128.0), 0.0, 255.0)); get_color(dst, blue_t()) = static_cast<dst_channel_t>( detail::clamp(1.6438 * ( y - 16.0 ) - 2.0172 * ( cb -128.0 ), 0.0, 255.0)); } }; /* * Source: http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion * digital Y'CbCr derived from digital R'dG'dB'd 8 bits per sample, each using the full range. * with NO footroom wither headroom. / /* * @brief Convert RGB to YCbCr ITU.BT-601. / template<> struct default_color_converter_impl<rgb_t, ycbcr_601__t> { template < typename SRCP, typename DSTP > void operator()( const SRCP& src, DSTP& dst ) const { using namespace ycbcr_601_color_space; using src_channel_t = typename channel_type<SRCP>::type; using dst_channel_t = typename channel_type<DSTP>::type; src_channel_t red = channel_convert<src_channel_t>( get_color(src, red_t())); src_channel_t green = channel_convert<src_channel_t>( get_color(src, green_t())); src_channel_t blue = channel_convert<src_channel_t>( get_color(src, blue_t())); double y = 16.0 + 0.2567 red + 0.5041 * green + 0.0979 * blue; double cb = 128.0 - 0.1482 * red - 0.2909 * green + 0.4392 * blue; double cr = 128.0 + 0.4392 * red - 0.3677 * green - 0.0714 * blue; get_color( dst, y_t() ) = (dst_channel_t) y; get_color( dst, cb_t() ) = (dst_channel_t) cb; get_color( dst, cr_t() ) = (dst_channel_t) cr; } }; /** * @brief Convert RGB to YCbCr ITU.BT-709. / template<> struct default_color_converter_impl<rgb_t, ycbcr_709__t> { template < typename SRCP, typename DSTP > void operator()( const SRCP& src, DSTP& dst ) const { using namespace ycbcr_709_color_space; using src_channel_t = typename channel_type<SRCP>::type; using dst_channel_t = typename channel_type<DSTP>::type; src_channel_t red = channel_convert<src_channel_t>( get_color(src, red_t())); src_channel_t green = channel_convert<src_channel_t>( get_color(src, green_t())); src_channel_t blue = channel_convert<src_channel_t>( get_color(src, blue_t())); double y = 0.299 red + 0.587 * green + 0.114 * blue; double cb = 128.0 - 0.168736 * red - 0.331264 * green + 0.5 * blue; double cr = 128.0 + 0.5 * red - 0.418688 * green - 0.081312 * blue; get_color( dst, y_t() ) = (dst_channel_t) y; get_color( dst, cb_t() ) = (dst_channel_t) cb; get_color( dst, cr_t() ) = (dst_channel_t) cr; } }; /** * @brief Convert RGB to YCbCr ITU.BT-709. / template<> struct default_color_converter_impl<ycbcr_709__t, rgb_t> { template < typename SRCP, typename DSTP > void operator()( const SRCP& src, DSTP& dst ) const { using namespace ycbcr_709_color_space; using src_channel_t = typename channel_type<SRCP>::type; using dst_channel_t = typename channel_type<DSTP>::type; src_channel_t y = channel_convert<src_channel_t>( get_color(src, y_t()) ); src_channel_t cb_clipped = channel_convert<src_channel_t>( get_color(src, cb_t()) - 128 ); src_channel_t cr_clipped = channel_convert<src_channel_t>( get_color(src, cr_t()) - 128 ); double red = y + 1.042 cr_clipped; double green = y - 0.34414 * cb_clipped - 0.71414 * cr_clipped; double blue = y + 1.772 * cb_clipped; get_color( dst, red_t() ) = (dst_channel_t) red; get_color( dst, green_t() ) = (dst_channel_t) green; get_color( dst, blue_t() ) = (dst_channel_t) blue; } }; } // namespace gil } // namespace boost #endif PK��p�[]�/P^��^��&��extension/toolbox/color_spaces/hsl.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_HSL_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSL_HPP #include <boost/gil/color_convert.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { /// \addtogroup ColorNameModel /// \{ namespace hsl_color_space { /// \brief Hue struct hue_t {}; /// \brief Saturation struct saturation_t {}; /// \brief Lightness struct lightness_t {}; } /// \} /// \ingroup ColorSpaceModel using hsl_t = mp11::mp_list < hsl_color_space::hue_t, hsl_color_space::saturation_t, hsl_color_space::lightness_t >; /// \ingroup LayoutModel using hsl_layout_t = layout<hsl_t>; BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, hsl) /// \ingroup ColorConvert /// \brief RGB to HSL template <> struct default_color_converter_impl< rgb_t, hsl_t > { template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace hsl_color_space; // only float32_t for hsl is supported float32_t temp_red = channel_convert<float32_t>( get_color( src, red_t() )); float32_t temp_green = channel_convert<float32_t>( get_color( src, green_t() )); float32_t temp_blue = channel_convert<float32_t>( get_color( src, blue_t() )); float32_t hue, saturation, lightness; float32_t min_color = (std::min)( temp_red, (std::min)( temp_green, temp_blue )); float32_t max_color = (std::max)( temp_red, (std::max)( temp_green, temp_blue )); if( std::abs( min_color - max_color ) < 0.001 ) { // rgb color is gray hue = 0.f; saturation = 0.f; // doesn't matter which rgb channel we use. lightness = temp_red; } else { float32_t diff = max_color - min_color; // lightness calculation lightness = ( min_color + max_color ) / 2.f; // saturation calculation if( lightness < 0.5f ) { saturation = diff / ( min_color + max_color ); } else { saturation = ( max_color - min_color ) / ( 2.f - diff ); } // hue calculation if( std::abs( max_color - temp_red ) < 0.0001f ) { // max_color is red hue = ( temp_green - temp_blue ) / diff; } else if( std::abs( max_color - temp_green) < 0.0001f ) { // max_color is green // 2.0 + (b - r) / (maxColor - minColor); hue = 2.f + ( temp_blue - temp_red ) / diff; } else { // max_color is blue hue = 4.f + ( temp_red - temp_blue ) / diff; } hue /= 6.f; if( hue < 0.f ) { hue += 1.f; } } get_color( dst,hue_t() ) = hue; get_color( dst,saturation_t() ) = saturation; get_color( dst,lightness_t() ) = lightness; } }; /// \ingroup ColorConvert /// \brief HSL to RGB template <> struct default_color_converter_impl<hsl_t,rgb_t> { template <typename P1, typename P2> void operator()( const P1& src, P2& dst) const { using namespace hsl_color_space; float32_t red, green, blue; if( std::abs( get_color( src, saturation_t() )) < 0.0001 ) { // If saturation is 0, the color is a shade of gray red = get_color( src, lightness_t() ); green = get_color( src, lightness_t() ); blue = get_color( src, lightness_t() ); } else { float temp1, temp2; float tempr, tempg, tempb; //Set the temporary values if( get_color( src, lightness_t() ) < 0.5 ) { temp2 = get_color( src, lightness_t() ) * ( 1.f + get_color( src, saturation_t() ) ); } else { temp2 = ( get_color( src, lightness_t() ) + get_color( src, saturation_t() )) - ( get_color( src, lightness_t() ) * get_color( src, saturation_t() )); } temp1 = 2.f * get_color( src, lightness_t() ) - temp2; tempr = get_color( src, hue_t() ) + 1.f / 3.f; if( tempr > 1.f ) { tempr--; } tempg = get_color( src, hue_t() ); tempb = get_color( src, hue_t() ) - 1.f / 3.f; if( tempb < 0.f ) { tempb++; } //Red if( tempr < 1.f / 6.f ) { red = temp1 + ( temp2 - temp1 ) * 6.f * tempr; } else if( tempr < 0.5f ) { red = temp2; } else if( tempr < 2.f / 3.f ) { red = temp1 + (temp2 - temp1) * (( 2.f / 3.f ) - tempr) * 6.f; } else { red = temp1; } //Green if( tempg < 1.f / 6.f ) { green = temp1 + ( temp2 - temp1 ) * 6.f * tempg; } else if( tempg < 0.5f ) { green = temp2; } else if( tempg < 2.f / 3.f ) { green = temp1 + ( temp2 - temp1 ) * (( 2.f / 3.f ) - tempg) * 6.f; } else { green = temp1; } //Blue if( tempb < 1.f / 6.f ) { blue = temp1 + (temp2 - temp1) * 6.f * tempb; } else if( tempb < 0.5f ) { blue = temp2; } else if( tempb < 2.f / 3.f ) { blue = temp1 + (temp2 - temp1) * (( 2.f / 3.f ) - tempb) * 6.f; } else { blue = temp1; } } get_color(dst,red_t()) = channel_convert<typename color_element_type< P2, red_t >::type>( red ); get_color(dst,green_t())= channel_convert<typename color_element_type< P2, green_t >::type>( green ); get_color(dst,blue_t()) = channel_convert<typename color_element_type< P2, blue_t >::type>( blue ); } }; } // namespace gil } // namespace boost #endif PK��p�[J='/��/��&��extension/toolbox/color_spaces/hsv.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_HSV_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSV_HPP #include <boost/numeric/conversion/cast.hpp> #include <boost/gil/color_convert.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/mp11.hpp> #include <algorithm> #include <cmath> namespace boost{ namespace gil { /// \addtogroup ColorNameModel /// \{ namespace hsv_color_space { /// \brief Hue struct hue_t {}; /// \brief Saturation struct saturation_t{}; /// \brief Value struct value_t {}; } /// \} /// \ingroup ColorSpaceModel using hsv_t = mp11::mp_list < hsv_color_space::hue_t, hsv_color_space::saturation_t, hsv_color_space::value_t >; /// \ingroup LayoutModel using hsv_layout_t = layout<hsv_t>; BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, hsv) /// \ingroup ColorConvert /// \brief RGB to HSV template <> struct default_color_converter_impl< rgb_t, hsv_t > { template <typename P1, typename P2> void operator()( const P1& src, P2& dst ) const { using namespace hsv_color_space; // only float32_t for hsv is supported float32_t temp_red = channel_convert<float32_t>( get_color( src, red_t() )); float32_t temp_green = channel_convert<float32_t>( get_color( src, green_t() )); float32_t temp_blue = channel_convert<float32_t>( get_color( src, blue_t() )); float32_t hue, saturation, value; float32_t min_color = (std::min)( temp_red, (std::min)( temp_green, temp_blue )); float32_t max_color = (std::max)( temp_red, (std::max)( temp_green, temp_blue )); value = max_color; float32_t diff = max_color - min_color; if( max_color < 0.0001f ) { saturation = 0.f; } else { saturation = diff / max_color; } if( saturation < 0.0001f ) { //it doesn't matter what value it has hue = 0.f; } else { if( (std::abs)( boost::numeric_cast<float32_t>(temp_red - max_color) ) < 0.0001f ) { hue = ( temp_green - temp_blue ) / diff; } else if( temp_green >= max_color ) // means == but >= avoids compiler warning; color is never greater than max { hue = 2.f + ( temp_blue - temp_red ) / diff; } else { hue = 4.f + ( temp_red - temp_green ) / diff; } //to bring it to a number between 0 and 1 hue /= 6.f; if( hue < 0.f ) { hue++; } } get_color( dst, hue_t() ) = hue; get_color( dst, saturation_t() ) = saturation; get_color( dst, value_t() ) = value; } }; /// \ingroup ColorConvert /// \brief HSV to RGB template <> struct default_color_converter_impl<hsv_t,rgb_t> { template <typename P1, typename P2> void operator()( const P1& src, P2& dst) const { using namespace hsv_color_space; float32_t red, green, blue; //If saturation is 0, the color is a shade of gray if (std::abs(get_color(src, saturation_t())) < 0.0001f) { // If saturation is 0, the color is a shade of gray red = get_color( src, value_t() ); green = get_color( src, value_t() ); blue = get_color( src, value_t() ); } else { float32_t frac, p, q, t, h; uint32_t i; //to bring hue to a number between 0 and 6, better for the calculations h = get_color( src, hue_t() ); h = 6.f; i = static_cast<uint32_t>(floor(h)); frac = h - i; p = get_color( src, value_t() ) ( 1.f - get_color( src, saturation_t() )); q = get_color( src, value_t() ) * ( 1.f - ( get_color( src, saturation_t() ) * frac )); t = get_color( src, value_t() ) * ( 1.f - ( get_color( src, saturation_t() ) * ( 1.f - frac ))); switch( i ) { case 0: { red = get_color( src, value_t() ); green = t; blue = p; break; } case 1: { red = q; green = get_color( src, value_t() ); blue = p; break; } case 2: { red = p; green = get_color( src, value_t() ); blue = t; break; } case 3: { red = p; green = q; blue = get_color( src, value_t() ); break; } case 4: { red = t; green = p; blue = get_color( src, value_t() ); break; } case 5: { red = get_color( src, value_t() ); green = p; blue = q; break; } } } get_color(dst,red_t()) = channel_convert<typename color_element_type< P2, red_t >::type>( red ); get_color(dst,green_t())= channel_convert<typename color_element_type< P2, green_t >::type>( green ); get_color(dst,blue_t()) = channel_convert<typename color_element_type< P2, blue_t >::type>( blue ); } }; } // namespace gil } // namespace boost #endif PK��p�[M��!��!��-��extension/toolbox/color_spaces/gray_alpha.hppnu��[��// // Copyright 2012 Andreas Pokorny // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_GRAY_ALPHA_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_GRAY_ALPHA_HPP #include <boost/gil/color_convert.hpp> #include <boost/gil/gray.hpp> #include <boost/gil/typedefs.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { using gray_alpha_t = mp11::mp_list<gray_color_t,alpha_t>; using gray_alpha_layout_t = layout<gray_alpha_t>; using alpha_gray_layout_t = layout<gray_alpha_layout_t, mp11::mp_list_c<int,1,0>>; BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, alpha_gray) BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, alpha_gray) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, gray_alpha) BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, gray_alpha) /// \ingroup ColorConvert /// \brief Gray Alpha to RGBA template <> struct default_color_converter_impl<gray_alpha_t,rgba_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,red_t()) = channel_convert<typename color_element_type<P2, red_t>::type>(get_color(src,gray_color_t())); get_color(dst,green_t())= channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t())); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2, blue_t>::type>(get_color(src,gray_color_t())); get_color(dst,alpha_t()) = channel_convert<typename color_element_type<P2, alpha_t>::type>(get_color(src,alpha_t())); } }; /// \brief Gray Alpha to RGB template <> struct default_color_converter_impl<gray_alpha_t,rgb_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,red_t()) = channel_convert<typename color_element_type<P2, red_t>::type>( channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) ); get_color(dst,green_t()) = channel_convert<typename color_element_type<P2, green_t>::type>( channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) ); get_color(dst,blue_t()) = channel_convert<typename color_element_type<P2, blue_t>::type>( channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) ); } }; /// \brief Gray Alpha to Gray template <> struct default_color_converter_impl<gray_alpha_t,gray_t> { template <typename P1, typename P2> void operator()(const P1& src, P2& dst) const { get_color(dst,gray_color_t()) = channel_convert<typename color_element_type<P2, gray_color_t>::type>( channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) ); } }; } // namespace gil } // namespace boost #endif PK��p�[��o��!��extension/toolbox/image_types.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_IMAGE_TYPES_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IMAGE_TYPES_HPP #include <boost/gil/extension/toolbox/image_types/indexed_image.hpp> #endif PK��p�[^V{��.��extension/toolbox/metafunctions/is_similar.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_SIMILAR_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_SIMILAR_HPP #include <boost/gil/channel.hpp> #include <type_traits> namespace boost{ namespace gil { /// is_similar metafunctions /// \brief Determines if two pixel types are similar. template<typename A, typename B> struct is_similar : std::false_type {}; template<typename A> struct is_similar<A, A> : std::true_type {}; template<typename B,int I, int S, bool M, int I2> struct is_similar < packed_channel_reference<B, I, S, M>, packed_channel_reference<B, I2, S, M> > : std::true_type {}; }} // namespace boost::gil #endif PK��p�[ܟ7��2��extension/toolbox/metafunctions/is_bit_aligned.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_BIT_ALIGNED_TYPE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_BIT_ALIGNED_TYPE_HPP #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <type_traits> namespace boost{ namespace gil { /// is_bit_aligned metafunctions /// \brief Determines whether the given type is bit_aligned. template< typename PixelRef > struct is_bit_aligned : std::false_type {}; template <typename B, typename C, typename L, bool M> struct is_bit_aligned<bit_aligned_pixel_reference<B, C, L, M>> : std::true_type {}; template <typename B, typename C, typename L, bool M> struct is_bit_aligned<bit_aligned_pixel_reference<B, C, L, M> const> : std::true_type {}; template <typename B, typename C, typename L> struct is_bit_aligned<packed_pixel<B, C, L>> : std::true_type {}; template <typename B, typename C, typename L> struct is_bit_aligned<packed_pixel<B, C, L> const> : std::true_type {}; }} // namespace boost::gil #endif PK��p�[��d [ ��[ ��0��extension/toolbox/metafunctions/channel_type.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_CHANNEL_TYPE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_CHANNEL_TYPE_HPP #include <boost/gil/extension/toolbox/dynamic_images.hpp> #include <boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp> #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <boost/gil/channel.hpp> #include <boost/gil/detail/mp11.hpp> #include <boost/utility/enable_if.hpp> // boost::lazy_enable_if namespace boost{ namespace gil { /// channel_type metafunction /// \brief Generates the channel type for template <typename B, typename C, typename L, bool M> struct gen_chan_ref { using type = packed_dynamic_channel_reference < B, mp11::mp_at_c<C, 0>::value, M >; }; //! This implementation works for bit_algined_pixel_reference //! with a homogeneous channel layout. //! The result type will be a packed_dynamic_channel_reference, since the //! offset info will be missing. // bit_aligned_pixel_reference template <typename B, typename C, typename L, bool M> struct channel_type< bit_aligned_pixel_reference<B,C,L,M> > : lazy_enable_if< is_homogeneous< bit_aligned_pixel_reference< B, C, L, M > > , gen_chan_ref< B, C, L, M > > {}; template <typename B, typename C, typename L, bool M> struct channel_type<const bit_aligned_pixel_reference<B,C,L,M> > : lazy_enable_if< is_homogeneous< bit_aligned_pixel_reference< B, C, L, M > > , gen_chan_ref< B, C, L, M > > {}; template <typename B, typename C, typename L> struct gen_chan_ref_p { using type = packed_dynamic_channel_reference < B, get_num_bits<mp11::mp_at_c<C, 0>>::value, true >; }; // packed_pixel template < typename BitField , typename ChannelRefs , typename Layout > struct channel_type< packed_pixel< BitField , ChannelRefs , Layout > > : lazy_enable_if< is_homogeneous< packed_pixel< BitField , ChannelRefs , Layout > > , gen_chan_ref_p< BitField , ChannelRefs , Layout > > {}; template <typename B, typename C, typename L> struct channel_type< const packed_pixel< B, C, L > > : lazy_enable_if< is_homogeneous<packed_pixel< B, C, L > > , gen_chan_ref_p< B, C, L > > {}; template<> struct channel_type< any_image_pixel_t > { using type = any_image_channel_t; }; } // namespace gil } // namespace boost #endif PK��p�[��0Az��z��2��extension/toolbox/metafunctions/get_pixel_type.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_PIXEL_TYPE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_PIXEL_TYPE_HPP #include <boost/gil/extension/toolbox/dynamic_images.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp> #include <boost/gil/detail/mp11.hpp> namespace boost{ namespace gil { /// get_pixel_type metafunction /// \brief Depending on Image this function generates either /// the pixel type or the reference type in case /// the image is bit_aligned. template<typename View> struct get_pixel_type { using type = mp11::mp_if < is_bit_aligned<typename View::value_type>, typename View::reference, typename View::value_type >; }; template<typename ...Views> struct get_pixel_type<any_image_view<Views...>> { using type = any_image_pixel_t; }; }} // namespace boost::gil #endif PK��p�[�YI��I��0��extension/toolbox/metafunctions/get_num_bits.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_NUM_BITS_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_NUM_BITS_HPP #include <boost/gil/channel.hpp> #include <boost/gil/detail/is_channel_integral.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// get_num_bits metafunctions /// \brief Determines the numbers of bits for the given channel type. template <typename T, class = void> struct get_num_bits; template<typename B, int I, int S, bool M> struct get_num_bits<packed_channel_reference<B, I, S, M>> : std::integral_constant<int, S> {}; template<typename B, int I, int S, bool M> struct get_num_bits<packed_channel_reference<B, I, S, M> const> : std::integral_constant<int, S> {}; template<typename B, int I, bool M> struct get_num_bits<packed_dynamic_channel_reference<B, I, M>> : std::integral_constant<int, I> {}; template<typename B, int I, bool M> struct get_num_bits<packed_dynamic_channel_reference<B, I, M> const> : std::integral_constant<int, I> {}; template<int N> struct get_num_bits<packed_channel_value<N>> : std::integral_constant<int, N> {}; template<int N> struct get_num_bits<packed_channel_value<N> const> : std::integral_constant<int, N> {}; template <typename T> struct get_num_bits < T, typename std::enable_if < mp11::mp_and < detail::is_channel_integral<T>, mp11::mp_not<std::is_class<T>> >::value >::type > : std::integral_constant<std::size_t, sizeof(T) * 8> {}; }} // namespace boost::gil #endif PK��p�[x��2��extension/toolbox/metafunctions/is_homogeneous.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_HOMOGENEOUS_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_HOMOGENEOUS_HPP #include <boost/gil/pixel.hpp> #include <boost/gil/detail/mp11.hpp> #include <type_traits> namespace boost{ namespace gil { /// is_homogeneous metafunctions /// \brief Determines if a pixel types are homogeneous. template<typename C,typename CMP, int Next, int Last> struct is_homogeneous_impl; template<typename C, typename CMP, int Last> struct is_homogeneous_impl<C, CMP, Last, Last> : std::true_type {}; template<typename C, typename CMP, int Next, int Last> struct is_homogeneous_impl : mp11::mp_and < is_homogeneous_impl<C, CMP, Next + 1, Last>, std::is_same<CMP, mp11::mp_at_c<C, Next>> > {}; template <typename P> struct is_homogeneous : std::false_type {}; // pixel template <typename C, typename L> struct is_homogeneous<pixel<C, L>> : std::true_type {}; template <typename C, typename L > struct is_homogeneous<pixel<C, L> const> : std::true_type {}; template <typename C, typename L> struct is_homogeneous<pixel<C, L>&> : std::true_type {}; template <typename C, typename L> struct is_homogeneous<pixel<C, L> const&> : std::true_type {}; // planar pixel reference template <typename Channel, typename ColorSpace> struct is_homogeneous<planar_pixel_reference<Channel, ColorSpace>> : std::true_type {}; template <typename Channel, typename ColorSpace> struct is_homogeneous<planar_pixel_reference<Channel, ColorSpace> const> : std::true_type {}; template<typename C, typename CMP, int I, int Last> struct is_homogeneous_impl_p {}; // for packed_pixel template <typename B, typename C, typename L> struct is_homogeneous<packed_pixel<B, C, L>> : is_homogeneous_impl_p < C, mp11::mp_at_c<C, 0>, 1, mp11::mp_size<C>::value > {}; template< typename B , typename C , typename L > struct is_homogeneous<packed_pixel<B, C, L> const> : is_homogeneous_impl_p < C, mp11::mp_at_c<C, 0>, 1, mp11::mp_size<C>::value > {}; // for bit_aligned_pixel_reference template <typename B, typename C, typename L, bool M> struct is_homogeneous<bit_aligned_pixel_reference<B, C, L, M>> : is_homogeneous_impl<C, mp11::mp_at_c<C, 0>, 1, mp11::mp_size<C>::value> {}; template <typename B, typename C, typename L, bool M> struct is_homogeneous<const bit_aligned_pixel_reference<B, C, L, M> > : is_homogeneous_impl<C, mp11::mp_at_c<C, 0>, 1, mp11::mp_size<C>::value> {}; }} // namespace boost::gil #endif PK��p�["��2��extension/toolbox/metafunctions/pixel_bit_size.hppnu��[��// // Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_PIXEL_BIT_SIZE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_PIXEL_BIT_SIZE_HPP #include <boost/gil/bit_aligned_pixel_reference.hpp> #include <boost/gil/packed_pixel.hpp> namespace boost{ namespace gil { /// pixel_bit_size metafunctions /// \brief Accumulates the all channel size. /// /// \code /// using image_t = bit_aligned_image5_type<16, 16, 16, 8, 8, devicen_layout_t<5>>::type; /// const int size = pixel_bit_size<image_t::view_t::reference>::value; /// \endcode template< typename PixelRef> struct pixel_bit_size : std::integral_constant<int, 0> {}; template <typename B, typename C, typename L, bool M> struct pixel_bit_size<bit_aligned_pixel_reference<B, C, L, M>> : mp11::mp_fold < C, std::integral_constant<int, 0>, mp11::mp_plus > {}; template <typename B, typename C, typename L, bool M> struct pixel_bit_size<bit_aligned_pixel_reference<B, C, L, M> const> : mp11::mp_fold < C, std::integral_constant<int, 0>, mp11::mp_plus > {}; template <typename B, typename C, typename L> struct pixel_bit_size<packed_pixel<B, C, L>> : mp11::mp_fold < C, std::integral_constant<int, 0>, mp11::mp_plus > {}; template <typename B, typename C, typename L> struct pixel_bit_size<const packed_pixel<B,C,L> > : mp11::mp_fold < C, std::integral_constant<int, 0>, mp11::mp_plus > {}; }} // namespace boost::gil #endif PK��p�[�3����0��extension/toolbox/metafunctions/channel_view.hppnu��[��// // Copyright 2010 Fabien Castan, Christian Henning // // 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_EXTENSION_TOOLBOX_CHANNEL_VIEW_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_CHANNEL_VIEW_HPP #include <boost/gil/image_view_factory.hpp> namespace boost { namespace gil { template <typename Channel, typename View> struct channel_type_to_index { static constexpr int value = detail::type_to_index < typename color_space_type<View>::type, // color (Boost.MP11-compatible list) Channel // channel type >::value; // index of the channel in the color (Boost.MP11-compatible list) }; template<typename Channel, typename View> struct channel_view_type : kth_channel_view_type < channel_type_to_index<Channel, View>::value, View > { static constexpr int index = channel_type_to_index < Channel, View >::value; using parent_t = kth_channel_view_type<index, View>; using type = typename parent_t::type; static type make( const View& src ) { return parent_t::make( src ); } }; /// \ingroup ImageViewTransformationsKthChannel template<typename Channel, typename View> auto channel_view(View const& src) -> typename channel_view_type<Channel, View>::type { return channel_view_type<Channel, View>::make(src); } }} // namespace boost::gil #endif PK��p�[N��"��extension/toolbox/color_spaces.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_SPACES_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HPP #include <boost/gil/extension/toolbox/color_spaces/cmyka.hpp> #include <boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp> #include <boost/gil/extension/toolbox/color_spaces/hsl.hpp> #include <boost/gil/extension/toolbox/color_spaces/hsv.hpp> #include <boost/gil/extension/toolbox/color_spaces/lab.hpp> #include <boost/gil/extension/toolbox/color_spaces/xyz.hpp> #endif PK��p�[�K�M��M��extension/toolbox/toolbox.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_TOOLBOX_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_TOOLBOX_HPP #include <boost/gil/extension/toolbox/color_converters.hpp> #include <boost/gil/extension/toolbox/color_spaces.hpp> #include <boost/gil/extension/toolbox/dynamic_images.hpp> #include <boost/gil/extension/toolbox/image_types.hpp> #include <boost/gil/extension/toolbox/metafunctions.hpp> #endif PK��p�[[��lL��lL��1��extension/toolbox/image_types/subchroma_image.hppnu��[��// // Copyright 2013 Christian Henning and Juan V. Puertos // // 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_EXTENSION_TOOLBOX_IMAGE_TYPES_SUBCHROMA_IMAGE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_IMAGE_TYPES_SUBCHROMA_IMAGE_HPP #include <boost/gil/dynamic_step.hpp> #include <boost/gil/image.hpp> #include <boost/gil/image_view.hpp> #include <boost/gil/point.hpp> #include <boost/gil/virtual_locator.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> #include <memory> #include <type_traits> namespace boost { namespace gil { namespace detail { template< int J, int A, int B> struct scaling_factors { static_assert(std::integral_constant<int, J>::value == 4, ""); static_assert( std::integral_constant<int, A>::value == 4 \|\| std::integral_constant<int, A>::value == 2 \|\| std::integral_constant<int, A>::value == 1, ""); static_assert( std::integral_constant<int, B>::value == 4 \|\| std::integral_constant<int, B>::value == 2 \|\| std::integral_constant<int, B>::value == 1 \|\| std::integral_constant<int, B>::value == 0, ""); static constexpr int ss_X = std::integral_constant<int, J>::value / std::integral_constant<int, A>::value; static constexpr int ss_Y = mp11::mp_if_c < std::integral_constant<int, B>::value == 0, std::integral_constant<int, 2>, mp11::mp_if_c < std::integral_constant<int, A>::value == std::integral_constant<int, B>::value, std::integral_constant<int, 1>, std::integral_constant<int, 4> > >::value; }; } // namespace detail //////////////////////////////////////////////////////////////////////////////////////// /// \class subchroma_image_deref_fn /// \ingroup PixelLocatorModel PixelBasedModel /// \brief Used for virtual_2D_locator /// //////////////////////////////////////////////////////////////////////////////////////// template< typename Locator , typename Factors > struct subchroma_image_deref_fn { using plane_locator_t = gray8_view_t::locator; using const_t = subchroma_image_deref_fn<Locator, Factors>; using value_type = typename Locator::value_type; using reference = value_type; using const_reference = value_type; using argument_type = point_t; using result_type = reference; static const bool is_mutable = false; /// default constructor subchroma_image_deref_fn() {} /// constructor subchroma_image_deref_fn( const plane_locator_t& y_locator , const plane_locator_t& v_locator , const plane_locator_t& u_locator ) : _y_locator( y_locator ) , _v_locator( v_locator ) , _u_locator( u_locator ) {} /// operator() result_type operator()( const point_t& p ) const { using scaling_factors_t = detail::scaling_factors < mp11::mp_at_c<Factors, 0>::value, mp11::mp_at_c<Factors, 1>::value, mp11::mp_at_c<Factors, 2>::value >; plane_locator_t y = _y_locator.xy_at( p ); plane_locator_t v = _v_locator.xy_at( p.x / scaling_factors_t::ss_X, p.y / scaling_factors_t::ss_X ); plane_locator_t u = _u_locator.xy_at( p.x / scaling_factors_t::ss_X, p.y / scaling_factors_t::ss_X ); return value_type( at_c< 0 >( y ) , at_c< 0 >( v ) , at_c< 0 >( u ) ); } /// const plane_locator_t& y_locator() const { return _y_locator; } const plane_locator_t& v_locator() const { return _v_locator; } const plane_locator_t& u_locator() const { return _u_locator; } private: plane_locator_t _y_locator; plane_locator_t _v_locator; plane_locator_t _u_locator; }; //////////////////////////////////////////////////////////////////////////////////////// /// \class subchroma_image_locator_type /// \ingroup PixelLocatorModel PixelBasedModel /// \brief /// //////////////////////////////////////////////////////////////////////////////////////// template< typename Locator , typename Factors > struct subchroma_image_locator { using type = virtual_2d_locator < subchroma_image_deref_fn<Locator, Factors>, // Deref false // IsTransposed >; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template < typename Locator, typename Factors > struct channel_type< subchroma_image_locator< Locator, Factors > > : public channel_type< typename subchroma_image_locator< Locator, Factors >::type > {}; template < typename Locator, typename Factors > struct color_space_type< subchroma_image_locator< Locator, Factors > > : public color_space_type< typename subchroma_image_locator< Locator, Factors >::type > {}; template < typename Locator, typename Factors > struct channel_mapping_type< subchroma_image_locator< Locator, Factors > > : public channel_mapping_type< typename subchroma_image_locator< Locator, Factors >::type > {}; template < typename Locator, typename Factors > struct is_planar< subchroma_image_locator< Locator, Factors > > : public is_planar< typename subchroma_image_locator< Locator, Factors >::type > {}; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct dynamic_x_step_type< subchroma_image_locator< Locator, Factors > > { using type = typename subchroma_image_locator<Locator, Factors>::type; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct dynamic_y_step_type< subchroma_image_locator< Locator, Factors > > { using type = typename subchroma_image_locator<Locator, Factors>::type; }; ///////////////////////////// // HasTransposedTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct transposed_type< subchroma_image_locator< Locator, Factors > > { using type = typename subchroma_image_locator<Locator, Factors>::type; }; ////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////// /// \class subchroma_image_view /// \ingroup ImageViewModel PixelBasedModel /// \brief A lightweight object that interprets a subchroma image. /// //////////////////////////////////////////////////////////////////////////////////////// template < typename Locator, typename Factors = mp11::mp_list_c<int, 4, 4, 4> > class subchroma_image_view : public image_view<Locator> { public: using locator = Locator; using deref_fn_t = typename locator::deref_fn_t; using plane_locator_t = typename deref_fn_t::plane_locator_t; using const_t = subchroma_image_view<Locator, Factors>; using plane_view_t = image_view<plane_locator_t>; /// default constructor subchroma_image_view() : image_view< Locator >() {} /// constructor subchroma_image_view( const point_t& y_dimensions , const point_t& v_dimensions , const point_t& u_dimensions , const Locator& locator ) : image_view< Locator >( y_dimensions, locator ) , _y_dimensions( y_dimensions ) , _v_dimensions( v_dimensions ) , _u_dimensions( u_dimensions ) {} /// copy constructor template< typename Subchroma_View > subchroma_image_view( const Subchroma_View& v ) : image_view< locator >( v ) {} const point_t& v_ssfactors() const { return point_t( get_deref_fn().vx_ssfactor(), get_deref_fn().vx_ssfactor() ); } const point_t& u_ssfactors() const { return point_t( get_deref_fn().ux_ssfactor(), get_deref_fn().ux_ssfactor() ); } const point_t& y_dimension() const { return _y_dimensions; } const point_t& v_dimension() const { return _v_dimensions; } const point_t& u_dimension() const { return _u_dimensions; } const plane_locator_t& y_plane() const { return get_deref_fn().y_locator(); } const plane_locator_t& v_plane() const { return get_deref_fn().v_locator(); } const plane_locator_t& u_plane() const { return get_deref_fn().u_locator(); } const plane_view_t y_plane_view() const { return plane_view_t( _y_dimensions, y_plane() ); } const plane_view_t v_plane_view() const { return plane_view_t( _v_dimensions, v_plane() ); } const plane_view_t u_plane_view() const { return plane_view_t( _u_dimensions, u_plane() ); } private: const deref_fn_t& get_deref_fn() const { return this->pixels().deref_fn(); } private: point_t _y_dimensions; point_t _v_dimensions; point_t _u_dimensions; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template < typename Locator, typename Factors > struct channel_type< subchroma_image_view< Locator, Factors > > : public channel_type< Locator > {}; template < typename Locator, typename Factors > struct color_space_type< subchroma_image_view< Locator, Factors > > : public color_space_type< Locator > {}; template < typename Locator, typename Factors > struct channel_mapping_type< subchroma_image_view< Locator, Factors > > : public channel_mapping_type< Locator > {}; template < typename Locator, typename Factors > struct is_planar< subchroma_image_view< Locator, Factors > > : public is_planar< Locator > {}; ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct dynamic_x_step_type< subchroma_image_view< Locator, Factors > > { using type = image_view<typename dynamic_x_step_type<Locator>::type>; }; ///////////////////////////// // HasDynamicYStepTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct dynamic_y_step_type< subchroma_image_view< Locator, Factors > > { using type = image_view<typename dynamic_y_step_type<Locator>::type>; }; ///////////////////////////// // HasTransposedTypeConcept ///////////////////////////// template < typename Locator, typename Factors > struct transposed_type< subchroma_image_view< Locator, Factors > > { using type = image_view<typename transposed_type<Locator>::type>; }; //////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ImageModel PixelBasedModel /// \brief container interface over image view. Models ImageConcept, PixelBasedConcept /// /// A subchroma image holds a bunch of planes which don't need to have the same resolution. /// //////////////////////////////////////////////////////////////////////////////////////// template < typename Pixel, typename Factors = mp11::mp_list_c<int, 4, 4, 4>, typename Allocator = std::allocator<unsigned char> > class subchroma_image : public detail::scaling_factors < mp11::mp_at_c<Factors, 0>::value, mp11::mp_at_c<Factors, 1>::value, mp11::mp_at_c<Factors, 2>::value > { private: using parent_t = detail::scaling_factors < mp11::mp_at_c<Factors, 0>::value, mp11::mp_at_c<Factors, 1>::value, mp11::mp_at_c<Factors, 2>::value >; public: using channel_t = typename channel_type<Pixel>::type; using pixel_t = pixel<channel_t, gray_layout_t>; using plane_image_t = image<pixel_t, false, Allocator>; using plane_view_t = typename plane_image_t::view_t; using plane_const_view_t = typename plane_image_t::const_view_t; using plane_locator_t = typename plane_view_t::locator; using pixel_view_t = typename view_type_from_pixel<Pixel>::type; using pixel_locator_t = typename pixel_view_t::locator; using locator_t = typename subchroma_image_locator < pixel_locator_t, Factors >::type; using x_coord_t = typename plane_image_t::coord_t; using y_coord_t = typename plane_image_t::coord_t; using view_t = subchroma_image_view<locator_t, Factors>; using const_view_t = typename view_t::const_t; /// constructor subchroma_image( const x_coord_t y_width , const y_coord_t y_height ) : _y_plane( y_width, y_height, 0, Allocator() ) , _v_plane( y_width / parent_t::ss_X, y_height / parent_t::ss_Y, 0, Allocator() ) , _u_plane( y_width / parent_t::ss_X, y_height / parent_t::ss_Y, 0, Allocator() ) { init(); } public: view_t _view; private: void init() { using defer_fn_t = subchroma_image_deref_fn<pixel_locator_t, Factors>; defer_fn_t deref_fn( view( _y_plane ).xy_at( 0, 0 ) , view( _v_plane ).xy_at( 0, 0 ) , view( _u_plane ).xy_at( 0, 0 ) ); // init a virtual_2d_locator locator_t locator( point_t( 0, 0 ) // p , point_t( 1, 1 ) // step , deref_fn ); _view = view_t( _y_plane.dimensions() , _v_plane.dimensions() , _u_plane.dimensions() , locator ); } private: plane_image_t _y_plane; plane_image_t _v_plane; plane_image_t _u_plane; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template < typename Pixel, typename Factors, typename Alloc > struct channel_type< subchroma_image< Pixel, Factors, Alloc > > : channel_type< Pixel > {}; template < typename Pixel, typename Factors, typename Alloc > struct color_space_type< subchroma_image< Pixel, Factors, Alloc > > : color_space_type< Pixel > {}; template < typename Pixel, typename Factors, typename Alloc > struct channel_mapping_type< subchroma_image< Pixel, Factors, Alloc > > : channel_mapping_type< Pixel > {}; template < typename Pixel, typename Factors, typename Alloc > struct is_planar< subchroma_image< Pixel, Factors, Alloc > > : std::integral_constant<bool, false> {}; ///////////////////////////////////////////////////////////////////////////////////////// /// \name view, const_view /// \brief Get an image view from an subchroma_image /// \ingroup ImageModel /// \brief Returns the non-constant-pixel view of an image ///////////////////////////////////////////////////////////////////////////////////////// template< typename Pixel , typename Factors > inline const typename subchroma_image< Pixel, Factors >::view_t& view( subchroma_image< Pixel, Factors >& img ) { return img._view; } template< typename Pixel , typename Factors > inline const typename subchroma_image< Pixel, Factors >::const_view_t const_view( subchroma_image< Pixel, Factors >& img ) { return static_cast< const typename subchroma_image< Pixel, Factors >::const_view_t>( img._view ); } ///////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ImageViewSTLAlgorithmsFillPixels /// \brief std::fill for subchroma_image views ///////////////////////////////////////////////////////////////////////////////////////// template< typename Locator , typename Factors , typename Pixel > void fill_pixels( const subchroma_image_view< Locator, Factors >& view , const Pixel& value ) { using channel_t = typename subchroma_image < Pixel, Factors >::plane_view_t::value_type; fill_pixels( view.y_plane_view(), channel_t( at_c< 0 >( value ))); fill_pixels( view.v_plane_view(), channel_t( at_c< 1 >( value ))); fill_pixels( view.u_plane_view(), channel_t( at_c< 2 >( value ))); } ///////////////////////////////////////////////////////////////////////////////////////// /// \ingroup ImageViewConstructors /// \brief Creates a subchroma view from a raw memory ///////////////////////////////////////////////////////////////////////////////////////// template< typename Pixel , typename Factors > typename subchroma_image< Pixel , Factors >::view_t subchroma_view( std::size_t y_width , std::size_t y_height , unsigned char y_base ) { using scaling_factors_t = detail::scaling_factors < mp11::mp_at_c<Factors, 0>::type::value, mp11::mp_at_c<Factors, 1>::type::value, mp11::mp_at_c<Factors, 2>::type::value >; std::size_t y_channel_size = 1; std::size_t u_channel_size = 1; unsigned char* u_base = y_base + ( y_width * y_height * y_channel_size ); unsigned char* v_base = u_base + ( y_width / scaling_factors_t::ss_X ) * u_channel_size; using plane_view_t = typename subchroma_image<Pixel, Factors>::plane_view_t; using plane_value_t = typename plane_view_t::value_type; plane_view_t y_plane = interleaved_view( y_width , y_height , (plane_value_t) y_base // pixels , y_width // rowsize_in_bytes ); plane_view_t v_plane = interleaved_view( y_width / scaling_factors_t::ss_X , y_height / scaling_factors_t::ss_Y , (plane_value_t) v_base // pixels , y_width // rowsize_in_bytes ); plane_view_t u_plane = interleaved_view( y_width / scaling_factors_t::ss_X , y_height / scaling_factors_t::ss_Y , (plane_value_t) u_base // pixels , y_width // rowsize_in_bytes ); using defer_fn_t = subchroma_image_deref_fn < typename subchroma_image<Pixel, Factors>::pixel_locator_t, Factors >; defer_fn_t deref_fn( y_plane.xy_at( 0, 0 ) , v_plane.xy_at( 0, 0 ) , u_plane.xy_at( 0, 0 ) ); using locator_t = typename subchroma_image<Pixel, Factors>::locator_t; locator_t locator( point_t( 0, 0 ) // p , point_t( 1, 1 ) // step , deref_fn ); using view_t = typename subchroma_image<Pixel, Factors>::view_t; return view_t( point_t( y_width, y_height ) , point_t( y_width / scaling_factors_t::ss_X, y_height / scaling_factors_t::ss_Y ) , point_t( y_width / scaling_factors_t::ss_X, y_height / scaling_factors_t::ss_Y ) , locator ); } } // namespace gil } // namespace boost #endif PK��p�[ݎ��,��,��/��extension/toolbox/image_types/indexed_image.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_IMAGE_TYPES_INDEXED_IMAGE_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_IMAGE_TYPES_INDEXED_IMAGE_HPP #include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp> #include <boost/gil/image.hpp> #include <boost/gil/point.hpp> #include <boost/gil/virtual_locator.hpp> #include <boost/gil/detail/is_channel_integral.hpp> #include <boost/gil/detail/mp11.hpp> #include <cstddef> #include <memory> namespace boost { namespace gil { template< typename Locator > struct get_pixel_type_locator { using type = mp11::mp_if < typename is_bit_aligned<typename Locator::value_type>::type, typename Locator::reference, typename Locator::value_type >; }; // used for virtual locator template< typename IndicesLoc , typename PaletteLoc > struct indexed_image_deref_fn_base { using indices_locator_t = IndicesLoc; using palette_locator_t = PaletteLoc; //using index_t = typename get_pixel_type_locator<indices_locator_t>::type; using const_t = indexed_image_deref_fn_base<IndicesLoc, PaletteLoc>; using value_type = typename PaletteLoc::value_type; using reference = value_type; using const_reference = value_type; using argument_type = point_t; using result_type = reference; static const bool is_mutable = false; indexed_image_deref_fn_base() {} indexed_image_deref_fn_base( const indices_locator_t& indices_loc , const palette_locator_t& palette_loc ) : _indices_loc( indices_loc ) , _palette_loc( palette_loc ) {} void set_indices( const indices_locator_t& indices_loc ) { _indices_loc = indices_loc; } void set_palette( const palette_locator_t& palette_loc ) { _palette_loc = palette_loc; } const indices_locator_t& indices() const { return _indices_loc; } const palette_locator_t& palette() const { return _palette_loc; } protected: indices_locator_t _indices_loc; palette_locator_t _palette_loc; }; // used for virtual locator template< typename IndicesLoc , typename PaletteLoc , typename Enable = void // there is specialization for integral indices > struct indexed_image_deref_fn : indexed_image_deref_fn_base< IndicesLoc , PaletteLoc > { using base_t = indexed_image_deref_fn_base < IndicesLoc, PaletteLoc >; indexed_image_deref_fn() : base_t() {} indexed_image_deref_fn( const typename base_t::indices_locator_t& indices_loc , const typename base_t::palette_locator_t& palette_loc ) : base_t( indices_loc , palette_loc ) {} typename base_t::result_type operator()( const point_t& p ) const { return this->_palette_loc.xy_at( at_c<0>( this->_indices_loc.xy_at( p )), 0 ); } }; template <typename IndicesLoc, typename PaletteLoc> struct indexed_image_deref_fn < IndicesLoc, PaletteLoc, typename std::enable_if < detail::is_channel_integral<typename IndicesLoc::value_type>::value >::type > : indexed_image_deref_fn_base<IndicesLoc, PaletteLoc> { using base_t = indexed_image_deref_fn_base<IndicesLoc, PaletteLoc>; indexed_image_deref_fn() : base_t() {} indexed_image_deref_fn( typename base_t::indices_locator_t const& indices_loc, typename base_t::palette_locator_t const& palette_loc) : base_t(indices_loc, palette_loc) { } typename base_t::result_type operator()(point_t const& p) const { return this->_palette_loc.xy_at(this->_indices_loc.xy_at(p), 0); } }; template< typename IndicesLoc , typename PaletteLoc > struct indexed_image_locator_type { using type = virtual_2d_locator < indexed_image_deref_fn<IndicesLoc, PaletteLoc>, false >; }; template< typename Locator > // indexed_image_locator_type< ... >::type class indexed_image_view : public image_view< Locator > { public: using deref_fn_t = typename Locator::deref_fn_t; using indices_locator_t = typename deref_fn_t::indices_locator_t; using palette_locator_t = typename deref_fn_t::palette_locator_t; using const_t = indexed_image_view<Locator>; using indices_view_t = image_view<indices_locator_t>; using palette_view_t = image_view<palette_locator_t>; indexed_image_view() : image_view< Locator >() , _num_colors( 0 ) {} indexed_image_view( const point_t& dimensions , std::size_t num_colors , const Locator& locator ) : image_view< Locator >( dimensions, locator ) , _num_colors( num_colors ) {} template< typename IndexedView > indexed_image_view( const IndexedView& iv ) : image_view< Locator >( iv ) , _num_colors( iv._num_colors ) {} std::size_t num_colors() const { return _num_colors; } const indices_locator_t& indices() const { return get_deref_fn().indices(); } const palette_locator_t& palette() const { return get_deref_fn().palette(); } indices_view_t get_indices_view() const { return indices_view_t(this->dimensions(), indices() );} palette_view_t get_palette_view() const { return palette_view_t(point_t(num_colors(), 1), palette());} private: const deref_fn_t& get_deref_fn() const { return this->pixels().deref_fn(); } private: template< typename Locator2 > friend class indexed_image_view; std::size_t _num_colors; }; // build an indexed_image_view from two views template<typename Index_View, typename Palette_View> indexed_image_view < typename indexed_image_locator_type < typename Index_View::locator , typename Palette_View::locator >::type > view(Index_View iv, Palette_View pv) { using view_t = indexed_image_view < typename indexed_image_locator_type < typename Index_View::locator, typename Palette_View::locator >::type >; using defer_fn_t = indexed_image_deref_fn < typename Index_View::locator, typename Palette_View::locator >; return view_t( iv.dimensions() , pv.dimensions().x , typename view_t::locator(point_t(0, 0), point_t(1, 1), defer_fn_t(iv.xy_at(0, 0), pv.xy_at(0, 0))) ); } template< typename Index , typename Pixel , typename IndicesAllocator = std::allocator< unsigned char > , typename PalleteAllocator = std::allocator< unsigned char > > class indexed_image { public: using indices_t = image<Index, false, IndicesAllocator>; using palette_t = image<Pixel, false, PalleteAllocator>; using indices_view_t = typename indices_t::view_t; using palette_view_t = typename palette_t::view_t; using indices_const_view_t = typename indices_t::const_view_t; using palette_const_view_t = typename palette_t::const_view_t; using indices_locator_t = typename indices_view_t::locator; using palette_locator_t = typename palette_view_t::locator; using locator_t = typename indexed_image_locator_type < indices_locator_t, palette_locator_t >::type; using x_coord_t = typename indices_t::coord_t; using y_coord_t = typename indices_t::coord_t; using view_t = indexed_image_view<locator_t>; using const_view_t = typename view_t::const_t; indexed_image( const x_coord_t width = 0 , const y_coord_t height = 0 , const std::size_t num_colors = 1 , const std::size_t indices_alignment = 0 , const std::size_t palette_alignment = 0 ) : _indices( width , height, indices_alignment, IndicesAllocator() ) , _palette( num_colors, 1, palette_alignment, PalleteAllocator() ) { init( point_t( width, height ), num_colors ); } indexed_image( const point_t& dimensions , const std::size_t num_colors = 1 , const std::size_t indices_alignment = 0 , const std::size_t palette_alignment = 0 ) : _indices( dimensions, indices_alignment, IndicesAllocator() ) , _palette( num_colors, 1, palette_alignment, PalleteAllocator() ) { init( dimensions, num_colors ); } indexed_image( const indexed_image& img ) : _indices( img._indices ) , _palette( img._palette ) {} template <typename Pixel2, typename Index2> indexed_image( const indexed_image< Pixel2, Index2 >& img ) { _indices = img._indices; _palette = img._palette; } indexed_image& operator= ( const indexed_image& img ) { _indices = img._indices; _palette = img._palette; return this; } indices_const_view_t get_indices_const_view() const { return static_cast< indices_const_view_t >( _view.get_indices_view()); } palette_const_view_t get_palette_const_view() const { return static_cast< palette_const_view_t >( _view.get_palette_view()); } indices_view_t get_indices_view() { return _view.get_indices_view(); } palette_view_t get_palette_view() { return _view.get_palette_view(); } public: view_t _view; private: void init( const point_t& dimensions , const std::size_t num_colors ) { using defer_fn_t = indexed_image_deref_fn < indices_locator_t, palette_locator_t >; defer_fn_t deref_fn( view( _indices ).xy_at( 0, 0 ) , view( _palette ).xy_at( 0, 0 ) ); locator_t locator( point_t( 0, 0 ) // p , point_t( 1, 1 ) // step , deref_fn ); _view = view_t( dimensions , num_colors , locator ); } private: indices_t _indices; palette_t _palette; }; template< typename Index , typename Pixel > inline const typename indexed_image< Index, Pixel >::view_t& view( indexed_image< Index, Pixel >& img ) { return img._view; } template< typename Index , typename Pixel > inline const typename indexed_image< Index, Pixel >::const_view_t const_view( indexed_image< Index, Pixel >& img ) { return static_cast< const typename indexed_image< Index, Pixel >::const_view_t>( img._view ); } // Whole image has one color and all indices are set to 0. template< typename Locator , typename Value > void fill_pixels( const indexed_image_view< Locator >& view , const Value& value ) { using view_t = indexed_image_view<Locator>; fill_pixels( view.get_indices_view(), typename view_t::indices_view_t::value_type( 0 )); view.get_palette_view().begin() = value; } } // namespace gil } // namespace boost #endif PK��p�[��q��&��extension/toolbox/color_converters.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_COLOR_CONVERTERS_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_HPP #include <boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp> #include <boost/gil/extension/toolbox/color_converters/rgb_to_luminance.hpp> #endif PK��p�[��q��q��#��extension/toolbox/metafunctions.hppnu��[��// // Copyright 2012 Christian Henning // // 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_EXTENSION_TOOLBOX_METAFUNCTIONS_HPP #define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_HPP #include <boost/gil/extension/toolbox/metafunctions/channel_type.hpp> #include <boost/gil/extension/toolbox/metafunctions/channel_view.hpp> #include <boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp> #include <boost/gil/extension/toolbox/metafunctions/get_pixel_type.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp> #include <boost/gil/extension/toolbox/metafunctions/is_similar.hpp> #include <boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp> #endif PK��p�[KRRo#��o#��pixel_iterator_adaptor.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_PIXEL_ITERATOR_ADAPTOR_HPP #define BOOST_GIL_PIXEL_ITERATOR_ADAPTOR_HPP #include <boost/gil/concepts.hpp> #include <boost/gil/pixel_iterator.hpp> #include <boost/iterator/iterator_facade.hpp> #include <iterator> namespace boost { namespace gil { /// \defgroup PixelIteratorModelDerefPtr dereference_iterator_adaptor /// \ingroup PixelIteratorModel /// \brief An iterator that invokes a provided function object upon dereference. Models: IteratorAdaptorConcept, PixelIteratorConcept /// \ingroup PixelIteratorModelDerefPtr PixelBasedModel /// \brief An adaptor over an existing iterator that provides for custom filter on dereferencing the object. Models: IteratorAdaptorConcept, PixelIteratorConcept template <typename Iterator, // Models Iterator typename DFn> // Models Returns the result of dereferencing a given iterator of type Iterator class dereference_iterator_adaptor : public iterator_adaptor<dereference_iterator_adaptor<Iterator,DFn>, Iterator, typename DFn::value_type, typename std::iterator_traits<Iterator>::iterator_category, typename DFn::reference, use_default> { DFn _deref_fn; public: using parent_t = iterator_adaptor<dereference_iterator_adaptor<Iterator,DFn>, Iterator, typename DFn::value_type, typename std::iterator_traits<Iterator>::iterator_category, typename DFn::reference, use_default>; using reference = typename DFn::result_type; using difference_type = typename std::iterator_traits<Iterator>::difference_type; using dereference_fn = DFn; dereference_iterator_adaptor() {} template <typename Iterator1> dereference_iterator_adaptor(const dereference_iterator_adaptor<Iterator1,DFn>& dit) : parent_t(dit.base()), _deref_fn(dit._deref_fn) {} dereference_iterator_adaptor(Iterator it, DFn deref_fn=DFn()) : parent_t(it), _deref_fn(deref_fn) {} template <typename Iterator1, typename DFn1> dereference_iterator_adaptor(const dereference_iterator_adaptor<Iterator1,DFn1>& it) : parent_t(it.base()), _deref_fn(it._deref_fn) {} /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference /// We require our own reference because it is registered in iterator_traits reference operator[](difference_type d) const { return (this+d);} // although iterator_adaptor defines these, the default implementation computes distance and compares for zero. // it is often faster to just apply the relation operator to the base bool operator> (const dereference_iterator_adaptor& p) const { return this->base_reference()> p.base_reference(); } bool operator< (const dereference_iterator_adaptor& p) const { return this->base_reference()< p.base_reference(); } bool operator>=(const dereference_iterator_adaptor& p) const { return this->base_reference()>=p.base_reference(); } bool operator<=(const dereference_iterator_adaptor& p) const { return this->base_reference()<=p.base_reference(); } bool operator==(const dereference_iterator_adaptor& p) const { return this->base_reference()==p.base_reference(); } bool operator!=(const dereference_iterator_adaptor& p) const { return this->base_reference()!=p.base_reference(); } Iterator& base() { return this->base_reference(); } const Iterator& base() const { return this->base_reference(); } const DFn& deref_fn() const { return _deref_fn; } private: template <typename Iterator1, typename DFn1> friend class dereference_iterator_adaptor; friend class boost::iterator_core_access; reference dereference() const { return _deref_fn((this->base_reference())); } }; template <typename I, typename DFn> struct const_iterator_type<dereference_iterator_adaptor<I,DFn> > { using type = dereference_iterator_adaptor<typename const_iterator_type<I>::type,typename DFn::const_t>; }; template <typename I, typename DFn> struct iterator_is_mutable<dereference_iterator_adaptor<I, DFn>> : std::integral_constant<bool, DFn::is_mutable> {}; template <typename I, typename DFn> struct is_iterator_adaptor<dereference_iterator_adaptor<I, DFn>> : std::true_type {}; template <typename I, typename DFn> struct iterator_adaptor_get_base<dereference_iterator_adaptor<I, DFn>> { using type = I; }; template <typename I, typename DFn, typename NewBaseIterator> struct iterator_adaptor_rebind<dereference_iterator_adaptor<I,DFn>,NewBaseIterator> { using type = dereference_iterator_adaptor<NewBaseIterator,DFn>; }; ///////////////////////////// // PixelBasedConcept ///////////////////////////// template <typename I, typename DFn> struct color_space_type<dereference_iterator_adaptor<I,DFn> > : public color_space_type<typename DFn::value_type> {}; template <typename I, typename DFn> struct channel_mapping_type<dereference_iterator_adaptor<I,DFn> > : public channel_mapping_type<typename DFn::value_type> {}; template <typename I, typename DFn> struct is_planar<dereference_iterator_adaptor<I,DFn> > : public is_planar<typename DFn::value_type> {}; template <typename I, typename DFn> struct channel_type<dereference_iterator_adaptor<I,DFn> > : public channel_type<typename DFn::value_type> {}; ///////////////////////////// // MemoryBasedIteratorConcept ///////////////////////////// template <typename Iterator, typename DFn> struct byte_to_memunit<dereference_iterator_adaptor<Iterator,DFn> > : public byte_to_memunit<Iterator> {}; template <typename Iterator, typename DFn> inline typename std::iterator_traits<Iterator>::difference_type memunit_step(const dereference_iterator_adaptor<Iterator,DFn>& p) { return memunit_step(p.base()); } template <typename Iterator, typename DFn> inline typename std::iterator_traits<Iterator>::difference_type memunit_distance(const dereference_iterator_adaptor<Iterator,DFn>& p1, const dereference_iterator_adaptor<Iterator,DFn>& p2) { return memunit_distance(p1.base(),p2.base()); } template <typename Iterator, typename DFn> inline void memunit_advance(dereference_iterator_adaptor<Iterator,DFn>& p, typename std::iterator_traits<Iterator>::difference_type diff) { memunit_advance(p.base(), diff); } template <typename Iterator, typename DFn> inline dereference_iterator_adaptor<Iterator,DFn> memunit_advanced(const dereference_iterator_adaptor<Iterator,DFn>& p, typename std::iterator_traits<Iterator>::difference_type diff) { return dereference_iterator_adaptor<Iterator,DFn>(memunit_advanced(p.base(), diff), p.deref_fn()); } template <typename Iterator, typename DFn> inline typename std::iterator_traits<dereference_iterator_adaptor<Iterator,DFn> >::reference memunit_advanced_ref(const dereference_iterator_adaptor<Iterator,DFn>& p, typename std::iterator_traits<Iterator>::difference_type diff) { return memunit_advanced(p, diff); } ///////////////////////////// // HasDynamicXStepTypeConcept ///////////////////////////// template <typename Iterator, typename DFn> struct dynamic_x_step_type<dereference_iterator_adaptor<Iterator,DFn> > { using type = dereference_iterator_adaptor<typename dynamic_x_step_type<Iterator>::type,DFn>; }; /// \brief Returns the type (and creates an instance) of an iterator that invokes the given dereference adaptor upon dereferencing /// \ingroup PixelIteratorModelDerefPtr template <typename Iterator, typename Deref> struct iterator_add_deref { BOOST_GIL_CLASS_REQUIRE(Deref, boost::gil, PixelDereferenceAdaptorConcept) using type = dereference_iterator_adaptor<Iterator, Deref>; static type make(const Iterator& it, const Deref& d) { return type(it,d); } }; /// \ingroup PixelIteratorModelDerefPtr /// \brief For dereference iterator adaptors, compose the new function object after the old one template <typename Iterator, typename PREV_DEREF, typename Deref> struct iterator_add_deref<dereference_iterator_adaptor<Iterator, PREV_DEREF>,Deref> { // BOOST_GIL_CLASS_REQUIRE(Deref, boost::gil, PixelDereferenceAdaptorConcept) using type = dereference_iterator_adaptor<Iterator, deref_compose<Deref,PREV_DEREF>>; static type make(const dereference_iterator_adaptor<Iterator, PREV_DEREF>& it, const Deref& d) { return type(it.base(),deref_compose<Deref,PREV_DEREF>(d,it.deref_fn())); } }; }} // namespace boost::gil #endif PK��p�[��y��y��metafunctions.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_METAFUNCTIONS_HPP #define BOOST_GIL_METAFUNCTIONS_HPP #include <boost/gil/channel.hpp> #include <boost/gil/dynamic_step.hpp> #include <boost/gil/concepts.hpp> #include <boost/gil/concepts/detail/type_traits.hpp> #include <boost/gil/detail/mp11.hpp> #include <iterator> #include <type_traits> namespace boost { namespace gil { // forward declarations template <typename T, typename L> struct pixel; template <typename BitField,typename ChannelRefs,typename Layout> struct packed_pixel; template <typename T, typename C> struct planar_pixel_reference; template <typename IC, typename C> struct planar_pixel_iterator; template <typename I> class memory_based_step_iterator; template <typename I> class memory_based_2d_locator; template <typename L> class image_view; template <typename Pixel, bool IsPlanar, typename Alloc> class image; template <typename T> struct channel_type; template <typename T> struct color_space_type; template <typename T> struct channel_mapping_type; template <typename It> struct is_iterator_adaptor; template <typename It> struct iterator_adaptor_get_base; template <typename BitField, typename ChannelBitSizes, typename Layout, bool IsMutable> struct bit_aligned_pixel_reference; ////////////////////////////////////////////////// /// /// TYPE ANALYSIS METAFUNCTIONS /// Predicate metafunctions determining properties of GIL types /// ////////////////////////////////////////////////// /// \defgroup GILIsBasic xxx_is_basic /// \ingroup TypeAnalysis /// \brief Determines if GIL constructs are basic. /// Basic constructs are the ones that can be generated with the type /// factory methods pixel_reference_type, iterator_type, locator_type, view_type and image_type /// They can be mutable/immutable, planar/interleaved, step/nonstep. They must use GIL-provided models. /// \brief Determines if a given pixel reference is basic /// Basic references must use gil::pixel& (if interleaved), gil::planar_pixel_reference (if planar). They must use the standard constness rules. /// \ingroup GILIsBasic template <typename PixelRef> struct pixel_reference_is_basic : public std::false_type {}; template <typename T, typename L> struct pixel_reference_is_basic<pixel<T, L>&> : std::true_type {}; template <typename T, typename L> struct pixel_reference_is_basic<const pixel<T, L>&> : std::true_type {}; template <typename TR, typename CS> struct pixel_reference_is_basic<planar_pixel_reference<TR, CS>> : std::true_type {}; template <typename TR, typename CS> struct pixel_reference_is_basic<const planar_pixel_reference<TR, CS>> : std::true_type {}; /// \brief Determines if a given pixel iterator is basic /// Basic iterators must use gil::pixel (if interleaved), gil::planar_pixel_iterator (if planar) and gil::memory_based_step_iterator (if step). They must use the standard constness rules. /// \ingroup GILIsBasic template <typename Iterator> struct iterator_is_basic : std::false_type {}; /// \tparam T mutable interleaved pixel type template <typename T, typename L> struct iterator_is_basic<pixel<T, L>> : std::true_type {}; /// \tparam T immutable interleaved pixel type template <typename T, typename L> struct iterator_is_basic<pixel<T, L> const> : std::true_type {}; /// \tparam T mutable planar pixel type template <typename T, typename CS> struct iterator_is_basic<planar_pixel_iterator<T, CS>> : std::true_type {}; /// \tparam T immutable planar pixel type template <typename T, typename CS> struct iterator_is_basic<planar_pixel_iterator<T const, CS>> : std::true_type {}; /// \tparam T mutable interleaved step template <typename T, typename L> struct iterator_is_basic<memory_based_step_iterator<pixel<T, L>>> : std::true_type {}; /// \tparam T immutable interleaved step template <typename T, typename L> struct iterator_is_basic<memory_based_step_iterator<pixel<T, L> const>> : std::true_type {}; /// \tparam T mutable planar step template <typename T, typename CS> struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<T, CS>>> : std::true_type {}; /// \tparam T immutable planar step template <typename T, typename CS> struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<T const, CS>>> : std::true_type {}; /// \ingroup GILIsBasic /// \brief Determines if a given locator is basic. A basic locator is memory-based and has basic x_iterator and y_iterator template <typename Loc> struct locator_is_basic : std::false_type {}; template <typename Iterator> struct locator_is_basic < memory_based_2d_locator<memory_based_step_iterator<Iterator>> > : iterator_is_basic<Iterator> {}; /// \ingroup GILIsBasic /// \brief Basic views must be over basic locators template <typename View> struct view_is_basic : std::false_type {}; template <typename Loc> struct view_is_basic<image_view<Loc>> : locator_is_basic<Loc> {}; /// \ingroup GILIsBasic /// \brief Basic images must use basic views and std::allocator template <typename Img> struct image_is_basic : std::false_type {}; template <typename Pixel, bool IsPlanar, typename Alloc> struct image_is_basic<image<Pixel, IsPlanar, Alloc>> : std::true_type {}; /// \defgroup GILIsStep xxx_is_step /// \ingroup TypeAnalysis /// \brief Determines if the given iterator/locator/view has a step that could be set dynamically template <typename I> struct iterator_is_step; namespace detail { template <typename It, bool IsBase, bool EqualsStepType> struct iterator_is_step_impl; // iterator that has the same type as its dynamic_x_step_type must be a step iterator template <typename It, bool IsBase> struct iterator_is_step_impl<It, IsBase, true> : std::true_type {}; // base iterator can never be a step iterator template <typename It> struct iterator_is_step_impl<It, true, false> : std::false_type {}; // for an iterator adaptor, see if its base is step template <typename It> struct iterator_is_step_impl<It, false, false> : public iterator_is_step<typename iterator_adaptor_get_base<It>::type> {}; } // namespace detail /// \ingroup GILIsStep /// \brief Determines if the given iterator has a step that could be set dynamically template <typename I> struct iterator_is_step : detail::iterator_is_step_impl < I, !is_iterator_adaptor<I>::value, std::is_same<I, typename dynamic_x_step_type<I>::type >::value > {}; /// \ingroup GILIsStep /// \brief Determines if the given locator has a horizontal step that could be set dynamically template <typename L> struct locator_is_step_in_x : public iterator_is_step<typename L::x_iterator> {}; /// \ingroup GILIsStep /// \brief Determines if the given locator has a vertical step that could be set dynamically template <typename L> struct locator_is_step_in_y : public iterator_is_step<typename L::y_iterator> {}; /// \ingroup GILIsStep /// \brief Determines if the given view has a horizontal step that could be set dynamically template <typename V> struct view_is_step_in_x : public locator_is_step_in_x<typename V::xy_locator> {}; /// \ingroup GILIsStep /// \brief Determines if the given view has a vertical step that could be set dynamically template <typename V> struct view_is_step_in_y : public locator_is_step_in_y<typename V::xy_locator> {}; /// \brief Determines whether the given pixel reference is a proxy class or a native C++ reference /// \ingroup TypeAnalysis template <typename PixelReference> struct pixel_reference_is_proxy : mp11::mp_not < std::is_same < typename detail::remove_const_and_reference<PixelReference>::type, typename detail::remove_const_and_reference<PixelReference>::type::value_type > > {}; /// \brief Given a model of a pixel, determines whether the model represents a pixel reference (as opposed to pixel value) /// \ingroup TypeAnalysis template <typename Pixel> struct pixel_is_reference : mp11::mp_or<is_reference<Pixel>, pixel_reference_is_proxy<Pixel>> {}; /// \defgroup GILIsMutable xxx_is_mutable /// \ingroup TypeAnalysis /// \brief Determines if the given pixel reference/iterator/locator/view is mutable (i.e. its pixels can be changed) /// \ingroup GILIsMutable /// \brief Determines if the given pixel reference is mutable (i.e. its channels can be changed) /// /// Note that built-in C++ references obey the const qualifier but reference proxy classes do not. template <typename R> struct pixel_reference_is_mutable : std::integral_constant<bool, std::remove_reference<R>::type::is_mutable> {}; template <typename R> struct pixel_reference_is_mutable<R const&> : mp11::mp_and<pixel_reference_is_proxy<R>, pixel_reference_is_mutable<R>> {}; /// \ingroup GILIsMutable /// \brief Determines if the given locator is mutable (i.e. its pixels can be changed) template <typename L> struct locator_is_mutable : public iterator_is_mutable<typename L::x_iterator> {}; /// \ingroup GILIsMutable /// \brief Determines if the given view is mutable (i.e. its pixels can be changed) template <typename V> struct view_is_mutable : public iterator_is_mutable<typename V::x_iterator> {}; ////////////////////////////////////////////////// /// /// TYPE FACTORY METAFUNCTIONS /// Metafunctions returning GIL types from other GIL types /// ////////////////////////////////////////////////// /// \defgroup TypeFactoryFromElements xxx_type /// \ingroup TypeFactory /// \brief Returns the type of a homogeneous GIL construct given its elements (channel, layout, whether it is planar, step, mutable, etc.) /// \defgroup TypeFactoryFromPixel xxx_type_from_pixel /// \ingroup TypeFactory /// \brief Returns the type of a GIL construct given its pixel type, whether it is planar, step, mutable, etc. /// \defgroup TypeFactoryDerived derived_xxx_type /// \ingroup TypeFactory /// \brief Returns the type of a homogeneous GIL construct given a related construct by changing some of its properties /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous pixel reference given the channel type, layout, whether it operates on planar data and whether it is mutable template <typename T, typename L, bool IsPlanar=false, bool IsMutable=true> struct pixel_reference_type{}; template <typename T, typename L> struct pixel_reference_type<T,L,false,true > { using type = pixel<T,L>&; }; template <typename T, typename L> struct pixel_reference_type<T,L,false,false> { using type = pixel<T,L> const&; }; template <typename T, typename L> struct pixel_reference_type<T,L,true,true> { using type = planar_pixel_reference<typename channel_traits<T>::reference,typename color_space_type<L>::type> const; }; // TODO: Assert M=identity template <typename T, typename L> struct pixel_reference_type<T,L,true,false> { using type = planar_pixel_reference<typename channel_traits<T>::const_reference,typename color_space_type<L>::type> const; };// TODO: Assert M=identity /// \ingroup TypeFactoryFromPixel /// \brief Returns the type of a pixel iterator given the pixel type, whether it operates on planar data, whether it is a step iterator, and whether it is mutable template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type_from_pixel{}; template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,true > { using type = Pixel ; }; template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,false> { using type = const Pixel ; }; template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,true> { using type = planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::pointer,typename color_space_type<Pixel>::type>; }; template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,false> { using type = planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::const_pointer,typename color_space_type<Pixel>::type>; }; template <typename Pixel, bool IsPlanar, bool IsMutable> struct iterator_type_from_pixel<Pixel,IsPlanar,true,IsMutable> { using type = memory_based_step_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,false,IsMutable>::type>; }; /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous iterator given the channel type, layout, whether it operates on planar data, whether it is a step iterator, and whether it is mutable template <typename T, typename L, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type{}; template <typename T, typename L> struct iterator_type<T,L,false,false,true > { using type = pixel<T,L>; }; template <typename T, typename L> struct iterator_type<T,L,false,false,false> { using type = pixel<T,L> const; }; template <typename T, typename L> struct iterator_type<T,L,true,false,true> { using type = planar_pixel_iterator<T,typename L::color_space_t>; }; // TODO: Assert M=identity template <typename T, typename L> struct iterator_type<T,L,true,false,false> { using type = planar_pixel_iterator<const T,typename L::color_space_t>; }; // TODO: Assert M=identity template <typename T, typename L, bool IsPlanar, bool IsMutable> struct iterator_type<T,L,IsPlanar,true,IsMutable> { using type = memory_based_step_iterator<typename iterator_type<T,L,IsPlanar,false,IsMutable>::type>; }; /// \brief Given a pixel iterator defining access to pixels along a row, returns the types of the corresponding built-in step_iterator, xy_locator, image_view /// \ingroup TypeFactory template <typename XIterator> struct type_from_x_iterator { using step_iterator_t = memory_based_step_iterator<XIterator>; using xy_locator_t = memory_based_2d_locator<step_iterator_t>; using view_t = image_view<xy_locator_t>; }; namespace detail { template <typename BitField, typename FirstBit, typename NumBits> struct packed_channel_reference_type { using type = packed_channel_reference < BitField, FirstBit::value, NumBits::value, true > const; }; template <typename BitField, typename ChannelBitSizes> class packed_channel_references_vector_type { template <typename FirstBit, typename NumBits> using reference_type = typename packed_channel_reference_type<BitField, FirstBit, NumBits>::type; // If ChannelBitSizesVector is mp11::mp_list_c<int,7,7,2> // Then first_bits_vector will be mp11::mp_list_c<int,0,7,14,16> using first_bit_list = mp11::mp_fold_q < ChannelBitSizes, mp11::mp_list<std::integral_constant<int, 0>>, mp11::mp_bind < mp11::mp_push_back, mp11::_1, mp11::mp_bind < mp11::mp_plus, mp11::mp_bind<mp_back, mp11::_1>, mp11::_2 > > >; static_assert(mp11::mp_at_c<first_bit_list, 0>::value == 0, "packed channel first bit must be 0"); public: using type = mp11::mp_transform < reference_type, mp_pop_back<first_bit_list>, ChannelBitSizes >; }; } // namespace detail /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a packed pixel given its bitfield type, the bit size of its channels and its layout. /// /// A packed pixel has channels that cover bit ranges but itself is byte aligned. RGB565 pixel is an example. /// /// The size of ChannelBitSizes must equal the number of channels in the given layout /// The sum of bit sizes for all channels must be less than or equal to the number of bits in BitField (and cannot exceed 64). /// If it is less than the number of bits in BitField, the last bits will be unused. template <typename BitField, typename ChannelBitSizes, typename Layout> struct packed_pixel_type { using type = packed_pixel < BitField, typename detail::packed_channel_references_vector_type < BitField, ChannelBitSizes >::type, Layout>; }; /// \defgroup TypeFactoryPacked packed_image_type,bit_aligned_image_type /// \ingroup TypeFactoryFromElements /// \brief Returns the type of an image whose channels are not byte-aligned. /// /// A packed image is an image whose pixels are byte aligned, such as "rgb565". <br> /// A bit-aligned image is an image whose pixels are not byte aligned, such as "rgb222". <br> /// /// The sum of the bit sizes of all channels cannot exceed 64. /// \ingroup TypeFactoryPacked /// \brief Returns the type of an interleaved packed image: an image whose channels may not be byte-aligned, but whose pixels are byte aligned. template <typename BitField, typename ChannelBitSizes, typename Layout, typename Alloc=std::allocator<unsigned char>> struct packed_image_type { using type = image<typename packed_pixel_type<BitField,ChannelBitSizes,Layout>::type,false,Alloc>; }; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a single-channel image given its bitfield type, the bit size of its channel and its layout template <typename BitField, unsigned Size1, typename Layout, typename Alloc = std::allocator<unsigned char>> struct packed_image1_type : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a two channel image given its bitfield type, the bit size of its channels and its layout template <typename BitField, unsigned Size1, unsigned Size2, typename Layout, typename Alloc = std::allocator<unsigned char>> struct packed_image2_type : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a three channel image given its bitfield type, the bit size of its channels and its layout template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc = std::allocator<unsigned char>> struct packed_image3_type : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a four channel image given its bitfield type, the bit size of its channels and its layout template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc = std::allocator<unsigned char>> struct packed_image4_type : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a five channel image given its bitfield type, the bit size of its channels and its layout template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc = std::allocator<unsigned char>> struct packed_image5_type : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a packed image whose pixels may not be byte aligned. For example, an "rgb222" image is bit-aligned because its pixel spans six bits. /// /// Note that the alignment parameter in the constructor of bit-aligned images is in bit units. For example, if you want to construct a bit-aligned /// image whose rows are byte-aligned, use 8 as the alignment parameter, not 1. /// template < typename ChannelBitSizes, typename Layout, typename Alloc = std::allocator<unsigned char> > struct bit_aligned_image_type { private: static constexpr int bit_size = mp11::mp_fold < ChannelBitSizes, std::integral_constant<int, 0>, mp11::mp_plus >::value; using bitfield_t = typename detail::min_fast_uint<bit_size + 7>::type; using bit_alignedref_t = bit_aligned_pixel_reference<bitfield_t, ChannelBitSizes, Layout, true> const; public: using type = image<bit_alignedref_t,false,Alloc>; }; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a single-channel bit-aligned image given the bit size of its channel and its layout template <unsigned Size1, typename Layout, typename Alloc = std::allocator<unsigned char>> struct bit_aligned_image1_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a two channel bit-aligned image given the bit size of its channels and its layout template <unsigned Size1, unsigned Size2, typename Layout, typename Alloc = std::allocator<unsigned char>> struct bit_aligned_image2_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a three channel bit-aligned image given the bit size of its channels and its layout template <unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc = std::allocator<unsigned char>> struct bit_aligned_image3_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a four channel bit-aligned image given the bit size of its channels and its layout template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc = std::allocator<unsigned char>> struct bit_aligned_image4_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {}; /// \ingroup TypeFactoryPacked /// \brief Returns the type of a five channel bit-aligned image given the bit size of its channels and its layout template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc = std::allocator<unsigned char>> struct bit_aligned_image5_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {}; /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous pixel given the channel type and layout template <typename Channel, typename Layout> struct pixel_value_type { // by default use gil::pixel. Specializations are provided for using type = pixel<Channel, Layout>; }; // Specializations for packed channels template <typename BitField, int NumBits, bool IsMutable, typename Layout> struct pixel_value_type<packed_dynamic_channel_reference<BitField, NumBits, IsMutable>, Layout> : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout> {}; template <typename BitField, int NumBits, bool IsMutable, typename Layout> struct pixel_value_type<packed_dynamic_channel_reference<BitField, NumBits, IsMutable> const, Layout> : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout> {}; template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout> struct pixel_value_type<packed_channel_reference<BitField, FirstBit, NumBits, IsMutable>, Layout> : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout> {}; template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout> struct pixel_value_type<packed_channel_reference<BitField, FirstBit, NumBits, IsMutable> const, Layout> : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout> {}; template <int NumBits, typename Layout> struct pixel_value_type<packed_channel_value<NumBits>, Layout> : packed_pixel_type<typename detail::min_fast_uint<NumBits>::type, mp11::mp_list_c<unsigned, NumBits>, Layout> {}; /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous locator given the channel type, layout, whether it operates on planar data and whether it has a step horizontally template <typename T, typename L, bool IsPlanar = false, bool IsStepX = false, bool IsMutable = true> struct locator_type { using type = typename type_from_x_iterator < typename iterator_type<T, L, IsPlanar, IsStepX, IsMutable>::type >::xy_locator_type; }; /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous view given the channel type, layout, whether it operates on planar data and whether it has a step horizontally template <typename T, typename L, bool IsPlanar = false, bool IsStepX = false, bool IsMutable = true> struct view_type { using type = typename type_from_x_iterator < typename iterator_type<T, L, IsPlanar, IsStepX, IsMutable>::type >::view_t; }; /// \ingroup TypeFactoryFromElements /// \brief Returns the type of a homogeneous image given the channel type, layout, and whether it operates on planar data template <typename T, typename L, bool IsPlanar = false, typename Alloc = std::allocator<unsigned char>> struct image_type { using type = image<pixel<T, L>, IsPlanar, Alloc>; }; /// \ingroup TypeFactoryFromPixel /// \brief Returns the type of a view the pixel type, whether it operates on planar data and whether it has a step horizontally template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true> struct view_type_from_pixel { using type = typename type_from_x_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,IsStepX,IsMutable>::type>::view_t; }; /// \brief Constructs a pixel reference type from a source pixel reference type by changing some of the properties. /// \ingroup TypeFactoryDerived /// Use use_default for the properties of the source view that you want to keep template < typename Ref, typename T = use_default, typename L = use_default, typename IsPlanar = use_default, typename IsMutable = use_default> class derived_pixel_reference_type { using pixel_t = typename std::remove_reference<Ref>::type; using channel_t = typename mp11::mp_if < std::is_same<T, use_default>, typename channel_type<pixel_t>::type, T >::type; using layout_t = typename mp11::mp_if < std::is_same<L, use_default>, layout < typename color_space_type<pixel_t>::type, typename channel_mapping_type<pixel_t>::type >, L >::type; static bool const mut = mp11::mp_if < std::is_same<IsMutable, use_default>, pixel_reference_is_mutable<Ref>, IsMutable >::value; static bool const planar = mp11::mp_if < std::is_same<IsPlanar, use_default>, is_planar<pixel_t>, IsPlanar >::value; public: using type = typename pixel_reference_type<channel_t, layout_t, planar, mut>::type; }; /// \brief Constructs a pixel iterator type from a source pixel iterator type by changing some of the properties. /// \ingroup TypeFactoryDerived /// Use use_default for the properties of the source view that you want to keep template < typename Iterator, typename T = use_default, typename L = use_default, typename IsPlanar = use_default, typename IsStep = use_default, typename IsMutable = use_default > class derived_iterator_type { using channel_t = typename mp11::mp_if < std::is_same<T, use_default>, typename channel_type<Iterator>::type, T >::type; using layout_t = typename mp11::mp_if < std::is_same<L, use_default>, layout < typename color_space_type<Iterator>::type, typename channel_mapping_type<Iterator>::type >, L >::type; static const bool mut = mp11::mp_if < std::is_same<IsMutable, use_default>, iterator_is_mutable<Iterator>, IsMutable >::value; static bool const planar = mp11::mp_if < std::is_same<IsPlanar, use_default>, is_planar<Iterator>, IsPlanar >::value; static bool const step = mp11::mp_if < std::is_same<IsStep, use_default>, iterator_is_step<Iterator>, IsStep >::type::value; public: using type = typename iterator_type<channel_t, layout_t, planar, step, mut>::type; }; /// \brief Constructs an image view type from a source view type by changing some of the properties. /// \ingroup TypeFactoryDerived /// Use use_default for the properties of the source view that you want to keep template <typename View, typename T = use_default, typename L = use_default, typename IsPlanar = use_default, typename StepX = use_default, typename IsMutable = use_default> class derived_view_type { using channel_t = typename mp11::mp_if < std::is_same<T, use_default>, typename channel_type<View>::type, T >; using layout_t = typename mp11::mp_if < std::is_same<L, use_default>, layout < typename color_space_type<View>::type, typename channel_mapping_type<View>::type >, L >; static bool const mut = mp11::mp_if < std::is_same<IsMutable, use_default>, view_is_mutable<View>, IsMutable >::value; static bool const planar = mp11::mp_if < std::is_same<IsPlanar, use_default>, is_planar<View>, IsPlanar >::value; static bool const step = mp11::mp_if < std::is_same<StepX, use_default>, view_is_step_in_x<View>, StepX >::value; public: using type = typename view_type<channel_t, layout_t, planar, step, mut>::type; }; /// \brief Constructs a homogeneous image type from a source image type by changing some of the properties. /// \ingroup TypeFactoryDerived /// Use use_default for the properties of the source image that you want to keep template <typename Image, typename T = use_default, typename L = use_default, typename IsPlanar = use_default> class derived_image_type { using channel_t = typename mp11::mp_if < std::is_same<T, use_default>, typename channel_type<Image>::type, T >::type; using layout_t = typename mp11::mp_if < std::is_same<L, use_default>, layout < typename color_space_type<Image>::type, typename channel_mapping_type<Image>::type>, L >::type; static bool const planar = mp11::mp_if < std::is_same<IsPlanar, use_default>, is_planar<Image>, IsPlanar >::value; public: using type = typename image_type<channel_t, layout_t, planar>::type; }; }} // namespace boost::gil #endif PK��p�[s�� deprecated.hppnu��[��// // Copyright 2005-2007 Adobe Systems Incorporated // // 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_DEPRECATED_HPP #define BOOST_GIL_DEPRECATED_HPP #include <cstddef> /// This file is provided as a courtesy to ease upgrading GIL client code. /// Please make sure your code compiles when this file is not included. #define planar_ptr planar_pixel_iterator #define planar_ref planar_pixel_reference #define membased_2d_locator memory_based_2d_locator #define pixel_step_iterator memory_based_step_iterator #define pixel_image_iterator iterator_from_2d #define equal_channels static_equal #define copy_channels static_copy #define fill_channels static_fill #define generate_channels static_generate #define for_each_channel static_for_each #define transform_channels static_transform #define max_channel static_max #define min_channel static_min #define semantic_channel semantic_at_c template <typename Img> void resize_clobber_image(Img& img, const typename Img::point_t& new_dims) { img.recreate(new_dims); } template <typename Img> void resize_clobber_image(Img& img, const typename Img::x_coord_t& width, const typename Img::y_coord_t& height) { img.recreate(width,height); } template <typename T> typename T::x_coord_t get_width(const T& a) { return a.width(); } template <typename T> typename T::y_coord_t get_height(const T& a) { return a.height(); } template <typename T> typename T::point_t get_dimensions(const T& a) { return a.dimensions(); } template <typename T> std::size_t get_num_channels(const T& a) { return a.num_channels(); } #define GIL boost::gil #define ADOBE_GIL_NAMESPACE_BEGIN namespace boost { namespace gil { #define ADOBE_GIL_NAMESPACE_END } } #define ByteAdvancableIteratorConcept MemoryBasedIteratorConcept #define byte_advance memunit_advance #define byte_advanced memunit_advanced #define byte_step memunit_step #define byte_distance memunit_distance #define byte_addressable_step_iterator memory_based_step_iterator #define byte_addressable_2d_locator memory_based_2d_locator // These are members of memory-based locators //#define row_bytes row_size // commented out because row_bytes is commonly used #define pix_bytestep pixel_size #endif PK��p�[�]P ��virtual_locator.hppnu��[��PK��p�[�[ bI��bI��locator.hppnu��[��PK��p�[�f%K'��K'��pb��planar_pixel_iterator.hppnu��[��PK��p�[��g��concepts.hppnu��[��PK��p�[� �� utilities.hppnu��[��PK��p�[�_��7��7��߭��step_iterator.hppnu��[��PK��p�[��t��t��color_base_algorithm.hppnu��[��PK��p�[V��g4��g4��Z�typedefs.hppnu��[��PK��p�[��#��#��^��bit_aligned_pixel_iterator.hppnu��[��PK��p�[6D)��)��promote_integral.hppnu��[��PK��p�[0�� rgb.hppnu��[��PK��p�[�� t��t��channel.hppnu��[��PK��p�[�c��G�rgba.hppnu��[��PK��p�[2[/)Z��)Z��M�channel_algorithm.hppnu��[��PK��p�[�P�`��6��iterator_from_2d.hppnu��[��PK��p�[fp�]�6��6��r��image_view.hppnu��[��PK��p�[��W�O��O�� image.hppnu��[��PK��p�[�o��&��&��I�planar_pixel_reference.hppnu��[��PK��p�[�e#�u��u�� p�algorithm.hppnu��[��PK��p�[D�ӥ@��@��c�detail/type_traits.hppnu��[��PK��p�[�谓e��e��detail/math.hppnu��[��PK��p�[%�YI��detail/std_common_type.hppnu��[��PK��p�[��k��k��detail/is_channel_integral.hppnu��[��PK��p�[osP��z$�detail/mp11.hppnu��[��PK��p�[:=p�U��U��'�color_base.hppnu��[��PK��p�[��}�}��}��}�dynamic_step.hppnu��[��PK��p�[g��`��concepts/fwd.hppnu��[��PK��p�[��l�S��S��׆�concepts/channel.hppnu��[��PK��p�[ y<��n��concepts/pixel_dereference.hppnu��[��PK��p�[�}׍ �� u��concepts/color.hppnu��[��PK��p�[/�}4�9��9��D��concepts/pixel_locator.hppnu��[��PK��p�[�X�~K��~K��concepts/image_view.hppnu��[��PK��p�[�e��>�concepts/image.hppnu��[��PK��p�[�]vg}��}��S�concepts/concept_check.hppnu��[��PK��p�[�U��s��s��Z�concepts/detail/type_traits.hppnu��[��PK��p�[�I��]�concepts/detail/utility.hppnu��[��PK��p�[�8�hf-��f-��_�concepts/color_base.hppnu��[��PK��p�['�wb��b��k��concepts/dynamic_step.hppnu��[��PK��p�[:X�=}��}��concepts/basic.hppnu��[��PK��p�[��!��!��զ�concepts/pixel.hppnu��[��PK��p�[T�8��concepts/pixel_based.hppnu��[��PK��p�[H��/��/��%��concepts/pixel_iterator.hppnu��[��PK��p�[r� B��i�concepts/point.hppnu��[��PK��p�[+k�&��&�� pixel.hppnu��[��PK��p�[k7��S'��S'��8�io/read_and_convert_view.hppnu��[��PK��p�[k6]� �� `�io/base.hppnu��[��PK��p�[Nk�\��\��Ik�io/get_reader.hppnu��[��PK��p�[��z�io/typedefs.hppnu��[��PK��p�[��M��Ɇ�io/read_image_info.hppnu��[��PK��p�[kC4��io/make_backend.hppnu��[��PK��p�[�HQ1A��1A�� ^��io/device.hppnu��[��PK��p�[�n�� io/get_writer.hppnu��[��PK��p�[�9�� io/make_dynamic_image_writer.hppnu��[��PK��p�[F�Pa��io/dynamic_io_new.hppnu��[��PK��p�[ g�j'��j'��=�io/read_image.hppnu��[��PK��p�[4�=�C��C��8�io/error.hppnu��[��PK��p�[��7$��$��g;�io/make_scanline_reader.hppnu��[��PK��p�[��i��i��G�io/read_view.hppnu��[��PK��p�[�� _�io/reader_base.hppnu��[��PK��p�[Y��T��T�� l�io/make_dynamic_image_reader.hppnu��[��PK��p�[�k:�3��3�� `~�io/io.hppnu��[��PK��p�[�}�d��d��̌�io/path_spec.hppnu��[��PK��p�[��ۜ{��{��p��io/get_read_device.hppnu��[��PK��p�[_g<L&��&��1��io/make_reader.hppnu��[��PK��p�[��˷��io/write_view.hppnu��[��PK��p�[�c��io/make_writer.hppnu��[��PK��p�[.��4��4��io/row_buffer_helper.hppnu��[��PK��p�[��[D��$��io/bit_operations.hppnu��[��PK��p�[t�7��7�� io/get_write_device.hppnu��[��PK��p�[��P��io/conversion_policies.hppnu��[��PK��p�[ͼ�Y.'��.'��s�io/read_and_convert_image.hppnu��[��PK��p�[YT� �� B�io/scanline_read_iterator.hppnu��[��PK��p�[��~k��k��XL�gray.hppnu��[��PK��p�[P��L6��6��N�color_convert.hppnu��[��PK��p�[�ܩ �� W��image_processing/harris.hppnu��[��PK��p�[zxc��c��image_processing/hessian.hppnu��[��PK��p�[oa��e��image_processing/filter.hppnu��[��PK��p�[��&?��&?��C��image_processing/threshold.hppnu��[��PK��p�[u�H(��H(��image_processing/numeric.hppnu��[��PK��p�[�jZ��K �image_processing/scaling.hppnu��[��PK��p�[S"��( �position_iterator.hppnu��[��PK��p�[�4��#��#��]< �packed_pixel.hppnu��[��PK��p�[PHC7��7��` �bit_aligned_pixel_reference.hppnu��[��PK��p�[5�� device_n.hppnu��[��PK��p�[0j��=� �pixel_iterator.hppnu��[��PK��p�[�9/h�� :� �point.hppnu��[��PK��p�[��f� �cmyk.hppnu��[��PK��p�[E#�H� �� premultiply.hppnu��[��PK��p�[ #�b1`��1`�� image_view_factory.hppnu��[��PK��p�[�V�X��X��-��%J �extension/dynamic_image/dynamic_image_all.hppnu��[��PK��p�[�!�� %��L �extension/dynamic_image/algorithm.hppnu��[��PK��p�[��}����m �extension/dynamic_image/any_image_view.hppnu��[��PK��p�[g��K��+��9� �extension/dynamic_image/apply_operation.hppnu��[��PK��p�[�nְ_��_��%��I� �extension/dynamic_image/any_image.hppnu��[��PK��p�[�c�E�7��7��.�� extension/dynamic_image/image_view_factory.hppnu��[��PK��p�[��X#��#��(�� extension/dynamic_image/dynamic_at_c.hppnu��[��PK��p�[�p�'��'�� extension/numeric/kernel.hppnu��[��PK��p�[�p��extension/numeric/resample.hppnu��[��PK��p�[U��X��X��8�extension/numeric/sampler.hppnu��[��PK��p�[�t}��U�extension/numeric/affine.hppnu��[��PK��p�[��i��4��4��b�extension/numeric/algorithm.hppnu��[��PK��p�[��>_:��_:��extension/numeric/convolve.hppnu��[��PK��p�[����.��extension/numeric/pixel_numeric_operations.hppnu��[��PK��p�[�:��)��)��0��extension/numeric/channel_numeric_operations.hppnu��[��PK��p�[ln��p�extension/io/raw/tags.hppnu��[��PK��p�[��X$��$����S1�extension/io/raw/detail/reader_backend.hppnu��[��PK��p�[7 >5��"��A�extension/io/raw/detail/device.hppnu��[��PK��p�[�Bƅ�� V�extension/io/raw/detail/read.hppnu��[��PK��p�[ա��+��t�extension/io/raw/detail/supported_types.hppnu��[��PK��p�[ ��&��{�extension/io/raw/detail/is_allowed.hppnu��[��PK��p�[?�1��U��extension/io/raw/read.hppnu��[��PK��p�[w��mT��T��extension/io/bmp/tags.hppnu��[��PK��p�[L�3�V��V��extension/io/bmp/write.hppnu��[��PK��p�[ Z$v��v����extension/io/bmp/detail/reader_backend.hppnu��[��PK��p�[E��/��!��extension/io/bmp/detail/write.hppnu��[��PK��p�[�`~B3��B3��)��extension/io/bmp/detail/scanline_read.hppnu��[��PK��p�[7\|��Y��Y�� 0 �extension/io/bmp/detail/read.hppnu��[��PK��p�[`i�s��s����J^ �extension/io/bmp/detail/writer_backend.hppnu��[��PK��p�[d�� +��c �extension/io/bmp/detail/supported_types.hppnu��[��PK��p�[cɧ�V��V��&��_q �extension/io/bmp/detail/is_allowed.hppnu��[��PK��p�[�b�@Q��Q��z �extension/io/bmp/read.hppnu��[��PK��p�[j:9�K��K��~ �extension/io/bmp/old.hppnu��[��PK��p�[�= Jf��f��8� �extension/io/targa/tags.hppnu��[��PK��p�[ �.3_��_�� extension/io/targa/write.hppnu��[��PK��p�[��d��,�� extension/io/targa/detail/reader_backend.hppnu��[��PK��p�[৫"��"��#��ۻ �extension/io/targa/detail/write.hppnu��[��PK��p�[J������+��P� �extension/io/targa/detail/scanline_read.hppnu��[��PK��p�[y^�6)2��)2��"�� extension/io/targa/detail/read.hppnu��[��PK��p�[��p"��,��P�extension/io/targa/detail/writer_backend.hppnu��[��PK��p�[\�A�� -��-�extension/io/targa/detail/supported_types.hppnu��[��PK��p�[��X��(��#�extension/io/targa/detail/is_allowed.hppnu��[��PK��p�[˛�+��P)�extension/io/targa/read.hppnu��[��PK��p�[�~��-�extension/io/targa/old.hppnu��[��PK��p�[��C�extension/io/tiff.hppnu��[��PK��p�[5L/p?/��?/��oE�extension/io/tiff/tags.hppnu��[��PK��p�[�V��`��`��t�extension/io/tiff/write.hppnu��[��PK��p�[��+��w�extension/io/tiff/detail/reader_backend.hppnu��[��PK��p�[� i�� extension/io/tiff/detail/log.hppnu��[��PK��p�[�V�-:��-:��"��r��extension/io/tiff/detail/write.hppnu��[��PK��p�[#{��>��>����extension/io/tiff/detail/scanline_read.hppnu��[��PK��p�[�ʞ:�7��7��#�� extension/io/tiff/detail/device.hppnu��[��PK��p�[XN��m��m��!��1C�extension/io/tiff/detail/read.hppnu��[��PK��p�[��/��+��extension/io/tiff/detail/writer_backend.hppnu��[��PK��p�[e$�Af��f��,��d��extension/io/tiff/detail/supported_types.hppnu��[��PK��p�[jK`�z��z��'��&��extension/io/tiff/detail/is_allowed.hppnu��[��PK��p�[��]��]��extension/io/tiff/read.hppnu��[��PK��p�[��M��extension/io/tiff/old.hppnu��[��PK��p�[��oL��L��j��extension/io/raw.hppnu��[��PK��p�[a�hP��extension/io/jpeg/tags.hppnu��[��PK��p�[��`��`��%�extension/io/jpeg/write.hppnu��[��PK��p�[�zނt$��t$��+��extension/io/jpeg/detail/reader_backend.hppnu��[��PK��p�[)4J��!��D�extension/io/jpeg/detail/base.hppnu��[��PK��p�[~c��0��0��"��G�extension/io/jpeg/detail/write.hppnu��[��PK��p�[��z�������r\�extension/io/jpeg/detail/scanline_read.hppnu��[��PK��p�[K+��:$��:$��!��l�extension/io/jpeg/detail/read.hppnu��[��PK��p�[Q��#��+��extension/io/jpeg/detail/writer_backend.hppnu��[��PK��p�[��) j��j��,��extension/io/jpeg/detail/supported_types.hppnu��[��PK��p�[��[��'��q��extension/io/jpeg/detail/is_allowed.hppnu��[��PK��p�[��c]��]��۸�extension/io/jpeg/read.hppnu��[��PK��p�[��e ��extension/io/jpeg/old.hppnu��[��PK��p�[��e^��extension/io/jpeg.hppnu��[��PK��p�[R��u��extension/io/png.hppnu��[��PK��p�[�e\|��\|��:��extension/io/bmp.hppnu��[��PK��p�[ޑ�2a ��a ��extension/io/pnm/tags.hppnu��[��PK��p�[\�V��V��extension/io/pnm/write.hppnu��[��PK��p�[��s����D��extension/io/pnm/detail/reader_backend.hppnu��[��PK��p�[ ��hI��I��!��extension/io/pnm/detail/write.hppnu��[��PK��p�[��ʵB��B��)��/�extension/io/pnm/detail/scanline_read.hppnu��[��PK��p�[r�I�2��2�� +�extension/io/pnm/detail/read.hppnu��[��PK��p�[�"�o��o����^�extension/io/pnm/detail/writer_backend.hppnu��[��PK��p�[��_n��+��c�extension/io/pnm/detail/supported_types.hppnu��[��PK��p�[��Le/��/��&��v�extension/io/pnm/detail/is_allowed.hppnu��[��PK��p�[��,}�extension/io/pnm/read.hppnu��[��PK��p�[��=��=��r��extension/io/pnm/old.hppnu��[��PK��p�[F� \|��\|��extension/io/pnm.hppnu��[��PK��p�[��k��k��extension/io/png/tags.hppnu��[��PK��p�[��&�[��[��extension/io/png/write.hppnu��[��PK��p�[�6�f��f����extension/io/png/detail/reader_backend.hppnu��[��PK��p�[aV�� m�extension/io/png/detail/base.hppnu��[��PK��p�[l_nR��R��!��w�extension/io/png/detail/write.hppnu��[��PK��p�[t��a��a��)��N��extension/io/png/detail/scanline_read.hppnu��[��PK��p�[M�%�:��:�� extension/io/png/detail/read.hppnu��[��PK��p�[p#U"�A��A����\��extension/io/png/detail/writer_backend.hppnu��[��PK��p�[G�/�3��3��+��L"�extension/io/png/detail/supported_types.hppnu��[��PK��p�[ϝo-��-��&��U�extension/io/png/detail/is_allowed.hppnu��[��PK��p�[7vX�V��V��D[�extension/io/png/read.hppnu��[��PK��p�[j��ӑ��_�extension/io/png/old.hppnu��[��PK��p�[.�d��u�extension/io/targa.hppnu��[��PK��p�[�]ٕ��$��w�extension/toolbox/dynamic_images.hppnu��[��PK��p�[j��7��z�extension/toolbox/color_converters/rgb_to_luminance.hppnu��[��PK��p�[3~G��3��~�extension/toolbox/color_converters/gray_to_rgba.hppnu��[��PK��p�[��SE��E��(��O��extension/toolbox/color_spaces/cmyka.hppnu��[��PK��p�[Siv��&��extension/toolbox/color_spaces/xyz.hppnu��[��PK��p�[=��X��&��extension/toolbox/color_spaces/lab.hppnu��[��PK��p�[��"��"��(��extension/toolbox/color_spaces/ycbcr.hppnu��[��PK��p�[]�/P^��^��&��u��extension/toolbox/color_spaces/hsl.hppnu��[��PK��p�[J='/��/��&��)��extension/toolbox/color_spaces/hsv.hppnu��[��PK��p�[M��!��!��-��extension/toolbox/color_spaces/gray_alpha.hppnu��[��PK��p�[��o��!��,�extension/toolbox/image_types.hppnu��[��PK��p�[^V{��.��extension/toolbox/metafunctions/is_similar.hppnu��[��PK��p�[ܟ7��2��extension/toolbox/metafunctions/is_bit_aligned.hppnu��[��PK��p�[��d [ ��[ ��0��! �extension/toolbox/metafunctions/channel_type.hppnu��[��PK��p�[��0Az��z��2��-�extension/toolbox/metafunctions/get_pixel_type.hppnu��[��PK��p�[�YI��I��0��2�extension/toolbox/metafunctions/get_num_bits.hppnu��[��PK��p�[x��2��a:�extension/toolbox/metafunctions/is_homogeneous.hppnu��[��PK��p�["��2��E�extension/toolbox/metafunctions/pixel_bit_size.hppnu��[��PK��p�[�3��*��0��M�extension/toolbox/metafunctions/channel_view.hppnu��[��PK��p�[N��"��S�extension/toolbox/color_spaces.hppnu��[��PK��p�[�K�M��M��V�extension/toolbox/toolbox.hppnu��[��PK��p�[[��lL��lL��1��8Y�extension/toolbox/image_types/subchroma_image.hppnu��[��PK��p�[ݎ��,��,��/��extension/toolbox/image_types/indexed_image.hppnu��[��PK��p�[��q��&��U��extension/toolbox/color_converters.hppnu��[��PK��p�[��q��q��#��extension/toolbox/metafunctions.hppnu��[��PK��p�[KRRo#��o#��F��pixel_iterator_adaptor.hppnu��[��PK��p�[��y��y��metafunctions.hppnu��[��PK��p�[s�� w�deprecated.hppnu��[��PK��]N��

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0.05 | proxy | phpinfo | ???????????