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

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

???????
PK��LR�[2�s��detail/ostream_guard.hppnu��[��/* Copyright 2019-2020 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_DETAIL_OSTREAM_GUARD_HPP #define BOOST_IO_DETAIL_OSTREAM_GUARD_HPP #include <boost/config.hpp> #include <iosfwd> namespace boost { namespace io { namespace detail { template<class Char, class Traits> class ostream_guard { public: explicit ostream_guard(std::basic_ostream<Char, Traits>& os) BOOST_NOEXCEPT : os_(&os) { } ~ostream_guard() BOOST_NOEXCEPT_IF(false) { if (os_) { os_->setstate(std::basic_ostream<Char, Traits>::badbit); } } void release() BOOST_NOEXCEPT { os_ = 0; } private: ostream_guard(const ostream_guard&); ostream_guard& operator=(const ostream_guard&); std::basic_ostream<Char, Traits> os_; }; } /* detail / } / io / } / boost / #endif PK��LR�[`z�ge��e��detail/buffer_fill.hppnu��[��/ Copyright 2019-2020 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_DETAIL_BUFFER_FILL_HPP #define BOOST_IO_DETAIL_BUFFER_FILL_HPP #include <iosfwd> #include <cstddef> namespace boost { namespace io { namespace detail { template<class charT, class traits> inline bool buffer_fill(std::basic_streambuf<charT, traits>& buf, charT ch, std::size_t size) { charT fill[] = { ch, ch, ch, ch, ch, ch, ch, ch }; enum { chunk = sizeof fill / sizeof(charT) }; for (; size > chunk; size -= chunk) { if (static_cast<std::size_t>(buf.sputn(fill, chunk)) != chunk) { return false; } } return static_cast<std::size_t>(buf.sputn(fill, size)) == size; } } / detail / } / io / } / boost / #endif PK��LR�[)��"� �� ostream_joiner.hppnu��[��/ Copyright 2019 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_OSTREAM_JOINER_HPP #define BOOST_IO_OSTREAM_JOINER_HPP #include <boost/config.hpp> #include <ostream> #include <string> #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) #include <type_traits> #endif #include <utility> #endif namespace boost { namespace io { namespace detail { #if !defined(BOOST_NO_CXX11_ADDRESSOF) template<class T> inline T osj_address(T& o) { return std::addressof(o); } #else template<class T> inline T* osj_address(T& obj) { return &obj; } #endif } /* detail / template<class Delim, class Char = char, class Traits = std::char_traits<Char> > class ostream_joiner { public: typedef Char char_type; typedef Traits traits_type; typedef std::basic_ostream<Char, Traits> ostream_type; typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; ostream_joiner(ostream_type& output, const Delim& delim) : output_(detail::osj_address(output)) , delim_(delim) , first_(true) { } #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ostream_joiner(ostream_type& output, Delim&& delim) : output_(detail::osj_address(output)) , delim_(std::move(delim)) , first_(true) { } #endif template<class T> ostream_joiner& operator=(const T& value) { if (!first_) { output_ << delim_; } first_ = false; output_ << value; return this; } ostream_joiner& operator() BOOST_NOEXCEPT { return this; } ostream_joiner& operator++() BOOST_NOEXCEPT { return this; } ostream_joiner& operator++(int) BOOST_NOEXCEPT { return this; } private: ostream_type* output_; Delim delim_; bool first_; }; #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \ !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) template<class Char, class Traits, class Delim> inline ostream_joiner<typename std::decay<Delim>::type, Char, Traits> make_ostream_joiner(std::basic_ostream<Char, Traits>& output, Delim&& delim) { return ostream_joiner<typename std::decay<Delim>::type, Char, Traits>(output, std::forward<Delim>(delim)); } #else template<class Char, class Traits, class Delim> inline ostream_joiner<Delim, Char, Traits> make_ostream_joiner(std::basic_ostream<Char, Traits>& output, const Delim& delim) { return ostream_joiner<Delim, Char, Traits>(output, delim); } #endif } /* io / } / boost / #endif PK��LR�[�'5����� ios_state.hppnu��[��/ Copyright 2002, 2005 Daryle Walker Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_IOS_STATE_HPP #define BOOST_IO_IOS_STATE_HPP #include <boost/config.hpp> #include <boost/io_fwd.hpp> #include <ios> #ifndef BOOST_NO_STD_LOCALE #include <locale> #endif #include <ostream> #include <streambuf> #include <string> namespace boost { namespace io { class ios_flags_saver { public: typedef std::ios_base state_type; typedef std::ios_base::fmtflags aspect_type; explicit ios_flags_saver(state_type& s) : s_save_(s) , a_save_(s.flags()) { } ios_flags_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.flags(a)) { } ~ios_flags_saver() { this->restore(); } void restore() { s_save_.flags(a_save_); } private: ios_flags_saver(const ios_flags_saver&); ios_flags_saver& operator=(const ios_flags_saver&); state_type& s_save_; aspect_type a_save_; }; class ios_precision_saver { public: typedef std::ios_base state_type; typedef std::streamsize aspect_type; explicit ios_precision_saver(state_type& s) : s_save_(s) , a_save_(s.precision()) { } ios_precision_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.precision(a)) { } ~ios_precision_saver() { this->restore(); } void restore() { s_save_.precision(a_save_); } private: ios_precision_saver(const ios_precision_saver&); ios_precision_saver& operator=(const ios_precision_saver&); state_type& s_save_; aspect_type a_save_; }; class ios_width_saver { public: typedef std::ios_base state_type; typedef std::streamsize aspect_type; explicit ios_width_saver(state_type& s) : s_save_(s) , a_save_(s.width()) { } ios_width_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.width(a)) { } ~ios_width_saver() { this->restore(); } void restore() { s_save_.width(a_save_); } private: ios_width_saver(const ios_width_saver&); ios_width_saver& operator=(const ios_width_saver&); state_type& s_save_; aspect_type a_save_; }; template<class Ch, class Tr> class basic_ios_iostate_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef std::ios_base::iostate aspect_type; explicit basic_ios_iostate_saver(state_type& s) : s_save_(s) , a_save_(s.rdstate()) { } basic_ios_iostate_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.rdstate()) { s.clear(a); } ~basic_ios_iostate_saver() { this->restore(); } void restore() { s_save_.clear(a_save_); } private: basic_ios_iostate_saver(const basic_ios_iostate_saver&); basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&); state_type& s_save_; aspect_type a_save_; }; template<class Ch, class Tr> class basic_ios_exception_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef std::ios_base::iostate aspect_type; explicit basic_ios_exception_saver(state_type& s) : s_save_(s) , a_save_(s.exceptions()) { } basic_ios_exception_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.exceptions()) { s.exceptions(a); } ~basic_ios_exception_saver() { this->restore(); } void restore() { s_save_.exceptions(a_save_); } private: basic_ios_exception_saver(const basic_ios_exception_saver&); basic_ios_exception_saver& operator=(const basic_ios_exception_saver&); state_type& s_save_; aspect_type a_save_; }; template<class Ch, class Tr> class basic_ios_tie_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef std::basic_ostream<Ch, Tr> aspect_type; explicit basic_ios_tie_saver(state_type& s) : s_save_(s) , a_save_(s.tie()) { } basic_ios_tie_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.tie(a)) { } ~basic_ios_tie_saver() { this->restore(); } void restore() { s_save_.tie(a_save_); } private: basic_ios_tie_saver(const basic_ios_tie_saver&); basic_ios_tie_saver& operator=(const basic_ios_tie_saver&); state_type& s_save_; aspect_type a_save_; }; template<class Ch, class Tr> class basic_ios_rdbuf_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef std::basic_streambuf<Ch, Tr>* aspect_type; explicit basic_ios_rdbuf_saver(state_type& s) : s_save_(s) , a_save_(s.rdbuf()) { } basic_ios_rdbuf_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.rdbuf(a)) { } ~basic_ios_rdbuf_saver() { this->restore(); } void restore() { s_save_.rdbuf(a_save_); } private: basic_ios_rdbuf_saver(const basic_ios_rdbuf_saver&); basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&); state_type& s_save_; aspect_type a_save_; }; template<class Ch, class Tr> class basic_ios_fill_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef typename state_type::char_type aspect_type; explicit basic_ios_fill_saver(state_type& s) : s_save_(s) , a_save_(s.fill()) { } basic_ios_fill_saver(state_type& s, aspect_type a) : s_save_(s) , a_save_(s.fill(a)) { } ~basic_ios_fill_saver() { this->restore(); } void restore() { s_save_.fill(a_save_); } private: basic_ios_fill_saver(const basic_ios_fill_saver&); basic_ios_fill_saver& operator=(const basic_ios_fill_saver&); state_type& s_save_; aspect_type a_save_; }; #ifndef BOOST_NO_STD_LOCALE template<class Ch, class Tr> class basic_ios_locale_saver { public: typedef std::basic_ios<Ch, Tr> state_type; typedef std::locale aspect_type; explicit basic_ios_locale_saver(state_type& s) : s_save_(s) , a_save_(s.getloc()) { } basic_ios_locale_saver(state_type& s, const aspect_type& a) : s_save_(s) , a_save_(s.imbue(a)) { } ~basic_ios_locale_saver() { this->restore(); } void restore() { s_save_.imbue(a_save_); } private: basic_ios_locale_saver(const basic_ios_locale_saver&); basic_ios_locale_saver& operator=(const basic_ios_locale_saver&); state_type& s_save_; aspect_type a_save_; }; #endif class ios_iword_saver { public: typedef std::ios_base state_type; typedef int index_type; typedef long aspect_type; explicit ios_iword_saver(state_type& s, index_type i) : s_save_(s) , a_save_(s.iword(i)) , i_save_(i) { } ios_iword_saver(state_type& s, index_type i, aspect_type a) : s_save_(s) , a_save_(s.iword(i)) , i_save_(i) { s.iword(i) = a; } ~ios_iword_saver() { this->restore(); } void restore() { s_save_.iword(i_save_) = a_save_; } private: ios_iword_saver(const ios_iword_saver&); ios_iword_saver& operator=(const ios_iword_saver&); state_type& s_save_; aspect_type a_save_; index_type i_save_; }; class ios_pword_saver { public: typedef std::ios_base state_type; typedef int index_type; typedef void* aspect_type; explicit ios_pword_saver(state_type& s, index_type i) : s_save_(s) , a_save_(s.pword(i)) , i_save_(i) { } ios_pword_saver(state_type& s, index_type i, aspect_type a) : s_save_(s) , a_save_(s.pword(i)) , i_save_(i) { s.pword(i) = a; } ~ios_pword_saver() { this->restore(); } void restore() { s_save_.pword(i_save_) = a_save_; } private: ios_pword_saver(const ios_pword_saver&); ios_pword_saver operator=(const ios_pword_saver&); state_type& s_save_; aspect_type a_save_; index_type i_save_; }; class ios_base_all_saver { public: typedef std::ios_base state_type; explicit ios_base_all_saver(state_type& s) : s_save_(s) , a1_save_(s.flags()) , a2_save_(s.precision()) , a3_save_(s.width()) { } ~ios_base_all_saver() { this->restore(); } void restore() { s_save_.width(a3_save_); s_save_.precision(a2_save_); s_save_.flags(a1_save_); } private: ios_base_all_saver(const ios_base_all_saver&); ios_base_all_saver& operator=(const ios_base_all_saver&); state_type& s_save_; state_type::fmtflags a1_save_; std::streamsize a2_save_; std::streamsize a3_save_; }; template<class Ch, class Tr> class basic_ios_all_saver { public: typedef std::basic_ios<Ch, Tr> state_type; explicit basic_ios_all_saver(state_type& s) : s_save_(s) , a1_save_(s.flags()) , a2_save_(s.precision()) , a3_save_(s.width()) , a4_save_(s.rdstate()) , a5_save_(s.exceptions()) , a6_save_(s.tie()) , a7_save_(s.rdbuf()) , a8_save_(s.fill()) #ifndef BOOST_NO_STD_LOCALE , a9_save_(s.getloc()) #endif { } ~basic_ios_all_saver() { this->restore(); } void restore() { #ifndef BOOST_NO_STD_LOCALE s_save_.imbue(a9_save_); #endif s_save_.fill(a8_save_); s_save_.rdbuf(a7_save_); s_save_.tie(a6_save_); s_save_.exceptions(a5_save_); s_save_.clear(a4_save_); s_save_.width(a3_save_); s_save_.precision(a2_save_); s_save_.flags(a1_save_); } private: basic_ios_all_saver(const basic_ios_all_saver&); basic_ios_all_saver& operator=(const basic_ios_all_saver&); state_type& s_save_; typename state_type::fmtflags a1_save_; std::streamsize a2_save_; std::streamsize a3_save_; typename state_type::iostate a4_save_; typename state_type::iostate a5_save_; std::basic_ostream<Ch, Tr>* a6_save_; std::basic_streambuf<Ch, Tr>* a7_save_; typename state_type::char_type a8_save_; #ifndef BOOST_NO_STD_LOCALE std::locale a9_save_; #endif }; class ios_all_word_saver { public: typedef std::ios_base state_type; typedef int index_type; ios_all_word_saver(state_type& s, index_type i) : s_save_(s) , i_save_(i) , a1_save_(s.iword(i)) , a2_save_(s.pword(i)) { } ~ios_all_word_saver() { this->restore(); } void restore() { s_save_.pword(i_save_) = a2_save_; s_save_.iword(i_save_) = a1_save_; } private: ios_all_word_saver(const ios_all_word_saver&); ios_all_word_saver& operator=(const ios_all_word_saver&); state_type& s_save_; index_type i_save_; long a1_save_; void* a2_save_; }; } /* io / } / boost / #endif PK��LR�[�� quoted.hppnu��[��/ Copyright 2010 Beman Dawes Copyright 2019-2020 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_QUOTED_HPP #define BOOST_IO_QUOTED_HPP #include <boost/io/detail/buffer_fill.hpp> #include <boost/io/detail/ostream_guard.hpp> #include <boost/io/ios_state.hpp> namespace boost { namespace io { namespace detail { template<class String, class Char> struct quoted_proxy { String string; Char escape; Char delim; }; template<class Char> struct quoted_state { const Char string; std::size_t size; std::size_t count; }; template<class Char> inline quoted_state<Char> quoted_start(const Char* string, Char escape, Char delim) { const Char* end = string; std::size_t count = 2; for (Char ch; (ch = end) != 0; ++end) { count += 1 + (ch == escape \|\| ch == delim); } quoted_state<Char> state = { string, static_cast<std::size_t>(end - string), count }; return state; } template<class Char, class String> inline quoted_state<Char> quoted_start(const String string, Char escape, Char delim) { const Char* begin = string->data(); std::size_t size = string->size(); std::size_t count = 2; for (const Char it = begin, end = begin + size; it != end; ++it) { Char ch = it; count += 1 + (ch == escape \|\| ch == delim); } quoted_state<Char> state = { begin, size, count }; return state; } template<class Char, class Traits> inline bool quoted_put(std::basic_streambuf<Char, Traits>& buf, const Char string, std::size_t size, std::size_t count, Char escape, Char delim) { if (buf.sputc(delim) == Traits::eof()) { return false; } if (size == count) { if (static_cast<std::size_t>(buf.sputn(string, size)) != size) { return false; } } else { for (const Char* end = string + size; string != end; ++string) { Char ch = string; if ((ch == escape \|\| ch == delim) && buf.sputc(escape) == Traits::eof()) { return false; } if (buf.sputc(ch) == Traits::eof()) { return false; } } } return buf.sputc(delim) != Traits::eof(); } template<class Char, class Traits, class String> inline std::basic_ostream<Char, Traits>& quoted_out(std::basic_ostream<Char, Traits>& os, String string, Char escape, Char delim) { typedef std::basic_ostream<Char, Traits> stream; ostream_guard<Char, Traits> guard(os); typename stream::sentry entry(os); if (entry) { quoted_state<Char> state = boost::io::detail::quoted_start(string, escape, delim); std::basic_streambuf<Char, Traits>& buf = os.rdbuf(); std::size_t width = static_cast<std::size_t>(os.width()); if (width <= state.count) { if (!boost::io::detail::quoted_put(buf, state.string, state.size, state.count, escape, delim)) { return os; } } else if ((os.flags() & stream::adjustfield) == stream::left) { if (!boost::io::detail::quoted_put(buf, state.string, state.size, state.count, escape, delim) \|\| !boost::io::detail::buffer_fill(buf, os.fill(), width - state.count)) { return os; } } else if (!boost::io::detail::buffer_fill(buf, os.fill(), width - state.count) \|\| !boost::io::detail::quoted_put(buf, state.string, state.size, state.count, escape, delim)) { return os; } os.width(0); } guard.release(); return os; } template<class Char, class Traits> inline std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const quoted_proxy<const Char, Char>& proxy) { return boost::io::detail::quoted_out(os, proxy.string, proxy.escape, proxy.delim); } template <class Char, class Traits, class Alloc> inline std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const quoted_proxy<const std::basic_string<Char, Traits, Alloc>, Char>& proxy) { return boost::io::detail::quoted_out(os, proxy.string, proxy.escape, proxy.delim); } template<class Char, class Traits, class Alloc> inline std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const quoted_proxy<std::basic_string<Char, Traits, Alloc>, Char>& proxy) { return boost::io::detail::quoted_out(os, proxy.string, proxy.escape, proxy.delim); } template<class Char, class Traits, class Alloc> inline std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is, const quoted_proxy<std::basic_string<Char, Traits, Alloc>, Char>& proxy) { Char ch; if (!(is >> ch)) { return is; } if (ch != proxy.delim) { is.unget(); return is >> proxy.string; } { boost::io::ios_flags_saver ifs(is); std::noskipws(is); proxy.string->clear(); while ((is >> ch) && ch != proxy.delim) { if (ch == proxy.escape && !(is >> ch)) { break; } proxy.string->push_back(ch); } } return is; } } /* detail / template<class Char, class Traits, class Alloc> inline detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>, Char> quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape='\\', Char delim='\"') { detail::quoted_proxy<const std::basic_string<Char, Traits, Alloc>, Char> proxy = { &s, escape, delim }; return proxy; } template<class Char, class Traits, class Alloc> inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>, Char> quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape='\\', Char delim='\"') { detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>, Char> proxy = { &s, escape, delim }; return proxy; } template<class Char> inline detail::quoted_proxy<const Char, Char> quoted(const Char* s, Char escape='\\', Char delim='\"') { detail::quoted_proxy<const Char, Char> proxy = { s, escape, delim }; return proxy; } } / io / } / boost / #endif PK��LR�[A�o��ostream_put.hppnu��[��/ Copyright 2019 Glen Joseph Fernandes (glenjofe@gmail.com) Distributed under the Boost Software License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt) / #ifndef BOOST_IO_OSTREAM_PUT_HPP #define BOOST_IO_OSTREAM_PUT_HPP #include <boost/io/detail/buffer_fill.hpp> #include <boost/io/detail/ostream_guard.hpp> namespace boost { namespace io { template<class charT, class traits> inline std::basic_ostream<charT, traits>& ostream_put(std::basic_ostream<charT, traits>& os, const charT data, std::size_t size) { typedef std::basic_ostream<charT, traits> stream; detail::ostream_guard<charT, traits> guard(os); typename stream::sentry entry(os); if (entry) { std::basic_streambuf<charT, traits>& buf = os.rdbuf(); std::size_t width = static_cast<std::size_t>(os.width()); if (width <= size) { if (static_cast<std::size_t>(buf.sputn(data, size)) != size) { return os; } } else if ((os.flags() & stream::adjustfield) == stream::left) { if (static_cast<std::size_t>(buf.sputn(data, size)) != size \|\| !detail::buffer_fill(buf, os.fill(), width - size)) { return os; } } else if (!detail::buffer_fill(buf, os.fill(), width - size) \|\| static_cast<std::size_t>(buf.sputn(data, size)) != size) { return os; } os.width(0); } guard.release(); return os; } } / io / } / boost / #endif PK��M!\k7��S'��S'��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��M!\k6]� �� 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��M!\Nk�\��\��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��M!\��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��M!\��M��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��M!\kC4��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��M!\�HQ1A��1A�� 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��M!\�n�� 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��M!\�9��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��M!\F�Pa��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��M!\ g�j'��j'��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��M!\4�=�C��C�� 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��M!\��7$��$��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��M!\��i��i�� 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��M!\�� 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��M!\Y��T��T��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��M!\�X�� io.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_HPP #define BOOST_GEOMETRY_IO_HPP #include <boost/geometry/io/wkt/read.hpp> #include <boost/geometry/io/wkt/write.hpp> namespace boost { namespace geometry { struct format_wkt {}; struct format_wkb {}; // TODO struct format_dsv {}; // TODO #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Tag, typename Geometry> struct read { }; template <typename Geometry> struct read<format_wkt, Geometry> { static inline void apply(Geometry& geometry, std::string const& wkt) { read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry); } }; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH template <typename Format, typename Geometry> inline void read(Geometry& geometry, std::string const& wkt) { geometry::concepts::check<Geometry>(); dispatch::read<Format, Geometry>::apply(geometry, wkt); } // TODO: wriite }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_HPP PK��M!\�}�d��d�� 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��M!\��ۜ{��{��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��M!\_g<L&��&��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��M!\��˷��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��M!\�c��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��M!\.��4��4��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��M!\��[D��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��M!\t�7��7��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��M!\��P��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��M!\ͼ�Y.'��.'��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��M!\YT� �� 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��u!\��Qg��svg/write_svg_multi.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands. // This file was modified by Oracle on 2016. // Modifications copyright (c) 2016, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP #define BOOST_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP // THIS FILE WAS LEFT HERE FOR BACKWARD COMPATIBILITY #include <boost/geometry/io/svg/write.hpp> #endif // BOOST_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP PK��u!\��\�/��/�� svg/write.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland. // This file was modified by Oracle on 2016-2020. // Modifications copyright (c) 2016-2020, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_SVG_WRITE_HPP #define BOOST_GEOMETRY_IO_SVG_WRITE_HPP #include <ostream> #include <string> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> #include <boost/variant/apply_visitor.hpp> #include <boost/variant/static_visitor.hpp> #include <boost/variant/variant_fwd.hpp> #include <boost/geometry/algorithms/detail/interior_iterator.hpp> #include <boost/geometry/core/exterior_ring.hpp> #include <boost/geometry/core/interior_rings.hpp> #include <boost/geometry/core/ring_type.hpp> #include <boost/geometry/core/static_assert.hpp> #include <boost/geometry/geometries/concepts/check.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace svg { template <typename Point> struct svg_point { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& p, std::string const& style, double size) { os << "<circle cx=\"" << geometry::get<0>(p) << "\" cy=\"" << geometry::get<1>(p) << "\" r=\"" << (size < 0 ? 5 : size) << "\" style=\"" << style << "\"/>"; } }; template <typename Box> struct svg_box { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Box const& box, std::string const& style, double) { // Prevent invisible boxes, making them >=1, using "max" BOOST_USING_STD_MAX(); typedef typename coordinate_type<Box>::type ct; ct x = geometry::get<geometry::min_corner, 0>(box); ct y = geometry::get<geometry::min_corner, 1>(box); ct width = max BOOST_PREVENT_MACRO_SUBSTITUTION (ct(1), geometry::get<geometry::max_corner, 0>(box) - x); ct height = max BOOST_PREVENT_MACRO_SUBSTITUTION (ct(1), geometry::get<geometry::max_corner, 1>(box) - y); os << "<rect x=\"" << x << "\" y=\"" << y << "\" width=\"" << width << "\" height=\"" << height << "\" style=\"" << style << "\"/>"; } }; template <typename Segment> struct svg_segment { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Segment const& segment, std::string const& style, double) { typedef typename coordinate_type<Segment>::type ct; ct x1 = geometry::get<0, 0>(segment); ct y1 = geometry::get<0, 1>(segment); ct x2 = geometry::get<1, 0>(segment); ct y2 = geometry::get<1, 1>(segment); os << "<line x1=\"" << x1 << "\" y1=\"" << y1 << "\" x2=\"" << x2 << "\" y2=\"" << y2 << "\" style=\"" << style << "\"/>"; } }; /! \brief Stream ranges as SVG \note policy is used to select type (polyline/polygon) / template <typename Range, typename Policy> struct svg_range { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Range const& range, std::string const& style, double) { typedef typename boost::range_iterator<Range const>::type iterator; bool first = true; os << "<" << Policy::prefix() << " points=\""; for (iterator it = boost::begin(range); it != boost::end(range); ++it, first = false) { os << (first ? "" : " " ) << geometry::get<0>(it) << "," << geometry::get<1>(it); } os << "\" style=\"" << style << Policy::style() << "\"/>"; } }; template <typename Polygon> struct svg_poly { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Polygon const& polygon, std::string const& style, double) { typedef typename geometry::ring_type<Polygon>::type ring_type; typedef typename boost::range_iterator<ring_type const>::type iterator_type; bool first = true; os << "<g fill-rule=\"evenodd\"><path d=\""; ring_type const& ring = geometry::exterior_ring(polygon); for (iterator_type it = boost::begin(ring); it != boost::end(ring); ++it, first = false) { os << (first ? "M" : " L") << " " << geometry::get<0>(it) << "," << geometry::get<1>(it); } // Inner rings: { typename interior_return_type<Polygon const>::type rings = interior_rings(polygon); for (typename detail::interior_iterator<Polygon const>::type rit = boost::begin(rings); rit != boost::end(rings); ++rit) { first = true; for (typename detail::interior_ring_iterator<Polygon const>::type it = boost::begin(rit); it != boost::end(rit); ++it, first = false) { os << (first ? "M" : " L") << " " << geometry::get<0>(it) << "," << geometry::get<1>(it); } } } os << " z \" style=\"" << style << "\"/></g>"; } }; struct prefix_linestring { static inline const char* prefix() { return "polyline"; } static inline const char* style() { return ";fill:none"; } }; struct prefix_ring { static inline const char* prefix() { return "polygon"; } static inline const char* style() { return ""; } }; template <typename MultiGeometry, typename Policy> struct svg_multi { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, MultiGeometry const& multi, std::string const& style, double size) { for (typename boost::range_iterator<MultiGeometry const>::type it = boost::begin(multi); it != boost::end(multi); ++it) { Policy::apply(os, it, style, size); } } }; }} // namespace detail::svg #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { /! \brief Dispatching base struct for SVG streaming, specialized below per geometry type \details Specializations should implement a static method "stream" to stream a geometry The static method should have the signature: template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, G const& geometry) / template <typename Geometry, typename Tag = typename tag<Geometry>::type> struct svg { BOOST_GEOMETRY_STATIC_ASSERT_FALSE( "Not or not yet implemented for this Geometry type.", Geometry, Tag); }; template <typename Point> struct svg<Point, point_tag> : detail::svg::svg_point<Point> {}; template <typename Segment> struct svg<Segment, segment_tag> : detail::svg::svg_segment<Segment> {}; template <typename Box> struct svg<Box, box_tag> : detail::svg::svg_box<Box> {}; template <typename Linestring> struct svg<Linestring, linestring_tag> : detail::svg::svg_range<Linestring, detail::svg::prefix_linestring> {}; template <typename Ring> struct svg<Ring, ring_tag> : detail::svg::svg_range<Ring, detail::svg::prefix_ring> {}; template <typename Polygon> struct svg<Polygon, polygon_tag> : detail::svg::svg_poly<Polygon> {}; template <typename MultiPoint> struct svg<MultiPoint, multi_point_tag> : detail::svg::svg_multi < MultiPoint, detail::svg::svg_point < typename boost::range_value<MultiPoint>::type > > {}; template <typename MultiLinestring> struct svg<MultiLinestring, multi_linestring_tag> : detail::svg::svg_multi < MultiLinestring, detail::svg::svg_range < typename boost::range_value<MultiLinestring>::type, detail::svg::prefix_linestring > > {}; template <typename MultiPolygon> struct svg<MultiPolygon, multi_polygon_tag> : detail::svg::svg_multi < MultiPolygon, detail::svg::svg_poly < typename boost::range_value<MultiPolygon>::type > > {}; template <typename Geometry> struct devarianted_svg { template <typename OutputStream> static inline void apply(OutputStream& os, Geometry const& geometry, std::string const& style, double size) { svg<Geometry>::apply(os, geometry, style, size); } }; template <BOOST_VARIANT_ENUM_PARAMS(typename T)> struct devarianted_svg<variant<BOOST_VARIANT_ENUM_PARAMS(T)> > { template <typename OutputStream> struct visitor: static_visitor<void> { OutputStream& m_os; std::string const& m_style; double m_size; visitor(OutputStream& os, std::string const& style, double size) : m_os(os) , m_style(style) , m_size(size) {} template <typename Geometry> inline void operator()(Geometry const& geometry) const { devarianted_svg<Geometry>::apply(m_os, geometry, m_style, m_size); } }; template <typename OutputStream> static inline void apply( OutputStream& os, variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry, std::string const& style, double size ) { boost::apply_visitor(visitor<OutputStream>(os, style, size), geometry); } }; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH /! \brief Generic geometry template manipulator class, takes corresponding output class from traits class \ingroup svg \details Stream manipulator, streams geometry classes as SVG (Scalable Vector Graphics) / template <typename Geometry> class svg_manipulator { public: inline svg_manipulator(Geometry const& g, std::string const& style, double size) : m_geometry(g) , m_style(style) , m_size(size) {} template <typename Char, typename Traits> inline friend std::basic_ostream<Char, Traits>& operator<<( std::basic_ostream<Char, Traits>& os, svg_manipulator const& m) { dispatch::devarianted_svg<Geometry>::apply(os, m.m_geometry, m.m_style, m.m_size); os.flush(); return os; } private: Geometry const& m_geometry; std::string const& m_style; double m_size; }; /! \brief Manipulator to stream geometries as SVG \tparam Geometry \tparam_geometry \param geometry \param_geometry \param style String containing verbatim SVG style information \param size Optional size (used for SVG points) in SVG pixels. For linestrings, specify linewidth in the SVG style information \ingroup svg / template <typename Geometry> inline svg_manipulator<Geometry> svg(Geometry const& geometry, std::string const& style, double size = -1.0) { concepts::check<Geometry const>(); return svg_manipulator<Geometry>(geometry, style, size); } }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_SVG_WRITE_HPP PK��u!\\|��svg/write_svg.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland. // This file was modified by Oracle on 2016. // Modifications copyright (c) 2016, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_SVG_WRITE_SVG_HPP #define BOOST_GEOMETRY_IO_SVG_WRITE_SVG_HPP // THIS FILE WAS LEFT HERE FOR BACKWARD COMPATIBILITY #include <boost/geometry/io/svg/write.hpp> #endif // BOOST_GEOMETRY_IO_SVG_WRITE_SVG_HPP PK��u!\��CZ'7��'7��svg/svg_mapper.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2009-2015 Barend Gehrels, Amsterdam, the Netherlands. // This file was modified by Oracle on 2015-2020. // Modifications copyright (c) 2015-2020, Oracle and/or its affiliates. // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_SVG_MAPPER_HPP #define BOOST_GEOMETRY_IO_SVG_MAPPER_HPP #include <cstdio> #include <type_traits> #include <vector> #include <boost/algorithm/string/classification.hpp> #include <boost/algorithm/string/split.hpp> #include <boost/config.hpp> #include <boost/noncopyable.hpp> #include <boost/scoped_ptr.hpp> #include <boost/geometry/core/static_assert.hpp> #include <boost/geometry/core/tags.hpp> #include <boost/geometry/core/tag_cast.hpp> #include <boost/geometry/algorithms/envelope.hpp> #include <boost/geometry/algorithms/expand.hpp> #include <boost/geometry/algorithms/is_empty.hpp> #include <boost/geometry/algorithms/transform.hpp> #include <boost/geometry/strategies/transform/map_transformer.hpp> #include <boost/geometry/views/segment_view.hpp> #include <boost/geometry/io/svg/write.hpp> // Helper geometries (all points are transformed to svg-points) #include <boost/geometry/geometries/geometries.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename GeometryTag, typename Geometry, typename SvgPoint> struct svg_map { BOOST_GEOMETRY_STATIC_ASSERT_FALSE( "Not or not yet implemented for this Geometry type.", GeometryTag, Geometry); }; template <typename Point, typename SvgPoint> struct svg_map<point_tag, Point, SvgPoint> { template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, Point const& point, TransformStrategy const& strategy) { SvgPoint ipoint; geometry::transform(point, ipoint, strategy); stream << geometry::svg(ipoint, style, size) << std::endl; } }; template <typename BoxSeg1, typename BoxSeg2, typename SvgPoint> struct svg_map_box_seg { template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, BoxSeg1 const& box_seg, TransformStrategy const& strategy) { BoxSeg2 ibox_seg; // Fix bug in gcc compiler warning for possible uninitialization #if defined(BOOST_GCC) geometry::assign_zero(ibox_seg); #endif geometry::transform(box_seg, ibox_seg, strategy); stream << geometry::svg(ibox_seg, style, size) << std::endl; } }; template <typename Box, typename SvgPoint> struct svg_map<box_tag, Box, SvgPoint> : svg_map_box_seg<Box, model::box<SvgPoint>, SvgPoint> {}; template <typename Segment, typename SvgPoint> struct svg_map<segment_tag, Segment, SvgPoint> : svg_map_box_seg<Segment, model::segment<SvgPoint>, SvgPoint> {}; template <typename Range1, typename Range2, typename SvgPoint> struct svg_map_range { template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, Range1 const& range, TransformStrategy const& strategy) { Range2 irange; geometry::transform(range, irange, strategy); stream << geometry::svg(irange, style, size) << std::endl; } }; template <typename Ring, typename SvgPoint> struct svg_map<ring_tag, Ring, SvgPoint> : svg_map_range<Ring, model::ring<SvgPoint>, SvgPoint> {}; template <typename Linestring, typename SvgPoint> struct svg_map<linestring_tag, Linestring, SvgPoint> : svg_map_range<Linestring, model::linestring<SvgPoint>, SvgPoint> {}; template <typename Polygon, typename SvgPoint> struct svg_map<polygon_tag, Polygon, SvgPoint> { template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, Polygon const& polygon, TransformStrategy const& strategy) { model::polygon<SvgPoint> ipoly; geometry::transform(polygon, ipoly, strategy); stream << geometry::svg(ipoly, style, size) << std::endl; } }; template <typename Multi, typename SvgPoint> struct svg_map<multi_tag, Multi, SvgPoint> { typedef typename single_tag_of < typename geometry::tag<Multi>::type >::type stag; template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, Multi const& multi, TransformStrategy const& strategy) { for (typename boost::range_iterator<Multi const>::type it = boost::begin(multi); it != boost::end(multi); ++it) { svg_map < stag, typename boost::range_value<Multi>::type, SvgPoint >::apply(stream, style, size, it, strategy); } } }; template <typename SvgPoint, typename Geometry> struct devarianted_svg_map { template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, Geometry const& geometry, TransformStrategy const& strategy) { svg_map < typename tag_cast < typename tag<Geometry>::type, multi_tag >::type, typename std::remove_const<Geometry>::type, SvgPoint >::apply(stream, style, size, geometry, strategy); } }; template <typename SvgPoint, BOOST_VARIANT_ENUM_PARAMS(typename T)> struct devarianted_svg_map<SvgPoint, variant<BOOST_VARIANT_ENUM_PARAMS(T)> > { template <typename TransformStrategy> struct visitor: static_visitor<void> { std::ostream& m_os; std::string const& m_style; double m_size; TransformStrategy const& m_strategy; visitor(std::ostream& os, std::string const& style, double size, TransformStrategy const& strategy) : m_os(os) , m_style(style) , m_size(size) , m_strategy(strategy) {} template <typename Geometry> inline void operator()(Geometry const& geometry) const { devarianted_svg_map<SvgPoint, Geometry>::apply(m_os, m_style, m_size, geometry, m_strategy); } }; template <typename TransformStrategy> static inline void apply(std::ostream& stream, std::string const& style, double size, variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry, TransformStrategy const& strategy) { boost::apply_visitor(visitor<TransformStrategy>(stream, style, size, strategy), geometry); } }; } // namespace dispatch #endif template <typename SvgPoint, typename Geometry, typename TransformStrategy> inline void svg_map(std::ostream& stream, std::string const& style, double size, Geometry const& geometry, TransformStrategy const& strategy) { dispatch::devarianted_svg_map<SvgPoint, Geometry>::apply(stream, style, size, geometry, strategy); } /! \brief Helper class to create SVG maps \tparam Point Point type, for input geometries. \tparam SameScale Boolean flag indicating if horizontal and vertical scale should be the same. The default value is true \tparam SvgCoordinateType Coordinate type of SVG points. SVG is capable to use floating point coordinates. Therefore the default value is double \ingroup svg \qbk{[include reference/io/svg.qbk]} / template < typename Point, bool SameScale = true, typename SvgCoordinateType = double > class svg_mapper : boost::noncopyable { typedef model::point<SvgCoordinateType, 2, cs::cartesian> svg_point_type; typedef typename geometry::select_most_precise < typename coordinate_type<Point>::type, double >::type calculation_type; typedef strategy::transform::map_transformer < calculation_type, geometry::dimension<Point>::type::value, geometry::dimension<Point>::type::value, true, SameScale > transformer_type; model::box<Point> m_bounding_box; boost::scoped_ptr<transformer_type> m_matrix; std::ostream& m_stream; SvgCoordinateType m_width, m_height; std::string m_width_height; // for <svg> tag only, defaults to 2x 100% void init_matrix() { if (! m_matrix) { m_matrix.reset(new transformer_type(m_bounding_box, m_width, m_height)); m_stream << "<?xml version=\"1.0\" standalone=\"no\"?>" << std::endl << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"" << std::endl << "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">" << std::endl << "<svg " << m_width_height << " version=\"1.1\"" << std::endl << "xmlns=\"http://www.w3.org/2000/svg\"" << std::endl << "xmlns:xlink=\"http://www.w3.org/1999/xlink\"" << ">" << std::endl; } } public : /! \brief Constructor, initializing the SVG map. Opens and initializes the SVG. Should be called explicitly. \param stream Output stream, should be a stream already open \param width Width of the SVG map (in SVG pixels) \param height Height of the SVG map (in SVG pixels) \param width_height Optional information to increase width and/or height / svg_mapper(std::ostream& stream , SvgCoordinateType width , SvgCoordinateType height , std::string const& width_height = "width=\"100%\" height=\"100%\"") : m_stream(stream) , m_width(width) , m_height(height) , m_width_height(width_height) { assign_inverse(m_bounding_box); } /! \brief Destructor, called automatically. Closes the SVG by streaming <\/svg> / virtual ~svg_mapper() { m_stream << "</svg>" << std::endl; } /! \brief Adds a geometry to the transformation matrix. After doing this, the specified geometry can be mapped fully into the SVG map \tparam Geometry \tparam_geometry \param geometry \param_geometry / template <typename Geometry> void add(Geometry const& geometry) { if (! geometry::is_empty(geometry)) { expand(m_bounding_box, return_envelope < model::box<Point> >(geometry)); } } /! \brief Maps a geometry into the SVG map using the specified style \tparam Geometry \tparam_geometry \param geometry \param_geometry \param style String containing verbatim SVG style information \param size Optional size (used for SVG points) in SVG pixels. For linestrings, specify linewidth in the SVG style information / template <typename Geometry> void map(Geometry const& geometry, std::string const& style, double size = -1.0) { init_matrix(); svg_map<svg_point_type>(m_stream, style, size, geometry, m_matrix); } /! \brief Adds a text to the SVG map \tparam TextPoint \tparam_point \param point Location of the text (in map units) \param s The text itself \param style String containing verbatim SVG style information, of the text \param offset_x Offset in SVG pixels, defaults to 0 \param offset_y Offset in SVG pixels, defaults to 0 \param lineheight Line height in SVG pixels, in case the text contains \n / template <typename TextPoint> void text(TextPoint const& point, std::string const& s, std::string const& style, double offset_x = 0.0, double offset_y = 0.0, double lineheight = 10.0) { init_matrix(); svg_point_type map_point; transform(point, map_point, m_matrix); m_stream << "<text style=\"" << style << "\"" << " x=\"" << get<0>(map_point) + offset_x << "\"" << " y=\"" << get<1>(map_point) + offset_y << "\"" << ">"; if (s.find("\n") == std::string::npos) { m_stream << s; } else { // Multi-line modus std::vector<std::string> splitted; boost::split(splitted, s, boost::is_any_of("\n")); for (std::vector<std::string>::const_iterator it = splitted.begin(); it != splitted.end(); ++it, offset_y += lineheight) { m_stream << "<tspan x=\"" << get<0>(map_point) + offset_x << "\"" << " y=\"" << get<1>(map_point) + offset_y << "\"" << ">" << it << "</tspan>"; } } m_stream << "</text>" << std::endl; } }; }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_SVG_MAPPER_HPP PK��u!\@�m/��/�� dsv/write.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland. // This file was modified by Oracle on 2018-2020. // Modifications copyright (c) 2018-2020, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_DSV_WRITE_HPP #define BOOST_GEOMETRY_IO_DSV_WRITE_HPP #include <cstddef> #include <ostream> #include <string> #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> #include <boost/geometry/algorithms/detail/interior_iterator.hpp> #include <boost/geometry/core/exterior_ring.hpp> #include <boost/geometry/core/interior_rings.hpp> #include <boost/geometry/core/ring_type.hpp> #include <boost/geometry/core/tag_cast.hpp> #include <boost/geometry/core/tags.hpp> #include <boost/geometry/geometries/concepts/check.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace dsv { struct dsv_settings { std::string coordinate_separator; std::string point_open; std::string point_close; std::string point_separator; std::string list_open; std::string list_close; std::string list_separator; dsv_settings(std::string const& sep , std::string const& open , std::string const& close , std::string const& psep , std::string const& lopen , std::string const& lclose , std::string const& lsep ) : coordinate_separator(sep) , point_open(open) , point_close(close) , point_separator(psep) , list_open(lopen) , list_close(lclose) , list_separator(lsep) {} }; /! \brief Stream coordinate of a point as \ref DSV / template <typename Point, std::size_t Dimension, std::size_t Count> struct stream_coordinate { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& point, dsv_settings const& settings) { os << (Dimension > 0 ? settings.coordinate_separator : "") << get<Dimension>(point); stream_coordinate < Point, Dimension + 1, Count >::apply(os, point, settings); } }; template <typename Point, std::size_t Count> struct stream_coordinate<Point, Count, Count> { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>&, Point const&, dsv_settings const& ) { } }; /! \brief Stream indexed coordinate of a box/segment as \ref DSV / template < typename Geometry, std::size_t Index, std::size_t Dimension, std::size_t Count > struct stream_indexed { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Geometry const& geometry, dsv_settings const& settings) { os << (Dimension > 0 ? settings.coordinate_separator : "") << get<Index, Dimension>(geometry); stream_indexed < Geometry, Index, Dimension + 1, Count >::apply(os, geometry, settings); } }; template <typename Geometry, std::size_t Index, std::size_t Count> struct stream_indexed<Geometry, Index, Count, Count> { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>&, Geometry const&, dsv_settings const& ) { } }; /! \brief Stream points as \ref DSV / template <typename Point> struct dsv_point { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& p, dsv_settings const& settings) { os << settings.point_open; stream_coordinate<Point, 0, dimension<Point>::type::value>::apply(os, p, settings); os << settings.point_close; } }; /! \brief Stream ranges as DSV \note policy is used to stream prefix/postfix, enabling derived classes to override this / template <typename Range> struct dsv_range { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Range const& range, dsv_settings const& settings) { typedef typename boost::range_iterator<Range const>::type iterator_type; bool first = true; os << settings.list_open; for (iterator_type it = boost::begin(range); it != boost::end(range); ++it) { os << (first ? "" : settings.point_separator) << settings.point_open; stream_coordinate < point_type, 0, dimension<point_type>::type::value >::apply(os, it, settings); os << settings.point_close; first = false; } os << settings.list_close; } private: typedef typename boost::range_value<Range>::type point_type; }; /! \brief Stream sequence of points as DSV-part, e.g. (1 2),(3 4) \note Used in polygon, all multi-geometries / template <typename Polygon> struct dsv_poly { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Polygon const& poly, dsv_settings const& settings) { typedef typename ring_type<Polygon>::type ring; os << settings.list_open; dsv_range<ring>::apply(os, exterior_ring(poly), settings); typename interior_return_type<Polygon const>::type rings = interior_rings(poly); for (typename detail::interior_iterator<Polygon const>::type it = boost::begin(rings); it != boost::end(rings); ++it) { os << settings.list_separator; dsv_range<ring>::apply(os, it, settings); } os << settings.list_close; } }; template <typename Geometry, std::size_t Index> struct dsv_per_index { typedef typename point_type<Geometry>::type point_type; template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Geometry const& geometry, dsv_settings const& settings) { os << settings.point_open; stream_indexed < Geometry, Index, 0, dimension<Geometry>::type::value >::apply(os, geometry, settings); os << settings.point_close; } }; template <typename Geometry> struct dsv_indexed { typedef typename point_type<Geometry>::type point_type; template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Geometry const& geometry, dsv_settings const& settings) { os << settings.list_open; dsv_per_index<Geometry, 0>::apply(os, geometry, settings); os << settings.point_separator; dsv_per_index<Geometry, 1>::apply(os, geometry, settings); os << settings.list_close; } }; }} // namespace detail::dsv #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Tag, typename Geometry> struct dsv {}; template <typename Point> struct dsv<point_tag, Point> : detail::dsv::dsv_point<Point> {}; template <typename Linestring> struct dsv<linestring_tag, Linestring> : detail::dsv::dsv_range<Linestring> {}; template <typename Box> struct dsv<box_tag, Box> : detail::dsv::dsv_indexed<Box> {}; template <typename Segment> struct dsv<segment_tag, Segment> : detail::dsv::dsv_indexed<Segment> {}; template <typename Ring> struct dsv<ring_tag, Ring> : detail::dsv::dsv_range<Ring> {}; template <typename Polygon> struct dsv<polygon_tag, Polygon> : detail::dsv::dsv_poly<Polygon> {}; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace dsv { // FIXME: This class is not copyable/assignable but it is used as such --mloskot template <typename Geometry> class dsv_manipulator { public: inline dsv_manipulator(Geometry const& g, dsv_settings const& settings) : m_geometry(g) , m_settings(settings) {} template <typename Char, typename Traits> inline friend std::basic_ostream<Char, Traits>& operator<<( std::basic_ostream<Char, Traits>& os, dsv_manipulator const& m) { dispatch::dsv < typename tag_cast < typename tag<Geometry>::type, multi_tag >::type, Geometry >::apply(os, m.m_geometry, m.m_settings); os.flush(); return os; } private: Geometry const& m_geometry; dsv_settings m_settings; }; template <typename MultiGeometry> struct dsv_multi { typedef dispatch::dsv < typename single_tag_of < typename tag<MultiGeometry>::type >::type, typename boost::range_value<MultiGeometry>::type > dispatch_one; typedef typename boost::range_iterator < MultiGeometry const >::type iterator; template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, MultiGeometry const& multi, dsv_settings const& settings) { os << settings.list_open; bool first = true; for(iterator it = boost::begin(multi); it != boost::end(multi); ++it, first = false) { os << (first ? "" : settings.list_separator); dispatch_one::apply(os, it, settings); } os << settings.list_close; } }; }} // namespace detail::dsv #endif // DOXYGEN_NO_DETAIL // TODO: The alternative to this could be a forward declaration of dispatch::dsv<> // or braking the code into the interface and implementation part #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Geometry> struct dsv<multi_tag, Geometry> : detail::dsv::dsv_multi<Geometry> {}; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH /! \brief Main DSV-streaming function \details DSV stands for Delimiter Separated Values. Geometries can be streamed as DSV. There are defaults for all separators. \note Useful for examples and testing purposes \note With this function GeoJSON objects can be created, using the right delimiters \ingroup dsv / template <typename Geometry> inline detail::dsv::dsv_manipulator<Geometry> dsv(Geometry const& geometry , std::string const& coordinate_separator = ", " , std::string const& point_open = "(" , std::string const& point_close = ")" , std::string const& point_separator = ", " , std::string const& list_open = "(" , std::string const& list_close = ")" , std::string const& list_separator = ", " ) { concepts::check<Geometry const>(); return detail::dsv::dsv_manipulator<Geometry>(geometry, detail::dsv::dsv_settings(coordinate_separator, point_open, point_close, point_separator, list_open, list_close, list_separator)); } }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_DSV_WRITE_HPP PK��u!\��wkt/wkt.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_WKT_WKT_HPP #define BOOST_GEOMETRY_IO_WKT_WKT_HPP #include <boost/geometry/io/wkt/read.hpp> #include <boost/geometry/io/wkt/write.hpp> // BSG 2011-02-03 // We don't include stream.hpp by default. That tries to stream anything not known // by default and reports errors. // Users can include stream.hpp themselves (if they want to) #endif // BOOST_GEOMETRY_IO_WKT_WKT_HPP PK��u!\�_��;��;�� wkt/write.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2017 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2017 Bruno Lalande, Paris, France. // Copyright (c) 2009-2017 Mateusz Loskot, London, UK. // Copyright (c) 2014-2017 Adam Wulkiewicz, Lodz, Poland. // This file was modified by Oracle on 2015-2020. // Modifications copyright (c) 2015-2020, Oracle and/or its affiliates. // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_WKT_WRITE_HPP #define BOOST_GEOMETRY_IO_WKT_WRITE_HPP #include <ostream> #include <string> #include <boost/array.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/size.hpp> #include <boost/range/value_type.hpp> #include <boost/variant/apply_visitor.hpp> #include <boost/variant/static_visitor.hpp> #include <boost/variant/variant_fwd.hpp> #include <boost/geometry/algorithms/detail/interior_iterator.hpp> #include <boost/geometry/algorithms/assign.hpp> #include <boost/geometry/algorithms/convert.hpp> #include <boost/geometry/algorithms/detail/disjoint/point_point.hpp> #include <boost/geometry/algorithms/not_implemented.hpp> #include <boost/geometry/core/exterior_ring.hpp> #include <boost/geometry/core/interior_rings.hpp> #include <boost/geometry/core/ring_type.hpp> #include <boost/geometry/core/tags.hpp> #include <boost/geometry/geometries/concepts/check.hpp> #include <boost/geometry/geometries/ring.hpp> #include <boost/geometry/io/wkt/detail/prefix.hpp> #include <boost/geometry/util/condition.hpp> #include <boost/geometry/util/type_traits.hpp> namespace boost { namespace geometry { // Silence warning C4512: 'boost::geometry::wkt_manipulator<Geometry>' : assignment operator could not be generated #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable : 4512) #endif #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace wkt { template <typename P, int I, int Count> struct stream_coordinate { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, P const& p) { os << (I > 0 ? " " : "") << get<I>(p); stream_coordinate<P, I + 1, Count>::apply(os, p); } }; template <typename P, int Count> struct stream_coordinate<P, Count, Count> { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>&, P const&) {} }; struct prefix_linestring_par { static inline const char* apply() { return "LINESTRING("; } }; struct prefix_ring_par_par { // Note, double parentheses are intentional, indicating WKT ring begin/end static inline const char* apply() { return "POLYGON(("; } }; struct opening_parenthesis { static inline const char* apply() { return "("; } }; struct closing_parenthesis { static inline const char* apply() { return ")"; } }; struct double_closing_parenthesis { static inline const char* apply() { return "))"; } }; /! \brief Stream points as \ref WKT / template <typename Point, typename Policy> struct wkt_point { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& p, bool) { os << Policy::apply() << "("; stream_coordinate<Point, 0, dimension<Point>::type::value>::apply(os, p); os << ")"; } }; /! \brief Stream ranges as WKT \note policy is used to stream prefix/postfix, enabling derived classes to override this / template < typename Range, bool ForceClosurePossible, typename PrefixPolicy, typename SuffixPolicy > struct wkt_range { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Range const& range, bool force_closure = ForceClosurePossible) { typedef typename boost::range_iterator<Range const>::type iterator_type; typedef stream_coordinate < point_type, 0, dimension<point_type>::type::value > stream_type; bool first = true; os << PrefixPolicy::apply(); // TODO: check EMPTY here iterator_type begin = boost::begin(range); iterator_type end = boost::end(range); for (iterator_type it = begin; it != end; ++it) { os << (first ? "" : ","); stream_type::apply(os, it); first = false; } // optionally, close range to ring by repeating the first point if (BOOST_GEOMETRY_CONDITION(ForceClosurePossible) && force_closure && boost::size(range) > 1 && wkt_range::disjoint(begin, (end - 1))) { os << ","; stream_type::apply(os, begin); } os << SuffixPolicy::apply(); } private: typedef typename boost::range_value<Range>::type point_type; static inline bool disjoint(point_type const& p1, point_type const& p2) { // TODO: pass strategy typedef typename strategy::disjoint::services::default_strategy < point_type, point_type >::type strategy_type; return detail::disjoint::disjoint_point_point(p1, p2, strategy_type()); } }; /! \brief Stream sequence of points as WKT-part, e.g. (1 2),(3 4) \note Used in polygon, all multi-geometries / template <typename Range, bool ForceClosurePossible = true> struct wkt_sequence : wkt_range < Range, ForceClosurePossible, opening_parenthesis, closing_parenthesis > {}; template <typename Polygon, typename PrefixPolicy> struct wkt_poly { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Polygon const& poly, bool force_closure) { typedef typename ring_type<Polygon const>::type ring; os << PrefixPolicy::apply(); // TODO: check EMPTY here os << "("; wkt_sequence<ring>::apply(os, exterior_ring(poly), force_closure); typename interior_return_type<Polygon const>::type rings = interior_rings(poly); for (typename detail::interior_iterator<Polygon const>::type it = boost::begin(rings); it != boost::end(rings); ++it) { os << ","; wkt_sequence<ring>::apply(os, it, force_closure); } os << ")"; } }; template <typename Multi, typename StreamPolicy, typename PrefixPolicy> struct wkt_multi { template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Multi const& geometry, bool force_closure) { os << PrefixPolicy::apply(); // TODO: check EMPTY here os << "("; for (typename boost::range_iterator<Multi const>::type it = boost::begin(geometry); it != boost::end(geometry); ++it) { if (it != boost::begin(geometry)) { os << ","; } StreamPolicy::apply(os, it, force_closure); } os << ")"; } }; template <typename Box> struct wkt_box { typedef typename point_type<Box>::type point_type; template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Box const& box, bool force_closure) { // Convert to a clockwire ring, then stream. // Never close it based on last point (box might be empty and // that should result in POLYGON((0 0,0 0,0 0,0 0, ...)) ) if (force_closure) { do_apply<model::ring<point_type, true, true> >(os, box); } else { do_apply<model::ring<point_type, true, false> >(os, box); } } private: inline wkt_box() { // Only streaming of boxes with two dimensions is support, otherwise it is a polyhedron! //assert_dimension<B, 2>(); } template <typename RingType, typename Char, typename Traits> static inline void do_apply(std::basic_ostream<Char, Traits>& os, Box const& box) { RingType ring; geometry::convert(box, ring); os << "POLYGON("; wkt_sequence<RingType, false>::apply(os, ring); os << ")"; } }; template <typename Segment> struct wkt_segment { typedef typename point_type<Segment>::type point_type; template <typename Char, typename Traits> static inline void apply(std::basic_ostream<Char, Traits>& os, Segment const& segment, bool) { // Convert to two points, then stream typedef boost::array<point_type, 2> sequence; sequence points; geometry::detail::assign_point_from_index<0>(segment, points[0]); geometry::detail::assign_point_from_index<1>(segment, points[1]); // In Boost.Geometry a segment is represented // in WKT-format like (for 2D): LINESTRING(x y,x y) os << "LINESTRING"; wkt_sequence<sequence, false>::apply(os, points); } private: inline wkt_segment() {} }; }} // namespace detail::wkt #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Geometry, typename Tag = typename tag<Geometry>::type> struct wkt: not_implemented<Tag> {}; template <typename Point> struct wkt<Point, point_tag> : detail::wkt::wkt_point < Point, detail::wkt::prefix_point > {}; template <typename Linestring> struct wkt<Linestring, linestring_tag> : detail::wkt::wkt_range < Linestring, false, detail::wkt::prefix_linestring_par, detail::wkt::closing_parenthesis > {}; /! \brief Specialization to stream a box as WKT \details A "box" does not exist in WKT. It is therefore streamed as a polygon / template <typename Box> struct wkt<Box, box_tag> : detail::wkt::wkt_box<Box> {}; template <typename Segment> struct wkt<Segment, segment_tag> : detail::wkt::wkt_segment<Segment> {}; /! \brief Specialization to stream a ring as WKT \details A ring or "linear_ring" does not exist in WKT. A ring is equivalent to a polygon without inner rings It is therefore streamed as a polygon / template <typename Ring> struct wkt<Ring, ring_tag> : detail::wkt::wkt_range < Ring, true, detail::wkt::prefix_ring_par_par, detail::wkt::double_closing_parenthesis > {}; /! \brief Specialization to stream polygon as WKT / template <typename Polygon> struct wkt<Polygon, polygon_tag> : detail::wkt::wkt_poly < Polygon, detail::wkt::prefix_polygon > {}; template <typename Multi> struct wkt<Multi, multi_point_tag> : detail::wkt::wkt_multi < Multi, detail::wkt::wkt_point < typename boost::range_value<Multi>::type, detail::wkt::prefix_null >, detail::wkt::prefix_multipoint > {}; template <typename Multi> struct wkt<Multi, multi_linestring_tag> : detail::wkt::wkt_multi < Multi, detail::wkt::wkt_sequence < typename boost::range_value<Multi>::type, false >, detail::wkt::prefix_multilinestring > {}; template <typename Multi> struct wkt<Multi, multi_polygon_tag> : detail::wkt::wkt_multi < Multi, detail::wkt::wkt_poly < typename boost::range_value<Multi>::type, detail::wkt::prefix_null >, detail::wkt::prefix_multipolygon > {}; template <typename Geometry> struct devarianted_wkt { template <typename OutputStream> static inline void apply(OutputStream& os, Geometry const& geometry, bool force_closure) { wkt<Geometry>::apply(os, geometry, force_closure); } }; template <BOOST_VARIANT_ENUM_PARAMS(typename T)> struct devarianted_wkt<variant<BOOST_VARIANT_ENUM_PARAMS(T)> > { template <typename OutputStream> struct visitor: static_visitor<void> { OutputStream& m_os; bool m_force_closure; visitor(OutputStream& os, bool force_closure) : m_os(os) , m_force_closure(force_closure) {} template <typename Geometry> inline void operator()(Geometry const& geometry) const { devarianted_wkt<Geometry>::apply(m_os, geometry, m_force_closure); } }; template <typename OutputStream> static inline void apply( OutputStream& os, variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry, bool force_closure) { boost::apply_visitor(visitor<OutputStream>(os, force_closure), geometry); } }; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH /! \brief Generic geometry template manipulator class, takes corresponding output class from traits class \ingroup wkt \details Stream manipulator, streams geometry classes as \ref WKT streams \par Example: Small example showing how to use the wkt class \dontinclude doxygen_1.cpp \skip example_as_wkt_point \line { \until } / template <typename Geometry> class wkt_manipulator { static const bool is_ring = util::is_ring<Geometry>::value; public: // Boost.Geometry, by default, closes polygons explictly, but not rings // NOTE: this might change in the future! inline wkt_manipulator(Geometry const& g, bool force_closure = ! is_ring) : m_geometry(g) , m_force_closure(force_closure) {} template <typename Char, typename Traits> inline friend std::basic_ostream<Char, Traits>& operator<<( std::basic_ostream<Char, Traits>& os, wkt_manipulator const& m) { dispatch::devarianted_wkt<Geometry>::apply(os, m.m_geometry, m.m_force_closure); os.flush(); return os; } private: Geometry const& m_geometry; bool m_force_closure; }; /! \brief Main WKT-streaming function \tparam Geometry \tparam_geometry \param geometry \param_geometry \ingroup wkt \qbk{[include reference/io/wkt.qbk]} / template <typename Geometry> inline wkt_manipulator<Geometry> wkt(Geometry const& geometry) { concepts::check<Geometry const>(); return wkt_manipulator<Geometry>(geometry); } #if defined(_MSC_VER) #pragma warning(pop) #endif }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_WKT_WRITE_HPP PK��u!\��wkt/stream.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_WKT_STREAM_HPP #define BOOST_GEOMETRY_IO_WKT_STREAM_HPP #include <boost/geometry/io/wkt/write.hpp> // This short file contains only one manipulator, streaming as WKT // Don't include this in any standard-included header file. // Don't use namespace boost::geometry, to enable the library to stream custom // geometries which are living outside the namespace boost::geometry // This is currently not documented on purpose: the Doxygen 2 QBK generator // should be updated w.r.t. << which in the end ruins the DocBook XML template<typename Char, typename Traits, typename Geometry> inline std::basic_ostream<Char, Traits>& operator<< ( std::basic_ostream<Char, Traits> &os, Geometry const& geom ) { os << boost::geometry::wkt(geom); return os; } #endif // BOOST_GEOMETRY_IO_WKT_STREAM_HPP PK��u!\揖��wkt/detail/wkt_multi.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP #define BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP #include <boost/geometry/core/tags.hpp> #include <boost/geometry/domains/gis/io/wkt/write.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace wkt { struct prefix_null { static inline const char* apply() { return ""; } }; struct prefix_multipoint { static inline const char* apply() { return "MULTIPOINT"; } }; struct prefix_multilinestring { static inline const char* apply() { return "MULTILINESTRING"; } }; struct prefix_multipolygon { static inline const char* apply() { return "MULTIPOLYGON"; } }; }} // namespace wkt::impl #endif }} // namespace boost::geometry #endif // BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP PK��u!\��[r��wkt/detail/prefix.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP #define BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace wkt { struct prefix_null { static inline const char* apply() { return ""; } }; struct prefix_point { static inline const char* apply() { return "POINT"; } }; struct prefix_polygon { static inline const char* apply() { return "POLYGON"; } }; struct prefix_linestring { static inline const char* apply() { return "LINESTRING"; } }; struct prefix_multipoint { static inline const char* apply() { return "MULTIPOINT"; } }; struct prefix_multilinestring { static inline const char* apply() { return "MULTILINESTRING"; } }; struct prefix_multipolygon { static inline const char* apply() { return "MULTIPOLYGON"; } }; }} // namespace wkt::impl #endif }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP PK��u!\�?aGf��f��wkt/read.hppnu��[��// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland. // This file was modified by Oracle on 2014-2020. // Modifications copyright (c) 2014-2020 Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is 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_GEOMETRY_IO_WKT_READ_HPP #define BOOST_GEOMETRY_IO_WKT_READ_HPP #include <cstddef> #include <string> #include <boost/lexical_cast.hpp> #include <boost/tokenizer.hpp> #include <boost/algorithm/string.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/size.hpp> #include <boost/range/value_type.hpp> #include <boost/throw_exception.hpp> #include <boost/geometry/algorithms/assign.hpp> #include <boost/geometry/algorithms/append.hpp> #include <boost/geometry/algorithms/clear.hpp> #include <boost/geometry/algorithms/detail/disjoint/point_point.hpp> #include <boost/geometry/core/access.hpp> #include <boost/geometry/core/coordinate_dimension.hpp> #include <boost/geometry/core/exception.hpp> #include <boost/geometry/core/exterior_ring.hpp> #include <boost/geometry/core/geometry_id.hpp> #include <boost/geometry/core/interior_rings.hpp> #include <boost/geometry/core/mutable_range.hpp> #include <boost/geometry/core/point_type.hpp> #include <boost/geometry/core/tag.hpp> #include <boost/geometry/core/tags.hpp> #include <boost/geometry/geometries/concepts/check.hpp> #include <boost/geometry/io/wkt/detail/prefix.hpp> #include <boost/geometry/util/coordinate_cast.hpp> #include <boost/geometry/util/type_traits.hpp> namespace boost { namespace geometry { /! \brief Exception showing things wrong with WKT parsing \ingroup wkt / struct read_wkt_exception : public geometry::exception { template <typename Iterator> read_wkt_exception(std::string const& msg, Iterator const& it, Iterator const& end, std::string const& wkt) : message(msg) , wkt(wkt) { if (it != end) { source = " at '"; source += it->c_str(); source += "'"; } complete = message + source + " in '" + wkt.substr(0, 100) + "'"; } read_wkt_exception(std::string const& msg, std::string const& wkt) : message(msg) , wkt(wkt) { complete = message + "' in (" + wkt.substr(0, 100) + ")"; } virtual ~read_wkt_exception() throw() {} virtual const char* what() const throw() { return complete.c_str(); } private : std::string source; std::string message; std::string wkt; std::string complete; }; #ifndef DOXYGEN_NO_DETAIL // (wkt: Well Known Text, defined by OGC for all geometries and implemented by e.g. databases (MySQL, PostGIS)) namespace detail { namespace wkt { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; template <typename Point, std::size_t Dimension = 0, std::size_t DimensionCount = geometry::dimension<Point>::value> struct parsing_assigner { static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, Point& point, std::string const& wkt) { typedef typename coordinate_type<Point>::type coordinate_type; // Stop at end of tokens, or at "," ot ")" bool finished = (it == end \|\| it == "," \|\| it == ")"); try { // Initialize missing coordinates to default constructor (zero) // OR // Use lexical_cast for conversion to double/int // Note that it is much slower than atof. However, it is more standard // and in parsing the change in performance falls probably away against // the tokenizing set<Dimension>(point, finished ? coordinate_type() : coordinate_cast<coordinate_type>::apply(it)); } catch(boost::bad_lexical_cast const& blc) { BOOST_THROW_EXCEPTION(read_wkt_exception(blc.what(), it, end, wkt)); } catch(std::exception const& e) { BOOST_THROW_EXCEPTION(read_wkt_exception(e.what(), it, end, wkt)); } catch(...) { BOOST_THROW_EXCEPTION(read_wkt_exception("", it, end, wkt)); } parsing_assigner<Point, Dimension + 1, DimensionCount>::apply( (finished ? it : ++it), end, point, wkt); } }; template <typename Point, std::size_t DimensionCount> struct parsing_assigner<Point, DimensionCount, DimensionCount> { static inline void apply(tokenizer::iterator&, tokenizer::iterator const&, Point&, std::string const&) { } }; template <typename Iterator> inline void handle_open_parenthesis(Iterator& it, Iterator const& end, std::string const& wkt) { if (it == end \|\| it != "(") { BOOST_THROW_EXCEPTION(read_wkt_exception("Expected '('", it, end, wkt)); } ++it; } template <typename Iterator> inline void handle_close_parenthesis(Iterator& it, Iterator const& end, std::string const& wkt) { if (it != end && it == ")") { ++it; } else { BOOST_THROW_EXCEPTION(read_wkt_exception("Expected ')'", it, end, wkt)); } } template <typename Iterator> inline void check_end(Iterator& it, Iterator const& end, std::string const& wkt) { if (it != end) { BOOST_THROW_EXCEPTION(read_wkt_exception("Too many tokens", it, end, wkt)); } } /! \brief Internal, parses coordinate sequences, strings are formated like "(1 2,3 4,...)" \param it token-iterator, should be pre-positioned at "(", is post-positions after last ")" \param end end-token-iterator \param out Output itererator receiving coordinates / template <typename Point> struct container_inserter { // Version with output iterator template <typename OutputIterator> static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, OutputIterator out) { handle_open_parenthesis(it, end, wkt); Point point; // Parse points until closing parenthesis while (it != end && it != ")") { parsing_assigner<Point>::apply(it, end, point, wkt); out = point; ++out; if (it != end && it == ",") { ++it; } } handle_close_parenthesis(it, end, wkt); } }; template <typename Geometry, closure_selector Closure = closure<Geometry>::value> struct stateful_range_appender { typedef typename geometry::point_type<Geometry>::type point_type; // NOTE: Geometry is a reference inline void append(Geometry geom, point_type const& point, bool) { geometry::append(geom, point); } }; template <typename Geometry> struct stateful_range_appender<Geometry, open> { typedef typename geometry::point_type<Geometry>::type point_type; typedef typename boost::range_size < typename util::remove_cptrref<Geometry>::type >::type size_type; BOOST_STATIC_ASSERT(( util::is_ring<Geometry>::value )); inline stateful_range_appender() : pt_index(0) {} // NOTE: Geometry is a reference inline void append(Geometry geom, point_type const& point, bool is_next_expected) { bool should_append = true; if (pt_index == 0) { first_point = point; //should_append = true; } else { // NOTE: if there is not enough Points, they're always appended should_append = is_next_expected \|\| pt_index < core_detail::closure::minimum_ring_size<open>::value \|\| disjoint(point, first_point); } ++pt_index; if (should_append) { geometry::append(geom, point); } } private: static inline bool disjoint(point_type const& p1, point_type const& p2) { // TODO: pass strategy typedef typename strategy::disjoint::services::default_strategy < point_type, point_type >::type strategy_type; return detail::disjoint::disjoint_point_point(p1, p2, strategy_type()); } size_type pt_index; point_type first_point; }; // Geometry is a value-type or reference-type template <typename Geometry> struct container_appender { typedef typename geometry::point_type<Geometry>::type point_type; static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, Geometry out) { handle_open_parenthesis(it, end, wkt); stateful_range_appender<Geometry> appender; // Parse points until closing parenthesis while (it != end && it != ")") { point_type point; parsing_assigner<point_type>::apply(it, end, point, wkt); bool const is_next_expected = it != end && it == ","; appender.append(out, point, is_next_expected); if (is_next_expected) { ++it; } } handle_close_parenthesis(it, end, wkt); } }; /! \brief Internal, parses a point from a string like this "(x y)" \note used for parsing points and multi-points / template <typename P> struct point_parser { static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, P& point) { handle_open_parenthesis(it, end, wkt); parsing_assigner<P>::apply(it, end, point, wkt); handle_close_parenthesis(it, end, wkt); } }; template <typename Geometry> struct linestring_parser { static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, Geometry& geometry) { container_appender<Geometry&>::apply(it, end, wkt, geometry); } }; template <typename Ring> struct ring_parser { static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, Ring& ring) { // A ring should look like polygon((x y,x y,x y...)) // So handle the extra opening/closing parentheses // and in between parse using the container-inserter handle_open_parenthesis(it, end, wkt); container_appender<Ring&>::apply(it, end, wkt, ring); handle_close_parenthesis(it, end, wkt); } }; /! \brief Internal, parses a polygon from a string like this "((x y,x y),(x y,x y))" \note used for parsing polygons and multi-polygons / template <typename Polygon> struct polygon_parser { typedef typename ring_return_type<Polygon>::type ring_return_type; typedef container_appender<ring_return_type> appender; static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, Polygon& poly) { handle_open_parenthesis(it, end, wkt); int n = -1; // Stop at ")" while (it != end && it != ")") { // Parse ring if (++n == 0) { appender::apply(it, end, wkt, exterior_ring(poly)); } else { typename ring_type<Polygon>::type ring; appender::apply(it, end, wkt, ring); traits::push_back < typename std::remove_reference < typename traits::interior_mutable_type<Polygon>::type >::type >::apply(interior_rings(poly), ring); } if (it != end && it == ",") { // Skip "," after ring is parsed ++it; } } handle_close_parenthesis(it, end, wkt); } }; inline bool one_of(tokenizer::iterator const& it, std::string const& value, bool& is_present) { if (boost::iequals(it, value)) { is_present = true; return true; } return false; } inline bool one_of(tokenizer::iterator const& it, std::string const& value, bool& present1, bool& present2) { if (boost::iequals(it, value)) { present1 = true; present2 = true; return true; } return false; } inline void handle_empty_z_m(tokenizer::iterator& it, tokenizer::iterator const& end, bool& has_empty, bool& has_z, bool& has_m) { has_empty = false; has_z = false; has_m = false; // WKT can optionally have Z and M (measured) values as in // POINT ZM (1 1 5 60), POINT M (1 1 80), POINT Z (1 1 5) // GGL supports any of them as coordinate values, but is not aware // of any Measured value. while (it != end && (one_of(it, "M", has_m) \|\| one_of(it, "Z", has_z) \|\| one_of(it, "EMPTY", has_empty) \|\| one_of(it, "MZ", has_m, has_z) \|\| one_of(it, "ZM", has_z, has_m) ) ) { ++it; } } /! \brief Internal, starts parsing \param tokens boost tokens, parsed with separator " " and keeping separator "()" \param geometry string to compare with first token / template <typename Geometry> inline bool initialize(tokenizer const& tokens, std::string const& geometry_name, std::string const& wkt, tokenizer::iterator& it, tokenizer::iterator& end) { it = tokens.begin(); end = tokens.end(); if (it == end \|\| ! boost::iequals(it++, geometry_name)) { BOOST_THROW_EXCEPTION(read_wkt_exception(std::string("Should start with '") + geometry_name + "'", wkt)); } bool has_empty, has_z, has_m; handle_empty_z_m(it, end, has_empty, has_z, has_m); // Silence warning C4127: conditional expression is constant #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable : 4127) #endif if (has_z && dimension<Geometry>::type::value < 3) { BOOST_THROW_EXCEPTION(read_wkt_exception("Z only allowed for 3 or more dimensions", wkt)); } #if defined(_MSC_VER) #pragma warning(pop) #endif if (has_empty) { check_end(it, end, wkt); return false; } // M is ignored at all. return true; } template <typename Geometry, template<typename> class Parser, typename PrefixPolicy> struct geometry_parser { static inline void apply(std::string const& wkt, Geometry& geometry) { geometry::clear(geometry); tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()")); tokenizer::iterator it, end; if (initialize<Geometry>(tokens, PrefixPolicy::apply(), wkt, it, end)) { Parser<Geometry>::apply(it, end, wkt, geometry); check_end(it, end, wkt); } } }; template <typename MultiGeometry, template<typename> class Parser, typename PrefixPolicy> struct multi_parser { static inline void apply(std::string const& wkt, MultiGeometry& geometry) { traits::clear<MultiGeometry>::apply(geometry); tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()")); tokenizer::iterator it, end; if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end)) { handle_open_parenthesis(it, end, wkt); // Parse sub-geometries while(it != end && it != ")") { traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1); Parser < typename boost::range_value<MultiGeometry>::type >::apply(it, end, wkt, (boost::end(geometry) - 1)); if (it != end && it == ",") { // Skip "," after multi-element is parsed ++it; } } handle_close_parenthesis(it, end, wkt); } check_end(it, end, wkt); } }; template <typename P> struct noparenthesis_point_parser { static inline void apply(tokenizer::iterator& it, tokenizer::iterator const& end, std::string const& wkt, P& point) { parsing_assigner<P>::apply(it, end, point, wkt); } }; template <typename MultiGeometry, typename PrefixPolicy> struct multi_point_parser { static inline void apply(std::string const& wkt, MultiGeometry& geometry) { traits::clear<MultiGeometry>::apply(geometry); tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()")); tokenizer::iterator it, end; if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end)) { handle_open_parenthesis(it, end, wkt); // If first point definition starts with "(" then parse points as (x y) // otherwise as "x y" bool using_brackets = (it != end && it == "("); while(it != end && it != ")") { traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1); if (using_brackets) { point_parser < typename boost::range_value<MultiGeometry>::type >::apply(it, end, wkt, (boost::end(geometry) - 1)); } else { noparenthesis_point_parser < typename boost::range_value<MultiGeometry>::type >::apply(it, end, wkt, (boost::end(geometry) - 1)); } if (it != end && it == ",") { // Skip "," after point is parsed ++it; } } handle_close_parenthesis(it, end, wkt); } check_end(it, end, wkt); } }; /! \brief Supports box parsing \note OGC does not define the box geometry, and WKT does not support boxes. However, to be generic GGL supports reading and writing from and to boxes. Boxes are outputted as a standard POLYGON. GGL can read boxes from a standard POLYGON, from a POLYGON with 2 points of from a BOX \tparam Box the box / template <typename Box> struct box_parser { static inline void apply(std::string const& wkt, Box& box) { bool should_close = false; tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()")); tokenizer::iterator it = tokens.begin(); tokenizer::iterator end = tokens.end(); if (it != end && boost::iequals(it, "POLYGON")) { ++it; bool has_empty, has_z, has_m; handle_empty_z_m(it, end, has_empty, has_z, has_m); if (has_empty) { assign_zero(box); return; } handle_open_parenthesis(it, end, wkt); should_close = true; } else if (it != end && boost::iequals(it, "BOX")) { ++it; } else { BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'POLYGON' or 'BOX'", wkt)); } typedef typename point_type<Box>::type point_type; std::vector<point_type> points; container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points)); if (should_close) { handle_close_parenthesis(it, end, wkt); } check_end(it, end, wkt); unsigned int index = 0; std::size_t n = boost::size(points); if (n == 2) { index = 1; } else if (n == 4 \|\| n == 5) { // In case of 4 or 5 points, we do not check the other ones, just // take the opposite corner which is always 2 index = 2; } else { BOOST_THROW_EXCEPTION(read_wkt_exception("Box should have 2,4 or 5 points", wkt)); } geometry::detail::assign_point_to_index<min_corner>(points.front(), box); geometry::detail::assign_point_to_index<max_corner>(points[index], box); } }; /! \brief Supports segment parsing \note OGC does not define the segment, and WKT does not support segmentes. However, it is useful to implement it, also for testing purposes \tparam Segment the segment / template <typename Segment> struct segment_parser { static inline void apply(std::string const& wkt, Segment& segment) { tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()")); tokenizer::iterator it = tokens.begin(); tokenizer::iterator end = tokens.end(); if (it != end && (boost::iequals(it, "SEGMENT") \|\| boost::iequals(it, "LINESTRING") )) { ++it; } else { BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'LINESTRING' or 'SEGMENT'", wkt)); } typedef typename point_type<Segment>::type point_type; std::vector<point_type> points; container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points)); check_end(it, end, wkt); if (boost::size(points) == 2) { geometry::detail::assign_point_to_index<0>(points.front(), segment); geometry::detail::assign_point_to_index<1>(points.back(), segment); } else { BOOST_THROW_EXCEPTION(read_wkt_exception("Segment should have 2 points", wkt)); } } }; }} // namespace detail::wkt #endif // DOXYGEN_NO_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Tag, typename Geometry> struct read_wkt {}; template <typename Point> struct read_wkt<point_tag, Point> : detail::wkt::geometry_parser < Point, detail::wkt::point_parser, detail::wkt::prefix_point > {}; template <typename L> struct read_wkt<linestring_tag, L> : detail::wkt::geometry_parser < L, detail::wkt::linestring_parser, detail::wkt::prefix_linestring > {}; template <typename Ring> struct read_wkt<ring_tag, Ring> : detail::wkt::geometry_parser < Ring, detail::wkt::ring_parser, detail::wkt::prefix_polygon > {}; template <typename Geometry> struct read_wkt<polygon_tag, Geometry> : detail::wkt::geometry_parser < Geometry, detail::wkt::polygon_parser, detail::wkt::prefix_polygon > {}; template <typename MultiGeometry> struct read_wkt<multi_point_tag, MultiGeometry> : detail::wkt::multi_point_parser < MultiGeometry, detail::wkt::prefix_multipoint > {}; template <typename MultiGeometry> struct read_wkt<multi_linestring_tag, MultiGeometry> : detail::wkt::multi_parser < MultiGeometry, detail::wkt::linestring_parser, detail::wkt::prefix_multilinestring > {}; template <typename MultiGeometry> struct read_wkt<multi_polygon_tag, MultiGeometry> : detail::wkt::multi_parser < MultiGeometry, detail::wkt::polygon_parser, detail::wkt::prefix_multipolygon > {}; // Box (Non-OGC) template <typename Box> struct read_wkt<box_tag, Box> : detail::wkt::box_parser<Box> {}; // Segment (Non-OGC) template <typename Segment> struct read_wkt<segment_tag, Segment> : detail::wkt::segment_parser<Segment> {}; } // namespace dispatch #endif // DOXYGEN_NO_DISPATCH /! \brief Parses OGC Well-Known Text (\ref WKT) into a geometry (any geometry) \ingroup wkt \tparam Geometry \tparam_geometry \param wkt string containing \ref WKT \param geometry \param_geometry output geometry \ingroup wkt \qbk{[include reference/io/read_wkt.qbk]} / template <typename Geometry> inline void read_wkt(std::string const& wkt, Geometry& geometry) { geometry::concepts::check<Geometry>(); dispatch::read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry); } }} // namespace boost::geometry #endif // BOOST_GEOMETRY_IO_WKT_READ_HPP PK��3�!\щ�y=��=��LC_MESSAGES/gtk30.monu��[��Q��F��"��8��"��[��,��~�� 7��)��4��,��=��a��'��$��(��)��#�� M�� X��"��f��#��!��0�� 9��6��Q��3��!�� '��2��8��H��T��a��n��{��+����$��@��e��1��-��"��,��?��G��V��b��j�� r��&�� &��@��`��~�� !��/��;��M��Q��]��u��\|��>��8��?��H��N��S��X��g�� l�� z�� =�� (��8��J��[�� a�� o��z�� % �� 4 ��B ��O ��e ��m ��} �� !��!�� !��(!��9!��A!��H!�� O!��]!��L��z!��!��!��!��!��/��!��("��1"��8"��D"��>��]"��"��"��"��6��"��#��5#��!��#��#��$�� $�� $��$�� %��%��"%��%��7%��>%��[%��b%�� n%�� x%��%��%��%��%��%��%��%��%��%��%��%��&��&��&��&�� "&��-&��4&��9&�� F&��T&�� c&��m&��z&�� &��&��&��&��&��&��&��&��&��&��&��&��'��'��'��+'��7'��M'�� Y'��d'��i'�� l'��v'��R��'��F��(��!��)��!��A)����c)��)��)��)��0��)��)��6��)��@��3��t��y��.����.����3����3��+�� F+��Q+��!��`+��"��+��!��+��-��+��+�� +��;��,��6��D,��{,��4��,��,��,��,��,��,��'��,��-�� -��,-��3-��F-��R-��b-��q-�� ~-��-�� -��-��-��-��/��-��.��#.��A.��#��[.��.��0��.��)��.��.��"��/��9/��L/��c/��k/��/��/��/��/��&��/��/��$��/��0�� +0��60��<0��!��Q0��s0��)��0��$��0��0��0�� 1��1��&1�� ?1��I1��Q1��X1�� k1��y1��1��1��1��1��1��1��1��1��1��2��2��"2��'2��,2��32��P2��p2��@��2��2�� 2��2��2��2��2��3��3��3��!3�� 3��43��A3��J3��E��Z3��3��3��3�� 3��3��3��3�� 4��4��#4��44��F4�� U4��c4��t4��4��4��4��4��4��4��4��4�� 4��4��4��5��&5��55�� P5��Z5��t5��5��!��5��5��5��!��5��6��6��6��/6��66��N6��V6��^6��f6��y6��M��6��6��6�� 7��7��1��'7��Y7��a7�� h7��s7��7��7��&��7��7��9��8��@8��`8��%��9��)9��B9�� :��:��$:��<:�� E:�� S:��^:��r:��%��z:��:�� :�� :��:��:��:��:�� :�� ;��";��(;��/;��6;�� F;��P;��X;�� a;�� o;��z;��;��;��;��;�� ;��;��;��;��;�� ;��;��<��<�� <��)<��5<�� ><��I<��]<��u<�� }<��<�� <��<��<��<��<�� <��<��<�� <��=��]��3��h��0��T��\��:��w�� F��^��{��"��@��B��N����l��/��'��q��U�� }��H��(��!��p��v��\|��C��[��$��I��j��P��n��g��o��V��t��Y��>��9��%��m��c��i��J��A��E��O��r��f��4��5��Q��7��y��a��L��_��W�� 6��e��;��8��`��K��~��k��#��+��.��?��x��D��)��1��z��&�� =��u��,��X��d��G��M��s��b��S��Z��2��-��R��<��"%s" could not be converted to a value of type "%s" for attribute "%s"�"%s" is not a valid attribute name�"%s" is not a valid attribute type�"%s" is not a valid value for attribute "%s"�%1$s on %2$s�%s job #%d�(None)�<%s> element has neither a "name" nor an "id" attribute�A <%s> element has already been specified�A <text> element can't occur before a <tags> element�A file named "%s" already exists. Do you want to replace it?�A_t:�About %s�Add the current folder to the bookmarks�Add the folder '%s' to the bookmarks�Add the selected folder to the Bookmarks�Add the selected folders to the bookmarks�All sheets�Amharic (EZ+)�Amount of blue light in the color.�Amount of green light in the color.�Amount of red light in the color.�Anonymous tag found and tags can not be created.�Application�Artwork by�Attribute "%s" is invalid on <%s> element in this context�Attribute "%s" repeated twice on the same <%s> element�Be_fore:�Both "id" and "name" were found on the <%s> element�Brightness of the color.�CLASS�COLORS�C_ollate�C_redits�Cache file created successfully. �Cedilla�Classified�Color�Color Selection�Color Wheel�Color _name:�Command Line�Confidential�Copie_s:�Copies�Copy URL�Copy _Location�Could not add a bookmark�Could not clear list�Could not get information for file '%s': %s�Could not mount %s�Could not remove bookmark�Could not remove item�Could not rename %s back to %s: %s. �Could not rename %s to %s: %s �Could not rename %s to %s: %s, removing %s then. �Could not retrieve information about the file�Could not select file�Could not start the search process�Create Fo_lder�Create in _folder:�Credits�Custom Size %d�Custom size�DISPLAY�Desktop�Documented by�Element <%s> is not allowed below <%s>�Empty�Error creating folder '%s': %s�Error loading icon: %s�Even sheets�FLAGS�Failed to load icon�Failed to open file '%s': %s�Failed to rewrite header �Failed to write cache file: %s �Failed to write folder index �Failed to write hash table �Failed to write header �File�File System�File not found: %s �Files�Finishing�Font�Font Selection�Full Volume�GTK+ Options�General�High�Image Quality�Invalid URI�Invalid file name�Job�Job Details�LRM _Left-to-right mark�Layout�License�Load additional GTK+ modules�Location�Low�MODULES�Manage Custom Sizes�Manage Custom Sizes...�Margins from Printer...�Margins: Left: %s %s Right: %s %s Top: %s %s Bottom: %s %s�Medium�Modified�Muted�NAME�Name�No items found�None�Not available�Odd sheets�One Sided�Op_acity:�Open '%s'�Other...�Out of paper�Outermost element in text must be <text_view_markup> not <%s>�Output Tray�Output t_ray:�PDF�Page %u�Page Setup�Pages Per Sheet�Pages per _sheet:�Pages per _side:�Paper�Paper Margins�Paper Size�Paper Source�Paper Type�Paper _source:�Paper _type:�Paused�Pick a Color�Pick a Font�Places�Position on the color wheel.�Postscript�Preparing�Preparing %d�Pri_ority:�Print�Print Document�Print to File�Print to LPR�Print to Test Printer�Printer�Printer offline�Printing %d�RLM _Right-to-left mark�Received invalid color data �Remove�Remove the bookmark '%s'�Remove the selected bookmark�Rename...�SCREEN�Same as --no-wintab�Sans 12�Save in _folder:�Sc_ale:�Search�Secret�Select A File�Serialized data is malformed�Serialized data is malformed. First section isn't GTKTEXTBUFFERCONTENTS-0001�Show GTK+ Options�Show _Hidden Files�Si_ze:�Size�Specify one or more page ranges, e.g. 1-3,7,11�Standard�Status�T_wo-sided:�Tag "%s" already defined�Tag "%s" does not exist in buffer and tags can not be created.�Tag "%s" has invalid priority "%s"�Tag "%s" has not been defined.�The attribute "%s" was found twice on the <%s> element�The folder could not be created�The folder could not be created, as a file with the same name already exists. Try using a different name for the folder, or rename the file first.�The generated cache was invalid. �The license of the program�The previously-selected color, for comparison to the color you're selecting now. You can drag this color to a palette entry, or select this color as current by dragging it to the other color swatch alongside.�Top Secret�Translated by�Transparency of the color.�Two Sided�Unclassified�Unknown�Unknown item�Urgent�Validate existing icon cache�Volume�Volume Down�Volume Up�Written by�X display to use�X screen to use�Yesterday at %H:%M�_Add�_Add to Bookmarks�_After:�_Blue:�_Bottom:�_Clear List�_Family:�_Green:�_Height:�_Hue:�_Left:�_License�_Location:�_Name:�_Now�_Only print:�_Orientation:�_Output format�_Palette:�_Paper size:�_Places�_Preview:�_Red:�_Remove�_Remove From List�_Replace�_Reverse�_Right:�_Saturation:�_Save color here�_Save in folder:�_Style:�_Top:�_Value:�_Width:�abcdefghijk ABCDEFGHIJK�calendar:MY�calendar:week_start:0�default:LTR�default:mm�inch�mm�output.%s�test-output.%s�Project-Id-Version: gtk+ 2.12.1 Report-Msgid-Bugs-To: PO-Revision-Date: 2007-09-22 14:13-0500 Last-Translator: Michael Terry <mike@mterry.name> Language-Team: Ido <gnome-ido@lists.mterry.name> Language: io MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=n != 1; �"%s" ne povis esar konvertita ad valoro de tipo "%s" por atributo "%s"�"%s" ne es valida atributala nomo�"%s" ne es valida atributala tipo�"%s" ne es valida valoro por atributo "%s"�%1$s an %2$s�%s tasko #%d�(Nula)�<%s>-elemento havas nek "name" nek "id" atributo�<%s>-elemento ja specigabas�<text>-elemento ne povas eventar avane <tags>-elemento�Dokumento nomizita "%s" ja existas. Ka vu deziras remplasar ol?�A_d:�Pri %s�Adjuntez la nuna dokumentuyo a la markorubandi�Adjuntez la dokumentuyo '%s' a la markorubandi�Adjuntez la selektata dokumentuyo a la Markorubandi�Adjuntez la selektata dokumentuyi a la markorubandi�Omna folii�Amharala (EZ+)�Quanto de blua lumo en la koloro.�Quanto de verda lumo en la koloro.�Quanto de reda lumo en la koloro.�Anomima tago trovis ed tagi ne povas kreesar.�Programo�Artaji da�Atributo "%s" es nevalida sur <%s>-elemento en ica kuntexto�Atributo "%s" repetis duople sur la sama <%s>-elemento�_Avan:�Due "id" ed "name" esis trovita sur la <%s>-elemento�Lumozeso di la koloro.�KLASO�KOLORI�K_olacionez�K_rediti�Trovajarala dokumento kreis sucesante. �Cedilio�Klasifikita�Koloro�Kolorala Selektajo�Kolora Roto�Kolorala _nomo:�Imperala Lineo�Konfidencala�_Kopiuri:�Kopiuri�Kopiez URL�Kopiez _Loko�Ne povis adjuntar markorubando�Ne povis vakuigez listo�Ne povis aquirar informo pri dokumento '%s': %s�Ne povis acensar %s�Ne povis forigar markorubando�Ne povis forigar elemento�Ne povis retronomizar %s a %s: %s. �Ne povis rinomizar %s a %s: %s �No povis rinomizar %s ad %s: %s, do forigas %s. �Ne povis aquirar informo pri la dokumento�Ne povis selektar dokumento�Ne povis startar la sercha procedo�Kreez _Dokumentuyo�Kreez en _dokumentuyo:�Krediti�Desnormala Grandeso %d�Desnormala grandeso�VIDIGILO�Pupitrosupro�Dokumentizita da�Elemento <%s> ne es permisata sub <%s>�Vakua�Eroro dum kreas dokumentuyo '%s': %s�Eroro dum charjas ikono: %s�Para folii�FLAGI�Faliis charjar ikono�Faliis apertar dokumento '%s': %s�Faliis riskribar kapo �Faliis skribar trovajarala dokumento: %s �Faliis skribar dokumentuyala indexo �Faliis skribar hachotabelo �Faliis skribar kapo �Dokumento�Dokumenta Sistemo�Dokumento netrovita: %s �Dokumenti�Finanta�Tiparo�Tiparala Selektajo�Plena Lauteso�GTK+ Selekti�Generala�Alta�Imajala Qualeso�Nevalida URI�Nevalida dokumenta nomo�Tasko�Taskala Detali�LRM _Sinistra-a-dextra marko�Traso�Yurizo�Charjez plusa GTK+-moduli�Loko�Basa�MODULI�Direktez Desnormala Grandesi�Direktez Desnormala Grandesi...�Marjini de Imprimilo...�Marjini: Sinistra: %s %s Dextra: %s %s Supra: %s %s Infra: %s %s�Meza�Modifikita�Tacigata�NOMO�Nomo�Nula elemteni trovita�Nula�Nedisponebla�Nepara folii�Unlatera�Op_akeso:�Apertez '%s'�Altra...�Ne plusa papero�Maxim extera elemento en texto mustas esar <text_view_markup> ne <%s>�Produkturala Pleto�Produkturala _pleto:�PDF�Pagino %u�Pagina Establiso�Pagini Po Folio�Pagini po _folio:�Pagini po _latero:�Papero�Paperala Marjini�Paperala Grandeso�Paperala Fonto�Paperala Tipo�Paperala _fonto:�Paperala _tipo:�Pauzita�Selektez Koloro�Selektez Tiparo�Loki�Loko en la kolora roto.�Posskribajo�Preparas�Preparas %d�Pri_oreso:�Imprimez�Imprimez Dokumento�Imprimez a Dokumento�Imprimez a LPR�Imprimez a Testa Imprimilo�Imprimilo�Imprimilo es deskonectata�Imprimas %d�RLM _Dextra-a-sinistra marko�Recevis nevalida kolorala donaji �Forigez�Forigez la markorubando '%s'�Forigez la selektata markorubando�Rinomizez...�SKRENO�Sama kam --no-wintab�Sen 12�Salvez en _dokumentuyo:�Sk_alo:�Serchez�Sekreta�Selektez Dokumento�Seriigata donaji es misforma�Seriigata donaji es misforma. Unesma seciono ne es GTKTEXTBUFFERCONTENTS-0001�Montrez GTK+ Selecti�Montrez _Celita Dokumenti�_Grandeso:�Grandeso�Specigez un o plu pagina rangi, exemple 1-3,7,11�Normala�Stando�_Dulatera:�Tago "%s" ja definita�Tago "%s" ne existas en bufro ed tagi ne povas kreesar.�Tago "%s" havas nevalida prioreso "%s"�Tago "%s" ne esabas definita.�La atributo "%s" esis trovita duople sur la <%s>-elemento�La dokumentuyo ne povis kreesar�La dokumentuyo ne povis kreesar, pro ke dokumento kun la sama nomo ja existas. Esforcez uzar diferanta nomo por la dokumentuyo, od rinomizez la dokumento unesme.�La genitita trovajaro esis nevalida. �La yurizo di la programo�La exselektita koloro, por komparado a la koloro ke vu selectas nun. Vu povas tranar ica koloro a piktoplanketa elemento, o selectez ica koloro kom nuna per tranas ol a la altra koloromakulo flanke.�Maxim Sekreta�Tradukita da�Diafaneso di la koloro.�Dulatera�Neklasifikita�Nekonocata�Nekonocata elemento�Urjanta�Validigez existanta ikonala trovajaro�Lauteso�Lauteso Infre�Lauteso Supre�Skribita da�X-vidigilo uzota�X-skreno uzota�Hiere ad %H:%M�_Adjuntez�_Adjuntez a markorubandi�_Dop:�_Bluo:�_Bazo:�_Vakuigez Listo�_Familio:�_Verdo:�_Alteso:�_Kolornuanco:�_Sinistra:�_Yurizo�_Loko:�_Nomo:�_Nun�_Nur imprimez:�_Orientizeso:�_Produkturala formato�_Piktoplanketo:�_Paperala grandeso:�_Loki�_Prevido:�_Redo:�_Forigez�_Forigez de Listo�_Remplasez�_Inversigez�_Dextra:�_Saturajo:�_Salvez koloro hike�_Salvez en dokumentuyo:�_Stilo:�_Suprajo:�_Valoro:�_Largeso:�abcdefghijk ABCDEFGHIJK�calendar:YM�calendar:week_start:1�default:LTR�default:mm�inch�mm�produkturo.%s�testa-produkturo.%s�PK��3�!\��X��X��LC_MESSAGES/gtk20.monu��[��]��8��F��9��"��"��,�� $�� +�� 6�� @��7��a��)��4��=��6��;��'��D��$��l��(��)�� "��#�� !��D ��0��f �� 9�� 6�� !��$!��3��-!��a!��z!��!��!��!��!��!��!�� !��"��!��"��""��;"��C"�� J"��U"��["��k"��w"��"��"��"��"��"��"��"��"����"��)��#��+��I#��u#��#��#��$��#��#��1��#��-��.$��\$��"��r$��$��$��$��$��$��%��%��%��%��2%��?%��K%��S%�� \%��&��j%��%��%��%��%��%��$��%��&��;&��[&��{&��&��&��N��&��&��&��'��1'��E'��#��c'��'��'��'��"��'��'��(��3(��M(��m(��(��(��8��(��8��(��1)��I)��N)��Z)��n)�� t)��~)��)��)��)��)��)��)��)��)��)��)�� )������5��K��`�� u���� ����������+�� +��+��+��3+��:+��B+��_+��h+��l+��t+��+��+��>��+��+��+��,��,��,�� ,�� $,��/,��>,�� C,�� Q,�� \,�� f,�� p,��z,��,��=��,��,�� ,��,��!��,�� -��/-�� 7-��B-��R-��d-��u-�� {-�� -��-�� -��-��-��-��-��-��-��-�� .�� .��!.�� ..��9.��?.�� N.��\.��i.��.��.��.��.��.��.��.��.��/��./��:/�� O/��Y/��`/��t/��\|/��/��/��/��/�� /��/��L��/��"0��40��G0��N0��/��S0��0��0��0��0��0��>��0��"��1��51��T1��i1��~1��1��1��1��1��'��1��2��&2��=2��S2��h2��6��}2��2��2��!��h3��3��3�� v4�� 4��4�� 4��4��4��4��!��4��"��4��5��15��85��U5��\5�� h5��%��r5��5�� 5��5��5��5��5��5��6��6��-6��26��D6��L6��S6��\6��h6��q6��z6�� 6��6��6��6��6��6��6�� 6��6��6��6��6��6�� 6��7�� 7��!7��.7�� 67�� A7��K7��Q7��Y7��k7��s7��7��7��7��7��7��7��7��7��7��7��7��7��7��8��8��8��(8��>8�� J8��U8��Z8��]8�� b8��l8��R��{8��F��9��!��:��!��7:����Y:��:��:��:��:��:��:��$��:��0��:��/;��6��K;��@��;��;��;��.��;��.��;��3��-<��3��a<�� <��<��!��<��"��<��!��<��-��=��D=�� M=��;��W=��6��=��=��=��4��=�� >��!>��'>��.>��:>��A>��'��J>��$��r>��%��>�� >��>��>�� ?��?��?��"?��5?��A?��Q?��`?�� m?��w?�� ?��?��?��?��5��?��6��@��/��;@��k@��@��@��#��@��@��0��@��)��,A��VA��"��rA�� A��A��!��A��A�� B��!B��)B��@B��TB��]B��oB��B�� B��B��&��B��B��$��B��#��B��C��:C��.��NC��&��}C��)��C����C�� C��D��D��N��$D��+��sD��D��D��D��"��D��E��!��)E�� KE��"��lE��E��E��E��)��E��$��F��)F��EF��;��ZF��;��F��F�� F��F��G�� G��G��2G��?G��KG��RG�� eG��sG��G��G��G��G��G��G��G��G��H��'H��@H�� ZH��{H��H��H��H��H��H��H��H�� I��I��,I��2I��9I��SI��XI��]I��dI��I��I��@��I��I�� I�� J��J��J��J��,J��=J��SJ��XJ��eJ��rJ�� {J��J��J��J��E��J��J��K��K��'��K��(��EK�� nK��xK��K��K��K��K��K��K��K�� K��L��L��&L��.L��>L��NL��SL��kL��wL��L�� L��L��L��L��L��L�� L��L��M��"M��?M��!��\M��~M��M��!��M��M��M��M��N�� N��N��&N��>N��FN��MN��UN��]N��pN��M��N��N��N�� O��O��1��O��PO��XO��_O�� xO��O��7��O��&��O��O��P��-P��DP��[P��rP��P��P��)��P��P��P��Q��+Q��BQ��9��YQ��Q��Q��%��VR��\|R��R�� \S��jS��wS��S�� S�� S��S�� S��,��S��T��,T��%��4T��ZT�� bT�� pT��'��~T��T��T��T��T��T��'��T��(��U��8U��DU�� SU��]U��vU��\|U��U��U�� U�� U�� U��U��U��U��U�� U�� U��V��V��V��V��$V��6V��;V�� JV��XV��nV��~V��V�� V�� V��V��V��V�� V��V�� V��V��W�� W��W��-W��EW��QW�� YW��cW��lW�� sW��}W��W��W��W��W��W�� W��W��W��W�� W��W��2��O��<��?��+��T��C��Y��8��@��-��6��p��a��l��}��\��m��G��k��^��F��H��M��$��<��:��,��U��A��Z��%��2��j�� !��d��R��v��\|��5��F��h�� `��>����)��U��J��I��E��6��[��0��.��7��/��&��]��Q��+��N��'��#��A��i��9��:��y�� c��5��;��N�� ?��G�� .��u��b��D�� 3��n��)��R�� _��S��O��!��%��z��=��s��I��\��7��4��"��S��V��-��3��X��~��o��Y��W��P��&��E��q��K��(��;��r��(��0��Q��$��K��4��'��9��P��f��w��=��1��[��>��t��X��B��L��T��x��B��H��J��W��V��]��D��8����#��g��Z��@��e��C��M��L��1��/��"��{��,�� "%s" could not be converted to a value of type "%s" for attribute "%s"�"%s" is not a valid attribute name�"%s" is not a valid attribute type�"%s" is not a valid value for attribute "%s"�"Deepness" of the color.�%1$s on %2$s�%s job #%d�(None)�(disabled)�(unknown)�<%s> element has invalid id "%s"�<%s> element has neither a "name" nor an "id" attribute�A <%s> element has already been specified�A <text> element can't occur before a <tags> element�A file named "%s" already exists. Do you want to replace it?�A_t:�About %s�Add the current folder to the bookmarks�Add the folder '%s' to the bookmarks�Add the selected folder to the Bookmarks�Add the selected folders to the bookmarks�All sheets�Amharic (EZ+)�Amount of blue light in the color.�Amount of green light in the color.�Amount of red light in the color.�Anonymous tag found and tags can not be created.�Application�Artwork by�Attribute "%s" is invalid on <%s> element in this context�Attribute "%s" repeated twice on the same <%s> element�Axes�Be_fore:�Both "id" and "name" were found on the <%s> element�Brightness of the color.�CLASS�COLORS�C_ollate�C_reate�C_redits�Cache file created successfully. �Cannot allocate colormap entries�Cannot allocate colormap structure�Cannot allocate new pixbuf�Cannot read XPM colormap�Cedilla�Cl_ear�Classified�Color�Color Selection�Color Wheel�Color _name:�Command Line�Confidential�Copie_s:�Copies�Copy URL�Copy _Location�Could not add a bookmark�Could not clear list�Could not get image height (bad TIFF file)�Could not get image width (bad TIFF file)�Could not get information for file '%s': %s�Could not mount %s�Could not remove bookmark�Could not remove item�Could not rename %s back to %s: %s. �Could not rename %s to %s: %s �Could not rename %s to %s: %s, removing %s then. �Could not retrieve information about the file�Could not select file�Could not start the search process�Couldn't convert filename�Couldn't create new pixbuf�Couldn't write to BMP file�Create Fo_lder�Create in _folder:�Credits�Custom Size %d�Custom size�DISPLAY�De_lete File�Delete File�Desktop�Disabled�Documented by�Element <%s> is not allowed below <%s>�Empty�Error creating folder '%s': %s�Error deleting file '%s': %s�Error loading icon: %s�Error printing�Error renaming file "%s" to "%s": %s�Error renaming file "%s": %s�Error renaming file to "%s": %s�Error writing to image file: %s�Even sheets�Excess data in file�FLAGS�Failed to close '%s' while writing image, all data may not have been saved: %s�Failed to load RGB data from TIFF file�Failed to load TIFF image�Failed to load icon�Failed to load image '%s': %s�Failed to open '%s' for writing: %s�Failed to open TIFF image�Failed to open file '%s': %s�Failed to open temporary file�Failed to read from temporary file�Failed to rewrite header �Failed to save TIFF image�Failed to write TIFF data�Failed to write cache file: %s �Failed to write folder index �Failed to write hash table �Failed to write header �Failed to write to temporary file when loading XBM image�Failed to write to temporary file when loading XPM image�Failure reading GIF: %s�File�File System�File not found: %s �Files�Finishing�Fol_ders�Folders�Font�Font Selection�Full Volume�GTK+ Options�Gamma�General�High�Icon has zero height�Icon has zero width�Image Quality�Image format unknown�Image has unsupported bpp�Image has zero height�Image has zero width�Image header corrupt�Image type '%s' is not supported�Invalid URI�Invalid UTF-8�Invalid XBM file�Invalid file name�Invalid header in animation�Invalid header in icon�Job�Job Details�Keys�LRM _Left-to-right mark�Layout�License�Load additional GTK+ modules�Location�Low�MODULES�Manage Custom Sizes�Manage Custom Sizes...�Margins from Printer...�Margins: Left: %s %s Right: %s %s Top: %s %s Bottom: %s %s�Medium�Modified�Muted�NAME�Name�Name too long�New Folder�No items found�None�Not available�Odd sheets�One Sided�Op_acity:�Open '%s'�Other...�Out of paper�Outermost element in text must be <text_view_markup> not <%s>�Output Tray�Output t_ray:�PDF�PNM file has an image height of 0�PNM file has an image width of 0�Page %u�Page Setup�Pages Per Sheet�Pages per _sheet:�Pages per _side:�Paper�Paper Margins�Paper Size�Paper Source�Paper Type�Paper _source:�Paper _type:�Paused�Pick a Color�Pick a Font�Places�Position on the color wheel.�Postscript�Preparing�Preparing %d�Pri_ority:�Print�Print Document�Print to File�Print to LPR�Print to Test Printer�Printer�Printer offline�Printing %d�RLM _Right-to-left mark�Really delete file "%s"?�Received invalid color data �Remove�Remove the bookmark '%s'�Remove the selected bookmark�Rename File�Rename file "%s" to:�Rename...�SCREEN�Same as --no-wintab�Sans 12�Save in _folder:�Sc_ale:�Screen�Search�Secret�Select A File�Serialized data is malformed�Serialized data is malformed. First section isn't GTKTEXTBUFFERCONTENTS-0001�Show GTK+ Options�Show _Hidden Files�Si_ze:�Size�Specify one or more page ranges, e.g. 1-3,7,11�Standard�Status�TIFFClose operation failed�T_wo-sided:�Tag "%s" already defined�Tag "%s" does not exist in buffer and tags can not be created.�Tag "%s" has invalid priority "%s"�Tag "%s" has not been defined.�The ANI image format�The BMP image format�The GIF image format�The ICO image format�The JPEG image format�The PCX image format�The PNG image format�The PNM/PBM/PGM/PPM image format family�The TIFF image format�The Targa image format�The WBMP image format�The XBM image format�The XPM image format�The attribute "%s" was found twice on the <%s> element�The folder could not be created�The folder could not be created, as a file with the same name already exists. Try using a different name for the folder, or rename the file first.�The generated cache was invalid. �The license of the program�The previously-selected color, for comparison to the color you're selecting now. You can drag this color to a palette entry, or select this color as current by dragging it to the other color swatch alongside.�Top Secret�Translated by�Transparency of the color.�Two Sided�Unclassified�Unknown�Unknown item�Unsupported JPEG color space (%s)�Unsupported depth for ICO file: %d�Unsupported icon type�Urgent�Validate existing icon cache�Volume�Volume Down�Volume Up�Width or height of TIFF image is zero�Window�Written by�X _tilt:�X display to use�X screen to use�XPM file has image height <= 0�XPM file has image width <= 0�Y t_ilt:�Yesterday at %H:%M�_Add�_Add to Bookmarks�_After:�_Blue:�_Bottom:�_Clear List�_Device:�_Family:�_Files�_Folder name:�_Gamma value�_Green:�_Height:�_Hue:�_Left:�_License�_Location:�_Mode:�_Name:�_New Folder�_Now�_Only print:�_Orientation:�_Output format�_Palette:�_Paper size:�_Places�_Pressure:�_Preview:�_Red:�_Remove�_Remove From List�_Rename�_Rename File�_Replace�_Reverse�_Right:�_Saturation:�_Save color here�_Save in folder:�_Selection: �_Style:�_Top:�_Value:�_Wheel:�_Width:�_X:�_Y:�abcdefghijk ABCDEFGHIJK�calendar:MY�calendar:week_start:0�default:LTR�default:mm�inch�mm�none�output.%s�test-output.%s�Project-Id-Version: gtk+ 2.12.1 Report-Msgid-Bugs-To: PO-Revision-Date: 2007-09-22 14:13-0500 Last-Translator: Michael Terry <mike@mterry.name> Language-Team: Ido <gnome-ido@lists.mterry.name> Language: io MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=n != 1; �"%s" ne povis esar konvertita ad valoro de tipo "%s" por atributo "%s"�"%s" ne es valida atributala nomo�"%s" ne es valida atributala tipo�"%s" ne es valida valoro por atributo "%s"�"Profundeso" di la koloro.�%1$s an %2$s�%s tasko #%d�(Nula)�(nekapabla)�(nekonocata)�<%s>-elemento havas invalida id "%s"�<%s>-elemento havas nek "name" nek "id" atributo�<%s>-elemento ja specigabas�<text>-elemento ne povas eventar avane <tags>-elemento�Dokumento nomizita "%s" ja existas. Ka vu deziras remplasar ol?�A_d:�Pri %s�Adjuntez la nuna dokumentuyo a la markorubandi�Adjuntez la dokumentuyo '%s' a la markorubandi�Adjuntez la selektata dokumentuyo a la Markorubandi�Adjuntez la selektata dokumentuyi a la markorubandi�Omna folii�Amharala (EZ+)�Quanto de blua lumo en la koloro.�Quanto de verda lumo en la koloro.�Quanto de reda lumo en la koloro.�Anomima tago trovis ed tagi ne povas kreesar.�Programo�Artaji da�Atributo "%s" es nevalida sur <%s>-elemento en ica kuntexto�Atributo "%s" repetis duople sur la sama <%s>-elemento�Axi�_Avan:�Due "id" ed "name" esis trovita sur la <%s>-elemento�Lumozeso di la koloro.�KLASO�KOLORI�K_olacionez�K_reez�K_rediti�Trovajarala dokumento kreis sucesante. �Ne povas asignar koloromapa elementi�Ne povas asignar koloromapa strukturo�Ne povas asignar nova imajobufro�Ne povas lektar XPM-koloromapo�Cedilio�_Vakuigez�Klasifikita�Koloro�Kolorala Selektajo�Kolora Roto�Kolorala _nomo:�Imperala Lineo�Konfidencala�_Kopiuri:�Kopiuri�Kopiez URL�Kopiez _Loko�Ne povis adjuntar markorubando�Ne povis vakuigez listo�Ne povis aquirar imajala alteso (mala TIFF dokumento)�Ne povis aquirar imajala larjeso (mala TIFF dokumento)�Ne povis aquirar informo pri dokumento '%s': %s�Ne povis acensar %s�Ne povis forigar markorubando�Ne povis forigar elemento�Ne povis retronomizar %s a %s: %s. �Ne povis rinomizar %s a %s: %s �No povis rinomizar %s ad %s: %s, do forigas %s. �Ne povis aquirar informo pri la dokumento�Ne povis selektar dokumento�Ne povis startar la sercha procedo�Ne povis konvertar dokumentonomo�Ne povis krear nova imajobufro�Ne povis skribar ad BMP-dokumento�Kreez _Dokumentuyo�Kreez en _dokumentuyo:�Krediti�Desnormala Grandeso %d�Desnormala grandeso�VIDIGILO�_Efacez Dokumento�Efacez Dokumento�Pupitrosupro�Nekapabla�Dokumentizita da�Elemento <%s> ne es permisata sub <%s>�Vakua�Eroro dum kreas dokumentuyo '%s': %s�Eroro dum efacas dokumento '%s': %s�Eroro dum charjas ikono: %s�Eroro dum imprimado�Eroro dum rinomizas dokumento "%s" ad "%s": %s�Eroro dum rinomizas dokumento "%s": %s�Eroro dum rinomizas dokumento ad "%s": %s�Eroro dum skribas ad imajala dokumento: %s�Para folii�Ecesa donaji en dokumento�FLAGI�Faliis klozar '%s' dum skribas imajo, omna donaji forsan ne esabas salvita: %s�Faliis charjar RVB-donaji de TIFF-dokumento�Faliis charjar TIFF-imajo�Faliis charjar ikono�Faliis apertar imajo '%s': %s�Faliis apertar '%s' por skribo: %s�Faliis apertar TIFF-imajo�Faliis apertar dokumento '%s': %s�Faliis apertar tempala dokumento�Faliis lektar de tempala dokumento�Faliis riskribar kapo �Faliis salvar TIFF-imajo�Faliis skribar TIFF-donaji�Faliis skribar trovajarala dokumento: %s �Faliis skribar dokumentuyala indexo �Faliis skribar hachotabelo �Faliis skribar kapo �Faliis skribar a tempala dokumento dum ke charjis XBM-imajo�Faliis skribar a tempala dokumento dum ke charjis XPM-imajo�Eroro dum lektas GIF: %s�Dokumento�Dokumenta Sistemo�Dokumento netrovita: %s �Dokumenti�Finanta�_Dokumentuyi�Dokumentuyi�Tiparo�Tiparala Selektajo�Plena Lauteso�GTK+ Selekti�Lumozeso�Generala�Alta�Ikono havas zera alteso�Ikono havas zera larjeso�Imajala Qualeso�Imajala formato nekonocata�Imajo havas nesuportata bpp�Imajo havas zera alteso�Imajo havas zera larjeso�Imajala kapo es koruptita�Imajala tipo '%s' es nesuportata�Nevalida URI�Nevalida UTF-8�Nevalida XBM-dokumento�Nevalida dokumenta nomo�Nevalida kapo en animo�Nevalida kapo en ikono�Tasko�Taskala Detali�Klavi�LRM _Sinistra-a-dextra marko�Traso�Yurizo�Charjez plusa GTK+-moduli�Loko�Basa�MODULI�Direktez Desnormala Grandesi�Direktez Desnormala Grandesi...�Marjini de Imprimilo...�Marjini: Sinistra: %s %s Dextra: %s %s Supra: %s %s Infra: %s %s�Meza�Modifikita�Tacigata�NOMO�Nomo�Nomo tro longa�Nova Dokumentuyo�Nula elemteni trovita�Nula�Nedisponebla�Nepara folii�Unlatera�Op_akeso:�Apertez '%s'�Altra...�Ne plusa papero�Maxim extera elemento en texto mustas esar <text_view_markup> ne <%s>�Produkturala Pleto�Produkturala _pleto:�PDF�PNM dokumento havas imajala alteso de 0�PNM dokumento havas imajala larjeso de 0�Pagino %u�Pagina Establiso�Pagini Po Folio�Pagini po _folio:�Pagini po _latero:�Papero�Paperala Marjini�Paperala Grandeso�Paperala Fonto�Paperala Tipo�Paperala _fonto:�Paperala _tipo:�Pauzita�Selektez Koloro�Selektez Tiparo�Loki�Loko en la kolora roto.�Posskribajo�Preparas�Preparas %d�Pri_oreso:�Imprimez�Imprimez Dokumento�Imprimez a Dokumento�Imprimez a LPR�Imprimez a Testa Imprimilo�Imprimilo�Imprimilo es deskonectata�Imprimas %d�RLM _Dextra-a-sinistra marko�Reale efacar dokumento "%s"?�Recevis nevalida kolorala donaji �Forigez�Forigez la markorubando '%s'�Forigez la selektata markorubando�Rinomizez Dokumento�Rinomizez dokumento "%s" ad:�Rinomizez...�SKRENO�Sama kam --no-wintab�Sen 12�Salvez en _dokumentuyo:�Sk_alo:�Skreno�Serchez�Sekreta�Selektez Dokumento�Seriigata donaji es misforma�Seriigata donaji es misforma. Unesma seciono ne es GTKTEXTBUFFERCONTENTS-0001�Montrez GTK+ Selecti�Montrez _Celita Dokumenti�_Grandeso:�Grandeso�Specigez un o plu pagina rangi, exemple 1-3,7,11�Normala�Stando�TIFFClose-operaco faliis�_Dulatera:�Tago "%s" ja definita�Tago "%s" ne existas en bufro ed tagi ne povas kreesar.�Tago "%s" havas nevalida prioreso "%s"�Tago "%s" ne esabas definita.�La ANI imajala formato�La BMP imajala formato�La GIF imajala formato�La ICO imajala formato�La JPEG imajala formato�La PCX imajala formato�La PNG imajala formato�La PNM/PBM/PGM/PPM-imajoformatala familio�La TIFF imajala formato�La Targa imajala formato�La WBMP imajala formato�La XBM imajala formato�La XPM imajala formato�La atributo "%s" esis trovita duople sur la <%s>-elemento�La dokumentuyo ne povis kreesar�La dokumentuyo ne povis kreesar, pro ke dokumento kun la sama nomo ja existas. Esforcez uzar diferanta nomo por la dokumentuyo, od rinomizez la dokumento unesme.�La genitita trovajaro esis nevalida. �La yurizo di la programo�La exselektita koloro, por komparado a la koloro ke vu selectas nun. Vu povas tranar ica koloro a piktoplanketa elemento, o selectez ica koloro kom nuna per tranas ol a la altra koloromakulo flanke.�Maxim Sekreta�Tradukita da�Diafaneso di la koloro.�Dulatera�Neklasifikita�Nekonocata�Nekonocata elemento�Nesuportat JPEG-kolorospaco (%s)�Nesuportata profundeso por ICO-dokumento: %d�Nesuportata ikonala tipo�Urjanta�Validigez existanta ikonala trovajaro�Lauteso�Lauteso Infre�Lauteso Supre�Larjeso od alteso di TIFF imajo es zero�Fenestro�Skribita da�_X-inklino:�X-vidigilo uzota�X-skreno uzota�XPM dokumento havas imajala alteso <= 0�XPM dokumento havas imajala larjeso <= 0�_Y-inklino:�Hiere ad %H:%M�_Adjuntez�_Adjuntez a markorubandi�_Dop:�_Bluo:�_Bazo:�_Vakuigez Listo�_Aparato:�_Familio:�_Dokumenti�_Dokumentuya nomo:�_Lumozesa valoro�_Verdo:�_Alteso:�_Kolornuanco:�_Sinistra:�_Yurizo�_Loko:�_Modo:�_Nomo:�_Nova Dokumentuyo�_Nun�_Nur imprimez:�_Orientizeso:�_Produkturala formato�_Piktoplanketo:�_Paperala grandeso:�_Loki�_Presado:�_Prevido:�_Redo:�_Forigez�_Forigez de Listo�_Rinomizez�_Rinomizez Dokumento�_Remplasez�_Inversigez�_Dextra:�_Saturajo:�_Salvez koloro hike�_Salvez en dokumentuyo:�_Selektajo:�_Stilo:�_Suprajo:�_Valoro:�_Roto:�_Largeso:�_X:�_Y:�abcdefghijk ABCDEFGHIJK�calendar:YM�calendar:week_start:1�default:LTR�default:mm�inch�mm�nula�produkturo.%s�testa-produkturo.%s�PK��3�!\�U6h$��$��LC_MESSAGES/iso_3166-1.monu��[��L �� �� 2��=�� E��P��Y��a��i��p��v��~�� (��/��>��W��\��b��k��s�� &��E��J��R��Y��j��p��x�� !��&��.��:��A��G��O��U��\�� c��n��t��}�� &��.��5��=��D�� M�� X��c�� k��v��~�� 0��9��T��Y��e��l��u�� #��9��F��N�� U��`�� m��w�� #��7��?��F��S��l��s��z�� #�� "��)��1�� C��N��V�� \��f�� n��y�� &��'��=��F��S��[��d��l�� s�� 1��9��A��G��d��j��s��{�� !����2�� 8��B��G�� \��g��n��u��}�� # ��+ ��0 ��6 �� ? ��J ��R ��Z ��b ��j ��q �� z �� !�� !��!��&!��+!��4!��:!��A!��S!��\!��y!��~!��!��!��!��!��!��!��!��!��!��!��!��"��""�� ("��3"��G"��T"��\"��c"��l"��y"��"��"��"��"�� "�� "��"�� "��"��"��"��"��"�� #�� #��#��#��$#��,#��2#��D#��L#��S#��`#��v#��}#��#��#��#��#��#�� #��#�� #��#��#��#��$��$��$��c��"��f��@��U��j��L��C��/��)��+��4��Z��&��A��l��\��V��;��v��!��(��g��i��M��r��D��=��{��h��[�� $��>��.��1��I��<����q��K��R��-��8��k��G��b��n��:��s��y��9��,��]��o��e��S��J��a��d��Q��^��}��t��P��3��O��?�� x��N��_��5��H��W�� `��w��'��B��E��2��6��F��X��7��T��m��Y��u��%��z��#�� ~��\|��0��p��Afghanistan�Albania�Algeria�American Samoa�Andorra�Angola�Anguilla�Antigua and Barbuda�Argentina�Armenia�Aruba�Australia�Austria�Azerbaijan�Bahrain�Bangladesh�Barbados�Belarus�Belgium�Belize�Benin�Bermuda�Bhutan�Bolivia�Bosnia and Herzegovina�Botswana�Bouvet Island�Brazil�British Indian Ocean Territory�British Virgin Islands�Bulgaria�Burkina Faso�Burundi�Cambodia�Cameroon�Canada�Cayman Islands�Central African Republic�Chad�Chile�Colombia�Comoros�Cook Islands�Costa Rica�Croatia�Cuba�Cyprus�Czech Republic�Denmark�Djibouti�Dominica�Dominican Republic�Ecuador�Egypt�El Salvador�Equatorial Guinea�Eritrea�Ethiopia�Faroe Islands�Federated States of Micronesia�Fiji�Finland�France�French Polynesia�Gabon�Georgia�Germany�Ghana�Gibraltar�Greece�Greenland�Grenada�Guadeloupe�Guam�Guatemala�Guernsey�Guinea�Guinea-Bissau�Guyana�Haiti�Honduras�Hong Kong�Hungary�Iceland�India�Indonesia�Iraq�Ireland�Isle of Man�Israel�Italy�Jamaica�Japan�Jersey�Jordan�Kazakhstan�Kenya�Kiribati�Kuwait�Kyrgyzstan�Latvia�Lebanon�Lesotho�Liberia�Libya�Liechtenstein�Lithuania�Luxembourg�Madagascar�Malawi�Malaysia�Maldives�Mali�Malta�Martinique�Mauritania�Mauritius�Mayotte�Mexico�Moldova�Monaco�Mongolia�Montenegro�Montserrat�Morocco�Mozambique�Myanmar�Namibia�Nauru�Nepal�Netherlands�New Caledonia�New Zealand�Nicaragua�Niger�Nigeria�Niue�Norfolk Island�Northern Mariana Islands�Norway�Oman�Pakistan�Palau�Panama�Papua New Guinea�Paraguay�People's Republic of China�Peru�Philippines�Poland�Portugal�Puerto Rico�Qatar�Republic of the Congo�Romania�Rwanda�Réunion�Saint Kitts and Nevis�Saint Lucia�Saint Pierre and Miquelon�Saint Vincent and the Grenadines�Samoa�San Marino�Sao Tome and Principe�Saudi Arabia�Senegal�Serbia�Seychelles�Sierra Leone�Singapore�Slovakia�Slovenia�Solomon Islands�Somalia�South Africa�South Sudan�Spain�Sri Lanka�Sudan�Suriname�Sweden�Switzerland�Taiwan�Tajikistan�Tanzania�Thailand�Togo�Tokelau�Tonga�Trinidad and Tobago�Tunisia�Turkey�Turkmenistan�Turks and Caicos Islands�Tuvalu�Uganda�Ukraine�United Arab Emirates�United Kingdom�United States of America�Uruguay�Uzbekistan�Vanuatu�Venezuela�Vietnam�Wallis and Futuna�Yemen�Zambia�Zimbabwe�Åland Islands�Project-Id-Version: iso_3166-1 Report-Msgid-Bugs-To: https://salsa.debian.org/iso-codes-team/iso-codes/issues PO-Revision-Date: 2017-12-29 07:00+0000 Last-Translator: Chris Leonard <cjlhomeaddress@gmail.com> Language-Team: Ido <https://hosted.weblate.org/projects/iso-codes/iso-3166-1/io/> Language: io MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=n != 1; X-Generator: Weblate 2.19-dev �Afganistan�Albania�Aljeria�Usana Samoa�Andora�Angola�Anguila�Antigua e Barbuda�Arjentinia�Armenia�Aruba�Australia�Austria�Azerbaijan�Bahrain�Bangladesh�Barbados�Bielorusia�Belgia�Belize�Benin�Bermuda�Bhutan�Bolivia�Bosnia e Herzegovina�Botswana�Bouvet Insulo�Brazilia�Britaniana teritorio en Indiana Oceano�Virgin-Insuli Britana�Bulgaria�Burkina Faso�Burundi�Kambodja�Kamerun�Kanada�Kaiman-Insuli�Centrafrika�Chad�Chili�Kolumbia�Komori�Cook-Insuli�Kosta Rika�Kroatia�Kuba�Chipro�Chekia�Dania�Djibuti�Dominika�Dominikana Republiko�Equador�Egiptia�Salvador�Equatorala Guinea�Eritrea�Etiopia�Faero�Federata Stati di Mikronezia�Fidji�Finlando�Francia�Franca Polinezia�Gabon�Gruzia�Germania�Ghana�Gibraltar�Grekia�Grenlando�Grenada�Guadelupa�Guam�Guatemala�Guernsey�Guinea�Guinea Bisau�Guyana�Haiti�Honduras�Hong Kong�Hungaria�Islando�India�Indonezia�Irak�Republiko di Irlando�Man-Insulo�Israel�Italia�Jamaika�Japonia�Jersey�Jordania�Kazakstan�Kenia�Kiribati�Kuwait�Kirgizistan�Latvia�Libano�Lesotho�Liberia�Libia�Liechtenstein�Lituania�Luxemburgia�Madagaskar�Malawi�Malaizia�Maldivi�Mali�Malta�Martinik�Mauritania�Maurico�Mayotte�Mexikia�Moldova�Monako�Mongolia�Montenegro�Montserrat�Maroko�Mozambik�Myanmar�Namibia�Nauru�Nepal�Nederlando�Nova-Kaledonia�Nova-Zelando�Nikaragua�Nijer�Nigeria�Niue�Norfolk-insulo�Norda Mariani�Norvegia�Oman�Pakistan�Palau�Panama�Papua-Nova-Guinea�Paraguay�Populala Republiko di Chinia�Peru�Filipini�Polonia�Portugal�Portuo Riko�Katar�Republiko Kongo�Rumania�Ruanda�Reunion�Santa Kitts e Nevis�Santa Lucia�Santa Pierre e Mikelon�Santa Vincent e Grenadini�Samoa�San-Marino�San-Tome e Principe�Saudi-Arabia�Senegal�Serbia�Seycheli�Sierra Leone�Singapur�Slovakia�Slovenia�Insuli Salomon�Somalia�Sudafrika�Sud-Sudan�Hispania�Sri-Lanka�Sudan�Surinam�Suedia�Suisia�Republiko di Chinia�Tajikistan�Tanzania�Tailando�Togo�Tokelau�Tonga�Trinidad e Tobago�Tunizia�Turkia�Turkmenistan�Turks e Kaikos-Insuli�Tuvalu�Uganda�Ukrainia�Unionita Araba Emirati�Unionita Rejio�Usa�Uruguay�Uzbekistan�Vanuatu�Venezuela�Vietnam�Wallis e Futuna Insuli�Yemen�Zambia�Zimbabwe�Alando�PK��3�!\'q�3F��F��LC_MESSAGES/gdk-pixbuf.monu��[��:��O�� "��=��X����q��)��N��0��&��#��9��"��W��z��8��8�� 8��M��a��v�� !��5 �� W ��x �� '��' ��O ��e ��\| �� !�� "�� %��=��\��z��$�� %��, �� R ��s ��5�� 6�� !����@��k��N��+��"��8��[��!��u�� "��;��;��K�� 9�� S��t��'��(�� #��:��Q��h��)�� 8��O�� f��,��'��'��(�� ,��0��.��1��+��!��(��)��5��6��4��&�� 8��3��"��'�� :��-��/��%��7��9��$��#��2����Cannot allocate colormap entries�Cannot allocate colormap structure�Cannot allocate new pixbuf�Cannot read XPM colormap�Could not get image height (bad TIFF file)�Could not get image width (bad TIFF file)�Couldn't create new pixbuf�Couldn't write to BMP file�Error writing to image file: %s�Excess data in file�Failed to close '%s' while writing image, all data may not have been saved: %s�Failed to load RGB data from TIFF file�Failed to load TIFF image�Failed to load image '%s': %s�Failed to open '%s' for writing: %s�Failed to open TIFF image�Failed to open file '%s': %s�Failed to open temporary file�Failed to read from temporary file�Failed to save TIFF image�Failed to write TIFF data�Failed to write to temporary file when loading XBM image�Failed to write to temporary file when loading XPM image�Failure reading GIF: %s�Icon has zero height�Icon has zero width�Image format unknown�Image has unsupported bpp�Image has zero height�Image has zero width�Image header corrupt�Image type '%s' is not supported�Invalid XBM file�Invalid header in animation�Invalid header in icon�PNM file has an image height of 0�PNM file has an image width of 0�TIFFClose operation failed�The ANI image format�The BMP image format�The GIF image format�The ICO image format�The JPEG image format�The PCX image format�The PNG image format�The PNM/PBM/PGM/PPM image format family�The TIFF image format�The Targa image format�The WBMP image format�The XBM image format�The XPM image format�Unsupported JPEG color space (%s)�Unsupported depth for ICO file: %d�Unsupported icon type�Width or height of TIFF image is zero�XPM file has image height <= 0�XPM file has image width <= 0�Project-Id-Version: gtk+ 2.12.1 Report-Msgid-Bugs-To: http://bugzilla.gnome.org/enter_bug.cgi?product=gdk-pixbuf PO-Revision-Date: 2007-09-22 14:13-0500 Last-Translator: Michael Terry <mike@mterry.name> Language-Team: Ido <gnome-ido@lists.mterry.name> Language: io MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Plural-Forms: nplurals=2; plural=n != 1; �Ne povas asignar koloromapa elementi�Ne povas asignar koloromapa strukturo�Ne povas asignar nova imajobufro�Ne povas lektar XPM-koloromapo�Ne povis aquirar imajala alteso (mala TIFF dokumento)�Ne povis aquirar imajala larjeso (mala TIFF dokumento)�Ne povis krear nova imajobufro�Ne povis skribar ad BMP-dokumento�Eroro dum skribas ad imajala dokumento: %s�Ecesa donaji en dokumento�Faliis klozar '%s' dum skribas imajo, omna donaji forsan ne esabas salvita: %s�Faliis charjar RVB-donaji de TIFF-dokumento�Faliis charjar TIFF-imajo�Faliis apertar imajo '%s': %s�Faliis apertar '%s' por skribo: %s�Faliis apertar TIFF-imajo�Faliis apertar dokumento '%s': %s�Faliis apertar tempala dokumento�Faliis lektar de tempala dokumento�Faliis salvar TIFF-imajo�Faliis skribar TIFF-donaji�Faliis skribar a tempala dokumento dum ke charjis XBM-imajo�Faliis skribar a tempala dokumento dum ke charjis XPM-imajo�Eroro dum lektas GIF: %s�Ikono havas zera alteso�Ikono havas zera larjeso�Imajala formato nekonocata�Imajo havas nesuportata bpp�Imajo havas zera alteso�Imajo havas zera larjeso�Imajala kapo es koruptita�Imajala tipo '%s' es nesuportata�Nevalida XBM-dokumento�Nevalida kapo en animo�Nevalida kapo en ikono�PNM dokumento havas imajala alteso de 0�PNM dokumento havas imajala larjeso de 0�TIFFClose-operaco faliis�La ANI imajala formato�La BMP imajala formato�La GIF imajala formato�La ICO imajala formato�La JPEG imajala formato�La PCX imajala formato�La PNG imajala formato�La PNM/PBM/PGM/PPM-imajoformatala familio�La TIFF imajala formato�La Targa imajala formato�La WBMP imajala formato�La XBM imajala formato�La XPM imajala formato�Nesuportat JPEG-kolorospaco (%s)�Nesuportata profundeso por ICO-dokumento: %d�Nesuportata ikonala tipo�Larjeso od alteso di TIFF imajo es zero�XPM dokumento havas imajala alteso <= 0�XPM dokumento havas imajala larjeso <= 0�PK��LR�[2�s��detail/ostream_guard.hppnu��[��PK��LR�[`z�ge��e��detail/buffer_fill.hppnu��[��PK��LR�[)��"� �� ostream_joiner.hppnu��[��PK��LR�[�'5����� ios_state.hppnu��[��PK��LR�[�� n=��quoted.hppnu��[��PK��LR�[A�o��V��ostream_put.hppnu��[��PK��M!\k7��S'��S'��\��read_and_convert_view.hppnu��[��PK��M!\k6]� �� >��base.hppnu��[��PK��M!\Nk�\��\��e��get_reader.hppnu��[��PK��M!\��typedefs.hppnu��[��PK��M!\��M��ߪ��read_image_info.hppnu��[��PK��M!\kC4��make_backend.hppnu��[��PK��M!\�HQ1A��1A�� n��device.hppnu��[��PK��M!\�n�� get_writer.hppnu��[��PK��M!\�9��make_dynamic_image_writer.hppnu��[��PK��M!\F�Pa��(�dynamic_io_new.hppnu��[��PK��M!\ g�j'��j'��A5�read_image.hppnu��[��PK��M!\4�=�C��C�� \�error.hppnu��[��PK��M!\��7$��$��e_�make_scanline_reader.hppnu��[��PK��M!\��i��i�� k�read_view.hppnu��[��PK��M!\�� w��reader_base.hppnu��[��PK��M!\Y��T��T��make_dynamic_image_reader.hppnu��[��PK��M!\�X�� R��io.hppnu��[��PK��M!\�}�d��d�� path_spec.hppnu��[��PK��M!\��ۜ{��{��3��get_read_device.hppnu��[��PK��M!\_g<L&��&��make_reader.hppnu��[��PK��M!\��˷��V��write_view.hppnu��[��PK��M!\�c��K��make_writer.hppnu��[��PK��M!\.��4��4��_�row_buffer_helper.hppnu��[��PK��M!\��[D��bit_operations.hppnu��[��PK��M!\t�7��7��%�get_write_device.hppnu��[��PK��M!\��P��I+�conversion_policies.hppnu��[��PK��M!\ͼ�Y.'��.'��7�read_and_convert_image.hppnu��[��PK��M!\YT� �� ^�scanline_read_iterator.hppnu��[��PK��u!\��Qg��g�svg/write_svg_multi.hppnu��[��PK��u!\��\�/��/�� k�svg/write.hppnu��[��PK��u!\\|��svg/write_svg.hppnu��[��PK��u!\��CZ'7��'7��ӟ�svg/svg_mapper.hppnu��[��PK��u!\@�m/��/�� <��dsv/write.hppnu��[��PK��u!\��wkt/wkt.hppnu��[��PK��u!\�_��;��;�� wkt/write.hppnu��[��PK��u!\��F�wkt/stream.hppnu��[��PK��u!\揖��kL�wkt/detail/wkt_multi.hppnu��[��PK��u!\��[r��:R�wkt/detail/prefix.hppnu��[��PK��u!\�?aGf��f��X�wkt/read.hppnu��[��PK��3�!\щ�y=��=��˾�LC_MESSAGES/gtk30.monu��[��PK��3�!\��X��X��$��LC_MESSAGES/gtk20.monu��[��PK��3�!\�U6h$��$��mT�LC_MESSAGES/iso_3166-1.monu��[��PK��3�!\'q�3F��F��x�LC_MESSAGES/gdk-pixbuf.monu��[��PK��1�1��]��

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