8 #ifndef BOOST_GIL_UTILITIES_HPP 9 #define BOOST_GIL_UTILITIES_HPP 11 #include <boost/gil/detail/mp11.hpp> 13 #include <boost/config.hpp> 15 #if defined(BOOST_CLANG) 16 #pragma clang diagnostic push 17 #pragma clang diagnostic ignored "-Wconversion" 20 #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) 21 #pragma GCC diagnostic push 22 #pragma GCC diagnostic ignored "-Wconversion" 25 #include <boost/iterator/iterator_adaptor.hpp> 26 #include <boost/iterator/iterator_facade.hpp> 28 #if defined(BOOST_CLANG) 29 #pragma clang diagnostic pop 32 #if defined(BOOST_GCC) && (BOOST_GCC >= 40900) 33 #pragma GCC diagnostic pop 42 #include <type_traits> 44 namespace boost {
namespace gil {
53 inline std::ptrdiff_t iround(
float x)
55 return static_cast<std::ptrdiff_t>(x + (x < 0.0f ? -0.5f : 0.5f));
58 inline std::ptrdiff_t iround(
double x)
60 return static_cast<std::ptrdiff_t>(x + (x < 0.0 ? -0.5 : 0.5));
63 inline std::ptrdiff_t ifloor(
float x)
65 return static_cast<std::ptrdiff_t>(std::floor(x));
68 inline std::ptrdiff_t ifloor(
double x)
70 return static_cast<std::ptrdiff_t>(std::floor(x));
73 inline std::ptrdiff_t iceil(
float x)
75 return static_cast<std::ptrdiff_t>(std::ceil(x));
78 inline std::ptrdiff_t iceil(
double x)
80 return static_cast<std::ptrdiff_t>(std::ceil(x));
88 inline T align(T val, std::size_t alignment)
90 return val+(alignment - val%alignment)%alignment;
101 typename ConstReference,
108 using argument_type = ArgType;
109 using result_type = ResultType;
110 using const_t = ConstT;
111 using value_type = Value;
112 using reference = Reference;
113 using const_reference = ConstReference;
114 static constexpr
bool is_mutable = IsMutable;
120 template <
typename D1,
typename D2>
123 deref_compose<typename D1::const_t, typename D2::const_t>,
124 typename D1::value_type,
125 typename D1::reference,
126 typename D1::const_reference,
127 typename D2::argument_type,
128 typename D1::result_type,
129 D1::is_mutable && D2::is_mutable
136 using argument_type =
typename D2::argument_type;
137 using result_type =
typename D1::result_type;
140 deref_compose(
const D1& x,
const D2& y) : _fn1(x), _fn2(y) {}
143 template <
typename _D1,
typename _D2>
145 : _fn1(dc._fn1), _fn2(dc._fn2)
148 result_type operator()(argument_type x)
const {
return _fn1(_fn2(x)); }
149 result_type operator()(argument_type x) {
return _fn1(_fn2(x)); }
153 template <
typename OutPtr,
typename In>
155 OutPtr gil_reinterpret_cast(In* p)
157 return static_cast<OutPtr>(static_cast<void*>(p));
160 template <
typename OutPtr,
typename In> BOOST_FORCEINLINE
161 const OutPtr gil_reinterpret_cast_c(
const In* p)
163 return static_cast<const OutPtr>(static_cast<const void*>(p));
172 template <
class InputIter,
class Size,
class OutputIter>
173 std::pair<InputIter, OutputIter> _copy_n(InputIter first, Size count,
174 OutputIter result, std::input_iterator_tag)
176 for ( ; count > 0; --count)
182 return std::pair<InputIter, OutputIter>(first, result);
185 template <
class RAIter,
class Size,
class OutputIter>
186 inline std::pair<RAIter, OutputIter>
187 _copy_n(RAIter first, Size count, OutputIter result, std::random_access_iterator_tag)
189 RAIter last = first + count;
190 return std::pair<RAIter, OutputIter>(last,
std::copy(first, last, result));
193 template <
class InputIter,
class Size,
class OutputIter>
194 inline std::pair<InputIter, OutputIter>
195 _copy_n(InputIter first, Size count, OutputIter result)
197 return _copy_n(first, count, result,
typename std::iterator_traits<InputIter>::iterator_category());
200 template <
class InputIter,
class Size,
class OutputIter>
201 inline std::pair<InputIter, OutputIter>
202 copy_n(InputIter first, Size count, OutputIter result)
204 return detail::_copy_n(first, count, result);
208 template <
typename T>
211 using argument_type = T;
212 using result_type = T;
213 const T& operator()(
const T& val)
const {
return val; }
217 template <
typename T1,
typename T2>
219 using first_argument_type = T1;
220 using second_argument_type = T2;
221 using result_type = T1;
222 T1 operator()(T1 f1, T2 f2)
const 229 template <
typename T>
232 using argument_type = T;
233 using result_type = T;
234 T operator()(T x)
const {
return ++x; }
238 template <
typename T>
241 using argument_type = T;
242 using result_type = T;
243 T operator()(T x)
const {
return --x; }
248 template <
typename Types,
typename T>
251 static_assert(mp11::mp_contains<Types, T>::value,
"T should be element of Types");
261 typename ChannelMapping = mp11::mp_iota
263 std::integral_constant<int, mp11::mp_size<ColorSpace>::value>
268 using color_space_t = ColorSpace;
269 using channel_mapping_t = ChannelMapping;
271 static_assert(mp11::mp_size<ColorSpace>::value > 0,
272 "color space should not be empty sequence");
277 template <
typename Value,
typename T1,
typename T2>
278 void swap_proxy(T1& left, T2& right)
286 BOOST_FORCEINLINE
bool little_endian()
288 short tester = 0x0001;
289 return *(
char*)&tester!=0;
292 BOOST_FORCEINLINE
bool big_endian()
294 return !little_endian();
plus function object whose arguments may be of different type.
Definition: utilities.hpp:218
Helper base class for pixel dereference adaptors.
Definition: utilities.hpp:106
operator– wrapped in a function object
Definition: utilities.hpp:239
identity taken from SGI STL.
Definition: utilities.hpp:209
operator++ wrapped in a function object
Definition: utilities.hpp:230
Represents a color space and ordering of channels in memory.
Definition: utilities.hpp:266
Composes two dereference function objects. Similar to std::unary_compose but needs to pull some alias...
Definition: utilities.hpp:121
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 > *
Copy when both src and dst are interleaved and of the same type can be just memmove.
Definition: algorithm.hpp:139
Returns the index corresponding to the first occurrance of a given given type in.
Definition: utilities.hpp:249