123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408 |
- //
- // 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
- //
- #include <boost/gil/channel.hpp>
- #include <boost/gil/channel_algorithm.hpp>
- #include <boost/gil/typedefs.hpp>
- #include <cstdint>
- #include <exception>
- #include <iostream>
- #include <type_traits>
- #if defined(BOOST_CLANG)
- #pragma clang diagnostic push
- #pragma clang diagnostic ignored "-Wfloat-equal"
- #elif BOOST_GCC >= 40700
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wfloat-equal"
- #elif BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
- #pragma warning(push)
- #pragma warning(disable:4512) //assignment operator could not be generated
- #endif
- using namespace boost::gil;
- using namespace std;
- void error_if(bool);
- auto c8_min = channel_traits<uint8_t>::min_value();
- auto c8_max = channel_traits<uint8_t>::max_value();
- auto c8s_min = channel_traits<int8_t>::min_value();
- auto c8s_max = channel_traits<int8_t>::max_value();
- auto c16_min = channel_traits<uint16_t>::min_value();
- auto c16_max = channel_traits<uint16_t>::max_value();
- auto c16s_min = channel_traits<int16_t>::min_value();
- auto c16s_max = channel_traits<int16_t>::max_value();
- auto c32_min = channel_traits<uint32_t>::min_value();
- auto c32_max = channel_traits<uint32_t>::max_value();
- auto c32s_min = channel_traits<int32_t>::min_value();
- auto c32s_max = channel_traits<int32_t>::max_value();
- auto c32f_min = channel_traits<float32_t>::min_value();
- auto c32f_max = channel_traits<float32_t>::max_value();
- template <typename ChannelTestCore>
- struct do_test : public ChannelTestCore {
- using channel_t = typename ChannelTestCore::channel_t;
- using channel_value_t = typename channel_traits<channel_t>::value_type;
- do_test() : ChannelTestCore() {
- error_if(this->_min_v != channel_traits<channel_t>::min_value());
- error_if(this->_max_v != channel_traits<channel_t>::max_value());
- }
- void test_all() {
- test_channel_invert();
- test_channel_convert();
- test_channel_multiply();
- test_channel_math();
- }
- void test_mutable(std::false_type) {}
- void test_mutable(std::true_type) {
- channel_value_t mv=this->_min_v;
- ++this->_min_v; this->_min_v++;
- --this->_min_v; this->_min_v--;
- error_if(mv!=this->_min_v);
- this->_min_v+=1;
- this->_min_v-=1;
- error_if(mv!=this->_min_v);
- this->_min_v*=1;
- this->_min_v/=1;
- error_if(mv!=this->_min_v);
- this->_min_v = 1; // assignable to scalar
- this->_min_v = mv; // and to value type
- // test swap
- channel_value_t v1=this->_min_v;
- channel_value_t v2=this->_max_v;
- swap(this->_min_v, this->_max_v);
- channel_value_t v3=this->_min_v;
- channel_value_t v4=this->_max_v;
- error_if(v1!=v4 || v2!=v3);
- }
- void test_channel_math() {
- error_if(this->_min_v >= this->_max_v);
- error_if(this->_max_v <= this->_min_v);
- error_if(this->_min_v > this->_max_v);
- error_if(this->_max_v < this->_min_v);
- error_if(this->_max_v == this->_min_v);
- error_if(!(this->_max_v != this->_min_v));
- error_if(this->_min_v * 1 != this->_min_v);
- error_if(this->_min_v / 1 != this->_min_v);
- error_if((this->_min_v + 1) + 1 != (this->_min_v + 2));
- error_if((this->_max_v - 1) - 1 != (this->_max_v - 2));
- error_if(this->_min_v != 1 && this->_min_v==1); // comparable to integral
- test_mutable(std::integral_constant<bool, channel_traits<channel_t>::is_mutable>());
- }
- void test_channel_invert() {
- error_if(channel_invert(this->_min_v) != this->_max_v);
- error_if(channel_invert(this->_max_v) != this->_min_v);
- }
- void test_channel_multiply() {
- error_if(channel_multiply(this->_min_v, this->_min_v) != this->_min_v);
- error_if(channel_multiply(this->_max_v, this->_max_v) != this->_max_v);
- error_if(channel_multiply(this->_max_v, this->_min_v) != this->_min_v);
- }
- void test_channel_convert() {
- channel_value_t v_min, v_max;
- v_min=channel_convert<channel_t>(c8_min);
- v_max=channel_convert<channel_t>(c8_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c8s_min);
- v_max=channel_convert<channel_t>(c8s_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c16_min);
- v_max=channel_convert<channel_t>(c16_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c16s_min);
- v_max=channel_convert<channel_t>(c16s_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c32_min);
- v_max=channel_convert<channel_t>(c32_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c32s_min);
- v_max=channel_convert<channel_t>(c32s_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- v_min=channel_convert<channel_t>(c32f_min);
- v_max=channel_convert<channel_t>(c32f_max);
- error_if(v_min!=this->_min_v || v_max!=this->_max_v);
- }
- };
- // Different core classes depending on the different types of channels - channel values, references and subbyte references
- // The cores ensure there are two members, _min_v and _max_v initialized with the minimum and maximum channel value.
- // The different channel types have different ways to initialize them, thus require different cores
- // For channel values simply initialize the value directly
- template <typename ChannelValue>
- class value_core {
- protected:
- using channel_t = ChannelValue;
- channel_t _min_v;
- channel_t _max_v;
- value_core()
- : _min_v(channel_traits<ChannelValue>::min_value())
- , _max_v(channel_traits<ChannelValue>::max_value())
- {
- boost::function_requires<ChannelValueConcept<ChannelValue> >();
- }
- };
- // For channel references we need to have separate channel values
- template <typename ChannelRef>
- class reference_core : public value_core<typename channel_traits<ChannelRef>::value_type>
- {
- using parent_t = value_core<typename channel_traits<ChannelRef>::value_type>;
- protected:
- using channel_t = ChannelRef;
- channel_t _min_v;
- channel_t _max_v;
- reference_core()
- : parent_t()
- , _min_v(parent_t::_min_v)
- , _max_v(parent_t::_max_v)
- {
- boost::function_requires<ChannelConcept<ChannelRef> >();
- }
- };
- // For subbyte channel references we need to store the bit buffers somewhere
- template <typename ChannelSubbyteRef, typename ChannelMutableRef = ChannelSubbyteRef>
- class packed_reference_core {
- protected:
- using channel_t = ChannelSubbyteRef;
- using integer_t = typename channel_t::integer_t;
- channel_t _min_v, _max_v;
- integer_t _min_buf, _max_buf;
- packed_reference_core() : _min_v(&_min_buf), _max_v(&_max_buf) {
- ChannelMutableRef b1(&_min_buf), b2(&_max_buf);
- b1 = channel_traits<channel_t>::min_value();
- b2 = channel_traits<channel_t>::max_value();
- boost::function_requires<ChannelConcept<ChannelSubbyteRef> >();
- }
- };
- template <typename ChannelSubbyteRef, typename ChannelMutableRef = ChannelSubbyteRef>
- class packed_dynamic_reference_core {
- protected:
- using channel_t = ChannelSubbyteRef;
- channel_t _min_v, _max_v;
- typename channel_t::integer_t _min_buf, _max_buf;
- packed_dynamic_reference_core(int first_bit1=1, int first_bit2=2) : _min_v(&_min_buf,first_bit1), _max_v(&_max_buf,first_bit2) {
- ChannelMutableRef b1(&_min_buf,1), b2(&_max_buf,2);
- b1 = channel_traits<channel_t>::min_value();
- b2 = channel_traits<channel_t>::max_value();
- boost::function_requires<ChannelConcept<ChannelSubbyteRef> >();
- }
- };
- template <typename ChannelValue>
- void test_channel_value() {
- do_test<value_core<ChannelValue> >().test_all();
- }
- template <typename ChannelRef>
- void test_channel_reference() {
- do_test<reference_core<ChannelRef> >().test_all();
- }
- template <typename ChannelSubbyteRef>
- void test_packed_channel_reference() {
- do_test<packed_reference_core<ChannelSubbyteRef,ChannelSubbyteRef> >().test_all();
- }
- template <typename ChannelSubbyteRef, typename MutableRef>
- void test_const_packed_channel_reference() {
- do_test<packed_reference_core<ChannelSubbyteRef,MutableRef> >().test_all();
- }
- template <typename ChannelSubbyteRef>
- void test_packed_dynamic_channel_reference() {
- do_test<packed_dynamic_reference_core<ChannelSubbyteRef,ChannelSubbyteRef> >().test_all();
- }
- template <typename ChannelSubbyteRef, typename MutableRef>
- void test_const_packed_dynamic_channel_reference() {
- do_test<packed_dynamic_reference_core<ChannelSubbyteRef,MutableRef> >().test_all();
- }
- template <typename ChannelValue>
- void test_channel_value_impl() {
- test_channel_value<ChannelValue>();
- test_channel_reference<ChannelValue&>();
- test_channel_reference<const ChannelValue&>();
- }
- /////////////////////////////////////////////////////////
- ///
- /// A channel archetype - to test the minimum requirements of the concept
- ///
- /////////////////////////////////////////////////////////
- struct channel_value_archetype;
- struct channel_archetype {
- // equality comparable
- friend bool operator==(const channel_archetype&,const channel_archetype&) { return true; }
- friend bool operator!=(const channel_archetype&,const channel_archetype&) { return false; }
- // less-than comparable
- friend bool operator<(const channel_archetype&,const channel_archetype&) { return false; }
- // convertible to a scalar
- operator std::uint8_t() const { return 0; }
- channel_archetype& operator++() { return *this; }
- channel_archetype& operator--() { return *this; }
- channel_archetype operator++(int) { return *this; }
- channel_archetype operator--(int) { return *this; }
- template <typename Scalar> channel_archetype operator+=(Scalar) { return *this; }
- template <typename Scalar> channel_archetype operator-=(Scalar) { return *this; }
- template <typename Scalar> channel_archetype operator*=(Scalar) { return *this; }
- template <typename Scalar> channel_archetype operator/=(Scalar) { return *this; }
- using value_type = channel_value_archetype;
- using reference = channel_archetype;
- using const_reference = channel_archetype const;
- using pointer = channel_value_archetype *;
- using const_pointer = channel_value_archetype const*;
- static constexpr bool is_mutable=true;
- static value_type min_value();
- static value_type max_value();
- };
- struct channel_value_archetype : public channel_archetype {
- channel_value_archetype() {} // default constructible
- channel_value_archetype(const channel_value_archetype&) {} // copy constructible
- channel_value_archetype& operator=(const channel_value_archetype&){return *this;} // assignable
- channel_value_archetype(std::uint8_t) {}
- };
- channel_value_archetype channel_archetype::min_value() { return channel_value_archetype(); }
- channel_value_archetype channel_archetype::max_value() { return channel_value_archetype(); }
- void test_packed_channel_reference()
- {
- using channel16_0_5_reference_t = packed_channel_reference<std::uint16_t, 0, 5, true>;
- using channel16_5_6_reference_t = packed_channel_reference<std::uint16_t, 5, 6, true>;
- using channel16_11_5_reference_t = packed_channel_reference<std::uint16_t, 11, 5, true>;
- std::uint16_t data=0;
- channel16_0_5_reference_t channel1(&data);
- channel16_5_6_reference_t channel2(&data);
- channel16_11_5_reference_t channel3(&data);
- channel1=channel_traits<channel16_0_5_reference_t>::max_value();
- channel2=channel_traits<channel16_5_6_reference_t>::max_value();
- channel3=channel_traits<channel16_11_5_reference_t>::max_value();
- error_if(data!=65535);
- test_packed_channel_reference<channel16_0_5_reference_t>();
- test_packed_channel_reference<channel16_5_6_reference_t>();
- test_packed_channel_reference<channel16_11_5_reference_t>();
- }
- void test_packed_dynamic_channel_reference()
- {
- using channel16_5_reference_t = packed_dynamic_channel_reference<std::uint16_t, 5, true>;
- using channel16_6_reference_t = packed_dynamic_channel_reference<std::uint16_t, 6, true>;
- std::uint16_t data=0;
- channel16_5_reference_t channel1(&data,0);
- channel16_6_reference_t channel2(&data,5);
- channel16_5_reference_t channel3(&data,11);
- channel1=channel_traits<channel16_5_reference_t>::max_value();
- channel2=channel_traits<channel16_6_reference_t>::max_value();
- channel3=channel_traits<channel16_5_reference_t>::max_value();
- error_if(data!=65535);
- test_packed_dynamic_channel_reference<channel16_5_reference_t>();
- }
- void test_channel() {
- test_channel_value_impl<uint8_t>();
- test_channel_value_impl<int8_t>();
- test_channel_value_impl<uint16_t>();
- test_channel_value_impl<int16_t>();
- test_channel_value_impl<uint32_t>();
- test_channel_value_impl<int16_t>();
- test_channel_value_impl<float32_t>();
- test_packed_channel_reference();
- test_packed_dynamic_channel_reference();
- // Do only compile-time tests for the archetype (because asserts like val1<val2 fail)
- boost::function_requires<MutableChannelConcept<channel_archetype> >();
- do_test<value_core<channel_value_archetype> >();
- do_test<reference_core<channel_archetype> >();
- do_test<reference_core<const channel_archetype&> >();
- }
- int main()
- {
- try
- {
- test_channel();
- return EXIT_SUCCESS;
- }
- catch (std::exception const& e)
- {
- std::cerr << e.what() << std::endl;
- return EXIT_FAILURE;
- }
- catch (...)
- {
- return EXIT_FAILURE;
- }
- }
- // TODO:
- // - provide algorithm performance overloads for scoped channel and packed channels
- // - Update concepts and documentation
- // - What to do about pointer types?!
- // - Performance!!
- // - is channel_convert the same as native?
- // - is operator++ on float32_t the same as native? How about if operator++ is defined in scoped_channel to do _value++?
|