8 #ifndef BOOST_GIL_ALGORITHM_HPP
9 #define BOOST_GIL_ALGORITHM_HPP
11 #include <boost/gil/bit_aligned_pixel_iterator.hpp>
12 #include <boost/gil/color_base_algorithm.hpp>
13 #include <boost/gil/concepts.hpp>
14 #include <boost/gil/image_view.hpp>
15 #include <boost/gil/image_view_factory.hpp>
17 #include <boost/config.hpp>
18 #include <boost/utility/enable_if.hpp>
19 #include <boost/mpl/and.hpp>
20 #include <boost/mpl/or.hpp>
30 namespace boost {
namespace gil {
33 template <
typename ChannelPtr,
typename ColorSpace>
35 template <
typename Iterator>
37 template <
typename StepIterator>
80 template <
typename Derived,
typename Result=
void>
82 typedef Result result_type;
84 template <
typename V1,
typename V2> BOOST_FORCEINLINE
85 result_type operator()(
const std::pair<const V1*,const V2*>& p)
const {
89 template <
typename V1,
typename V2> BOOST_FORCEINLINE
90 result_type operator()(
const V1& v1,
const V2& v2)
const {
94 result_type operator()(
const error_t&)
const {
throw std::bad_cast(); }
98 template <
typename V1,
typename V2>
99 BOOST_FORCEINLINE result_type apply(
const V1& v1,
const V2& v2, mpl::false_)
const {
100 return ((
const Derived*)
this)->apply_incompatible(v1,v2);
104 template <
typename V1,
typename V2>
105 BOOST_FORCEINLINE result_type apply(
const V1& v1,
const V2& v2, mpl::true_)
const {
106 return ((
const Derived*)
this)->apply_compatible(v1,v2);
110 template <
typename V1,
typename V2>
111 BOOST_FORCEINLINE result_type apply_incompatible(
const V1&,
const V2&)
const {
112 throw std::bad_cast();
130 template<
typename T,
typename Cs>
139 template<
typename T,
typename Cs>
147 namespace boost {
namespace gil {
149 template <
typename I,
typename O>
struct copy_fn {
150 BOOST_FORCEINLINE I operator()(I first, I last, O dst)
const {
return std::copy(first,last,dst); }
158 template<
typename Cs,
typename IC1,
typename IC2> BOOST_FORCEINLINE
160 boost::gil::gil_function_requires<boost::gil::ChannelsCompatibleConcept<typename std::iterator_traits<IC1>::value_type,
typename std::iterator_traits<IC2>::value_type> >();
161 static_for_each(first,last,dst,boost::gil::detail::copy_fn<IC1,IC2>());
162 return dst+(last-first);
166 namespace boost {
namespace gil {
170 template <
typename I,
typename O>
172 BOOST_FORCEINLINE
void operator()(I src,
typename std::iterator_traits<I>::difference_type n, O dst)
const {
std::copy(src,src+n, dst); }
176 template <
typename IL,
typename O>
178 typedef typename std::iterator_traits<iterator_from_2d<IL> >::difference_type diff_t;
180 gil_function_requires<PixelLocatorConcept<IL> >();
181 gil_function_requires<MutablePixelIteratorConcept<O> >();
183 diff_t l=src.width()-src.x_pos();
184 diff_t numToCopy=(n<l ? n:l);
185 detail::copy_n(src.x(), numToCopy, dst);
194 template <
typename I,
typename OL>
196 typedef typename std::iterator_traits<I>::difference_type diff_t;
198 gil_function_requires<PixelIteratorConcept<I> >();
199 gil_function_requires<MutablePixelLocatorConcept<OL> >();
201 diff_t l=dst.width()-dst.x_pos();
202 diff_t numToCopy=(n<l ? n:l);
203 detail::copy_n(src, numToCopy, dst.x());
212 template <
typename IL,
typename OL>
214 typedef typename iterator_from_2d<IL>::difference_type diff_t;
216 gil_function_requires<PixelLocatorConcept<IL> >();
217 gil_function_requires<MutablePixelLocatorConcept<OL> >();
218 if (src.x_pos()!=dst.x_pos() || src.width()!=dst.width()) {
224 diff_t l=dst.width()-dst.x_pos();
225 diff_t numToCopy=(n<l ? n : l);
226 detail::copy_n(src.x(), numToCopy, dst.x());
234 template <
typename SrcIterator,
typename DstIterator>
235 BOOST_FORCEINLINE DstIterator copy_with_2d_iterators(SrcIterator first, SrcIterator last, DstIterator dst) {
236 typedef typename SrcIterator::x_iterator src_x_iterator;
237 typedef typename DstIterator::x_iterator dst_x_iterator;
239 typename SrcIterator::difference_type n = last - first;
241 if (first.is_1d_traversable()) {
242 if (dst.is_1d_traversable())
247 if (dst.is_1d_traversable())
248 copier_n<SrcIterator,dst_x_iterator>()(first,n, dst.x());
250 copier_n<SrcIterator,DstIterator>()(first,n,dst);
260 template <
typename IL,
typename OL>
262 return boost::gil::detail::copy_with_2d_iterators(first,last,dst);
266 namespace boost {
namespace gil {
269 template <
typename View1,
typename View2> BOOST_FORCEINLINE
271 assert(src.dimensions()==dst.dimensions());
272 detail::copy_with_2d_iterators(src.begin(),src.end(),dst.begin());
288 template <
typename CC>
289 class copy_and_convert_pixels_fn :
public binary_operation_obj<copy_and_convert_pixels_fn<CC> > {
293 typedef typename binary_operation_obj<copy_and_convert_pixels_fn<CC> >::result_type result_type;
294 copy_and_convert_pixels_fn() {}
295 copy_and_convert_pixels_fn(CC cc_in) : _cc(cc_in) {}
297 template <
typename V1,
typename V2> BOOST_FORCEINLINE
298 result_type apply_incompatible(
const V1& src,
const V2& dst)
const {
299 copy_pixels(color_converted_view<typename V2::value_type>(src,_cc),dst);
303 template <
typename V1,
typename V2> BOOST_FORCEINLINE
304 result_type apply_compatible(
const V1& src,
const V2& dst)
const {
311 template <
typename V1,
typename V2,
typename CC>
313 void copy_and_convert_pixels(
const V1& src,
const V2& dst,CC cc) {
314 detail::copy_and_convert_pixels_fn<CC> ccp(cc);
318 struct default_color_converter;
321 template <
typename View1,
typename View2>
323 void copy_and_convert_pixels(
const View1& src,
const View2& dst) {
324 detail::copy_and_convert_pixels_fn<default_color_converter> ccp;
348 template <
typename IL,
typename V>
350 boost::gil::gil_function_requires<boost::gil::MutablePixelLocatorConcept<IL> >();
351 if (first.is_1d_traversable()) {
355 std::ptrdiff_t n=last-first;
357 std::ptrdiff_t numToDo=std::min<const std::ptrdiff_t>(n,(std::ptrdiff_t)(first.width()-first.x_pos()));
358 std::fill_n(first.x(), numToDo, val);
366 namespace boost {
namespace gil {
370 template <
typename It,
typename P>
371 void operator()(It first, It last,
const P& p_in) {
376 template <
typename It,
typename P>
378 void fill_aux(It first, It last,
const P& p, mpl::true_) {
382 template <
typename It,
typename P>
384 void fill_aux(It first, It last,
const P& p,mpl::false_) {
391 template <
typename View,
typename Value> BOOST_FORCEINLINE
393 if (img_view.is_1d_traversable())
394 detail::fill_aux(img_view.begin().x(), img_view.end().x(),
395 val,is_planar<View>());
397 for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
398 detail::fill_aux(img_view.row_begin(y),img_view.row_end(y),
399 val,is_planar<View>());
413 template <
typename It> BOOST_FORCEINLINE
414 void destruct_range_impl( It first
416 ,
typename enable_if< mpl::and_< is_pointer< It >
417 , mpl::not_< boost::has_trivial_destructor<
typename std::iterator_traits<It>::value_type > >
422 while (first!=last) {
428 template <
typename It> BOOST_FORCEINLINE
429 void destruct_range_impl( It
431 ,
typename enable_if< mpl::or_< mpl::not_< is_pointer< It > >
432 , boost::has_trivial_destructor<
typename std::iterator_traits< It >::value_type >
437 template <
typename It> BOOST_FORCEINLINE
438 void destruct_range(It first, It last) {
439 destruct_range_impl( first
444 struct std_destruct_t {
445 template <
typename It>
void operator()(It first, It last)
const { destruct_range(first,last); }
449 template <
typename It>
451 void destruct_aux(It first, It last, mpl::true_) {
452 static_for_each(first,last,std_destruct_t());
455 template <
typename It>
457 void destruct_aux(It first, It last, mpl::false_) {
458 destruct_range(first,last);
464 template <
typename View> BOOST_FORCEINLINE
466 if (img_view.is_1d_traversable())
467 detail::destruct_aux(img_view.begin().x(), img_view.end().x(),
470 for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
471 detail::destruct_aux(img_view.row_begin(y),img_view.row_end(y),
488 template <
typename It,
typename P>
490 void uninitialized_fill_aux(It first, It last,
491 const P& p, mpl::true_) {
494 typedef typename std::iterator_traits<It>::value_type pixel_t;
495 while (channel < num_channels<pixel_t>::value) {
496 std::uninitialized_fill(dynamic_at_c(first,channel), dynamic_at_c(last,channel),
497 dynamic_at_c(p,channel));
501 for (
int c=0; c<channel; ++c)
502 destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
509 template <
typename It,
typename P>
511 void uninitialized_fill_aux(It first, It last,
512 const P& p,mpl::false_) {
513 std::uninitialized_fill(first,last,p);
521 template <
typename View,
typename Value>
523 if (img_view.is_1d_traversable())
524 detail::uninitialized_fill_aux(img_view.begin().x(), img_view.end().x(),
525 val,is_planar<View>());
527 typename View::y_coord_t y = 0;
529 for (y=0; y<img_view.height(); ++y)
530 detail::uninitialized_fill_aux(img_view.row_begin(y),img_view.row_end(y),
531 val,is_planar<View>());
533 for (
typename View::y_coord_t y0=0; y0<y; ++y0)
534 detail::destruct_aux(img_view.row_begin(y0),img_view.row_end(y0), is_planar<View>());
551 template <
typename It> BOOST_FORCEINLINE
552 void default_construct_range_impl(It first, It last, mpl::true_) {
553 typedef typename std::iterator_traits<It>::value_type value_t;
556 while (first!=last) {
557 new (first) value_t();
561 destruct_range(first1,first);
566 template <
typename It> BOOST_FORCEINLINE
567 void default_construct_range_impl(It, It, mpl::false_) {}
569 template <
typename It> BOOST_FORCEINLINE
570 void default_construct_range(It first, It last) { default_construct_range_impl(first, last,
typename is_pointer<It>::type()); }
573 template <
typename It>
575 void default_construct_aux(It first, It last, mpl::true_) {
578 typedef typename std::iterator_traits<It>::value_type pixel_t;
579 while (channel < num_channels<pixel_t>::value) {
580 default_construct_range(dynamic_at_c(first,channel), dynamic_at_c(last,channel));
584 for (
int c=0; c<channel; ++c)
585 destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
591 template <
typename It>
593 void default_construct_aux(It first, It last, mpl::false_) {
594 default_construct_range(first,last);
597 template <
typename View,
bool IsPlanar>
598 struct has_trivial_pixel_constructor :
public boost::has_trivial_constructor<typename View::value_type> {};
599 template <
typename View>
600 struct has_trivial_pixel_constructor<View, true> :
public boost::has_trivial_constructor<typename channel_type<View>::type> {};
604 template<
typename View,
bool B > BOOST_FORCEINLINE
605 void default_construct_pixels_impl(
const View& img_view
606 , boost::enable_if< is_same< mpl::bool_< B >
612 if( img_view.is_1d_traversable() )
614 detail::default_construct_aux( img_view.begin().x()
621 typename View::y_coord_t y = 0;
624 for( y = 0; y < img_view.height(); ++y )
626 detail::default_construct_aux( img_view.row_begin( y )
627 ,img_view.row_end( y )
633 for (
typename View::y_coord_t y0 = 0; y0 < y; ++y0 )
635 detail::destruct_aux( img_view.row_begin(y0)
636 , img_view.row_end(y0)
651 template <
typename View>
653 detail::default_construct_pixels_impl< View
654 , detail::has_trivial_pixel_constructor< View
655 , is_planar< View >::value
672 template <
typename It1,
typename It2>
674 void uninitialized_copy_aux(It1 first1, It1 last1,
675 It2 first2, mpl::true_) {
678 typedef typename std::iterator_traits<It1>::value_type pixel_t;
679 while (channel < num_channels<pixel_t>::value) {
680 std::uninitialized_copy(dynamic_at_c(first1,channel), dynamic_at_c(last1,channel), dynamic_at_c(first2,channel));
685 std::advance(last2, std::distance(first1,last1));
686 for (
int c=0; c<channel; ++c)
687 destruct_range(dynamic_at_c(first2,c), dynamic_at_c(last2,c));
692 template <
typename It1,
typename It2>
694 void uninitialized_copy_aux(It1 first1, It1 last1,
695 It2 first2,mpl::false_) {
696 std::uninitialized_copy(first1,last1,first2);
704 template <
typename View1,
typename View2>
706 typedef mpl::bool_<is_planar<View1>::value && is_planar<View2>::value> is_planar;
707 assert(view1.dimensions()==view2.dimensions());
708 if (view1.is_1d_traversable() && view2.is_1d_traversable())
709 detail::uninitialized_copy_aux(view1.begin().x(), view1.end().x(),
713 typename View1::y_coord_t y = 0;
715 for (y=0; y<view1.height(); ++y)
716 detail::uninitialized_copy_aux(view1.row_begin(y), view1.row_end(y),
720 for (
typename View1::y_coord_t y0=0; y0<y; ++y0)
721 detail::destruct_aux(view2.row_begin(y0),view2.row_end(y0), is_planar());
743 template <
typename V,
typename F>
744 F for_each_pixel(
const V& img, F fun) {
745 if (img.is_1d_traversable()) {
746 return std::for_each(img.begin().x(), img.end().x(), fun);
748 for (std::ptrdiff_t y=0; y<img.height(); ++y)
749 std::for_each(img.row_begin(y),img.row_end(y),fun);
759 template <
typename View,
typename F>
760 F for_each_pixel_position(
const View& img, F fun) {
761 typename View::xy_locator loc=img.xy_at(0,0);
762 for (std::ptrdiff_t y=0; y<img.height(); ++y) {
763 for (std::ptrdiff_t x=0; x<img.width(); ++x, ++loc.x())
765 loc.x()-=img.width(); ++loc.y();
782 template <
typename View,
typename F>
784 if (v.is_1d_traversable()) {
785 std::generate(v.begin().x(), v.end().x(), fun);
787 for (std::ptrdiff_t y=0; y<v.height(); ++y)
788 std::generate(v.row_begin(y),v.row_end(y),fun);
802 template <
typename I1,
typename I2> BOOST_FORCEINLINE
bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2);
805 template <
typename I1,
typename I2>
807 BOOST_FORCEINLINE
bool operator()(I1 i1, std::ptrdiff_t n, I2 i2)
const {
return std::equal(i1,i1+n, i2); }
812 template<
typename T,
typename Cs>
818 template<
typename T,
typename Cs>
824 template<
typename IC,
typename Cs>
827 std::ptrdiff_t numBytes=n*
sizeof(
typename std::iterator_traits<IC>::value_type);
829 for (std::ptrdiff_t i=0; i<mpl::size<Cs>::value; ++i)
830 if (memcmp(dynamic_at_c(i1,i), dynamic_at_c(i2,i), numBytes)!=0)
837 template <
typename Loc,
typename I2>
840 gil_function_requires<boost::gil::PixelLocatorConcept<Loc> >();
841 gil_function_requires<boost::gil::PixelIteratorConcept<I2> >();
843 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n, i1.width()-i1.x_pos());
844 if (!equal_n(i1.x(), num, i2))
855 template <
typename I1,
typename Loc>
858 gil_function_requires<boost::gil::PixelIteratorConcept<I1> >();
859 gil_function_requires<boost::gil::PixelLocatorConcept<Loc> >();
861 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos());
862 if (!equal_n(i1, num, i2.x()))
873 template <
typename Loc1,
typename Loc2>
876 gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
877 gil_function_requires<boost::gil::PixelLocatorConcept<Loc2> >();
878 if (i1.x_pos()!=i2.x_pos() || i1.width()!=i2.width()) {
880 if (*i1++!=*i2++)
return false;
884 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos());
885 if (!equal_n(i1.x(), num, i2.x()))
896 template <
typename I1,
typename I2> BOOST_FORCEINLINE
897 bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2) {
898 return detail::equal_n_fn<I1,I2>()(i1,n,i2);
914 template <
typename Loc1,
typename Loc2> BOOST_FORCEINLINE
916 boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
917 boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc2> >();
918 std::ptrdiff_t n=last-first;
919 if (first.is_1d_traversable()) {
920 if (first2.is_1d_traversable())
921 return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,typename Loc2::x_iterator>()(first.x(),n, first2.x());
923 return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,boost::gil::iterator_from_2d<Loc2> >()(first.x(),n, first2);
925 if (first2.is_1d_traversable())
933 namespace boost {
namespace gil {
936 template <
typename View1,
typename View2> BOOST_FORCEINLINE
938 assert(v1.dimensions()==v2.dimensions());
939 return std::equal(v1.begin(),v1.end(),v2.begin());
954 template <
typename View1,
typename View2,
typename F> BOOST_FORCEINLINE
956 assert(src.dimensions()==dst.dimensions());
957 for (std::ptrdiff_t y=0; y<src.height(); ++y) {
958 typename View1::x_iterator srcIt=src.row_begin(y);
959 typename View2::x_iterator dstIt=dst.row_begin(y);
960 for (std::ptrdiff_t x=0; x<src.width(); ++x)
961 dstIt[x]=fun(srcIt[x]);
968 template <
typename View1,
typename View2,
typename View3,
typename F> BOOST_FORCEINLINE
970 for (std::ptrdiff_t y=0; y<dst.height(); ++y) {
971 typename View1::x_iterator srcIt1=src1.row_begin(y);
972 typename View2::x_iterator srcIt2=src2.row_begin(y);
973 typename View3::x_iterator dstIt=dst.row_begin(y);
974 for (std::ptrdiff_t x=0; x<dst.width(); ++x)
975 dstIt[x]=fun(srcIt1[x],srcIt2[x]);
986 template <
typename View1,
typename View2,
typename F> BOOST_FORCEINLINE
988 assert(src.dimensions()==dst.dimensions());
989 typename View1::xy_locator loc=src.xy_at(0,0);
990 for (std::ptrdiff_t y=0; y<src.height(); ++y) {
991 typename View2::x_iterator dstIt=dst.row_begin(y);
992 for (std::ptrdiff_t x=0; x<src.width(); ++x, ++loc.x())
994 loc.x()-=src.width(); ++loc.y();
1001 template <
typename View1,
typename View2,
typename View3,
typename F> BOOST_FORCEINLINE
1003 assert(src1.dimensions()==dst.dimensions());
1004 assert(src2.dimensions()==dst.dimensions());
1005 typename View1::xy_locator loc1=src1.xy_at(0,0);
1006 typename View2::xy_locator loc2=src2.xy_at(0,0);
1007 for (std::ptrdiff_t y=0; y<src1.height(); ++y) {
1008 typename View3::x_iterator dstIt=dst.row_begin(y);
1009 for (std::ptrdiff_t x=0; x<src1.width(); ++x, ++loc1.x(), ++loc2.x())
1010 dstIt[x]=fun(loc1,loc2);
1011 loc1.x()-=src1.width(); ++loc1.y();
1012 loc2.x()-=src2.width(); ++loc2.y();
void uninitialized_fill_pixels(const View &img_view, const Value &val)
std::uninitialized_fill for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in-place copy-constructed pixels
Definition: algorithm.hpp:522
Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept.
Definition: metafunctions.hpp:30
void generate_pixels(const View &v, F fun)
std::generate for image views
Definition: algorithm.hpp:783
An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept.
Definition: algorithm.hpp:34
Definition: algorithm.hpp:171
Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept.
Definition: iterator_from_2d.hpp:43
Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConceptThe class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis while its base iterator provides horizontal navigation.
Definition: algorithm.hpp:38
BOOST_FORCEINLINE bool equal_pixels(const View1 &v1, const View2 &v2)
std::equal for image views
Definition: algorithm.hpp:937
void fill(boost::gil::iterator_from_2d< IL > first, boost::gil::iterator_from_2d< IL > last, const V &val)
std::fill(I,I,V) with I being a iterator_from_2d
Definition: algorithm.hpp:349
Returns whether two views are compatible.
Definition: concepts.hpp:2128
BOOST_FORCEINLINE void copy_pixels(const View1 &src, const View2 &dst)
std::copy for image views
Definition: algorithm.hpp:270
BOOST_FORCEINLINE void fill_pixels(const View &img_view, const Value &val)
std::fill for image views
Definition: algorithm.hpp:392
void default_construct_pixels(const View &img_view)
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.
Definition: algorithm.hpp:652
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)
std::copy(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:261
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)
Copy when both src and dst are planar pointers is copy for each channel.
Definition: algorithm.hpp:159
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)
std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:915
A generic binary operation on viewsUse this class as a convenience superclass when defining an operat...
Definition: algorithm.hpp:81
struct to do std::fill
Definition: algorithm.hpp:369
void uninitialized_copy_pixels(const View1 &view1, const View2 &view2)
std::uninitialized_copy for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in-place copy-constructed objects
Definition: algorithm.hpp:705
BOOST_FORCEINLINE void destruct_pixels(const View &img_view)
Invokes the in-place destructor on every pixel of the view.
Definition: algorithm.hpp:465
MEMORY-BASED STEP ITERATOR.
Definition: algorithm.hpp:36