Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

proto-1.0 47: Preconditions in oln::abstract::image_with_data

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 6 ++++++ oln/core/abstract/image_with_data.hh | 5 +++++ 2 files changed, 11 insertions(+) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * oln/core/abstract/image_with_data.hh (impl_size, impl_npoints) (impl_hold, impl_get, impl_set): Ensure that the image contains data. Index: olena/oln/core/abstract/image_with_data.hh --- olena/oln/core/abstract/image_with_data.hh (revision 46) +++ olena/oln/core/abstract/image_with_data.hh (working copy) @@ -70,6 +70,7 @@ const oln_size_type(E)& impl_size() const { + precondition(this->has_data()); return this->data_->size(); } @@ -83,6 +84,7 @@ unsigned long impl_npoints() const { + precondition(this->has_data()); return this->data_->npoints(); } @@ -97,6 +99,7 @@ bool impl_hold(const oln_point_type(E)& p) const { + precondition(this->has_data()); return this->data_->hold(p); } @@ -110,6 +113,7 @@ const oln_value_type(E) impl_get(const oln_point_type(E)& p) const { + precondition(this->has_data()); return this->data_->get(p); } @@ -121,6 +125,7 @@ template <typename V> void impl_set(const oln_point_type(E)& p, const V& v) { + precondition(this->has_data()); this->data_->set(p, v); }

20 years, 1 month

proto-1.0 46: Add i/o support on data types.

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * ntg/real/int_u8.hh: Add i/o support. * ntg/real/integer.hh: Likewise. * ntg/enum/enum.hh: Likewise. * ntg/enum/bin.hh: Likewise. * ntg/core/macros.hh: Likewise. * ntg/color/rgb_8.hh: Likewise. * ntg/color/color.hh: Likewise. color/color.hh | 12 ++++++++++++ color/rgb_8.hh | 32 +++++++++++++++++++++++++++++++- core/macros.hh | 6 +++++- enum/bin.hh | 3 ++- enum/enum.hh | 3 ++- real/int_u8.hh | 11 +++++++++-- real/integer.hh | 5 +++-- 7 files changed, 64 insertions(+), 8 deletions(-) Index: ntg/real/int_u8.hh --- ntg/real/int_u8.hh (revision 35) +++ ntg/real/int_u8.hh (working copy) @@ -44,7 +44,8 @@ template <> struct props<cat::integer, int_u8> : public default_props<cat::integer> { - enum { ntg_max_val = 255 }; + enum { max_val = 255 }; + typedef char io_type; }; @@ -71,6 +72,12 @@ return *this; } + int_u8& impl_assign(const unsigned char& rhs) + { + this->value_ = rhs; + return *this; + } + operator unsigned char() const { return value_; @@ -110,7 +117,7 @@ template <> struct traits < ntg::int_u8 > { - typedef char encoding_type; + typedef unsigned char encoding_type; }; } // end of namespace mlc Index: ntg/real/integer.hh --- ntg/real/integer.hh (revision 35) +++ ntg/real/integer.hh (working copy) @@ -44,7 +44,8 @@ template <> struct default_props < cat::integer > { - enum { ntg_max_val = 0 }; + enum { max_val = 0 }; + typedef mlc::no_type io_type; protected: default_props() {} @@ -58,7 +59,7 @@ template <typename V> exact_type& operator=(const V& rhs) { - return this->exact.impl_assign(rhs); + return this->exact().impl_assign(rhs); } template <typename V> Index: ntg/enum/enum.hh --- ntg/enum/enum.hh (revision 35) +++ ntg/enum/enum.hh (working copy) @@ -44,6 +44,7 @@ struct default_props < cat::enum_value > { enum { max_val = 0 }; + typedef mlc::no_type io_type; protected: default_props() {} @@ -57,7 +58,7 @@ template <typename V> exact_type& operator=(const V& rhs) { - return this->exact.impl_assign(rhs); + return this->exact().impl_assign(rhs); } template <typename V> Index: ntg/enum/bin.hh --- ntg/enum/bin.hh (revision 35) +++ ntg/enum/bin.hh (working copy) @@ -45,7 +45,8 @@ template <> struct props<cat::enum_value, bin> : public default_props<cat::enum_value> { - enum { max_val = 255 }; + enum { max_val = 1 }; + typedef unsigned char io_type; }; struct bin : public enum_value<bin> Index: ntg/core/macros.hh --- ntg/core/macros.hh (revision 35) +++ ntg/core/macros.hh (working copy) @@ -28,8 +28,12 @@ #ifndef INTEGRE_CORE_MACROS_HH # define INTEGRE_CORE_MACROS_HH -# define ntg_max_val(T) ntg::props<ntg_category_type(T),T>::ntg_max_val +# define ntg_max_val(T) ntg::props<ntg_category_type(T),T>::max_val # define ntg_nb_comp(T) ntg::props<ntg_category_type(T),T>::nb_comp +# define ntg_comp_type(T) typename ntg::props<ntg_category_type(T),T>::comp_type + +# define ntg_io_type(T) typename ntg::props<ntg_category_type(T),T>::io_type + #endif // ! INTEGRE_CORE_MACROS_HH Index: ntg/color/rgb_8.hh --- ntg/color/rgb_8.hh (revision 35) +++ ntg/color/rgb_8.hh (working copy) @@ -47,6 +47,7 @@ enum { max_val = 255 }; enum { nb_comp = 3 }; + typedef char io_type; typedef unsigned char comp_type; }; @@ -66,6 +67,12 @@ this->value_[rgb_blue] = 0; } + rgb_8(const unsigned char init[3]) + { + for (unsigned i = 0; i < 3; i++) + value_[i] = init[i]; + } + rgb_8(unsigned char red, unsigned char green, unsigned char blue) @@ -104,8 +111,19 @@ this->value_[rgb_blue] != rhs.blue(); } + unsigned char& impl_op_sqbr(unsigned int i) + { + assert(i < 3); + return value_[i]; + } + const unsigned char impl_op_sqbr(unsigned int i) const + { + assert(i < 3); + return value_[i]; + } + unsigned char& red() { return value_[rgb_red]; @@ -145,13 +163,25 @@ } // end of namespace ntg +# include <ostream> +std::ostream& operator<<(std::ostream& ostr, const ntg::rgb_8& to_print) +{ + ostr << "(" << unsigned(to_print[0]) + << "," << unsigned(to_print[1]) + << "," << unsigned(to_print[2]) + << ")"; + return ostr; +} + + + namespace mlc { template <> struct traits < ntg::rgb_8 > { - typedef unsigned char* encoding_type; + typedef ntg::rgb_8 encoding_type; }; } // end of namespace mlc Index: ntg/color/color.hh --- ntg/color/color.hh (revision 35) +++ ntg/color/color.hh (working copy) @@ -49,6 +49,7 @@ enum { max_val = 0 }; enum { nb_comp = 0 }; typedef mlc::undefined_type comp_type; + typedef mlc::undefined_type io_type; protected: @@ -59,6 +60,7 @@ struct color : public mlc::any__best_memory<E> { typedef E exact_type; + typedef typename props<cat::color, E>::comp_type comp_type; E& operator=(const exact_type& rhs) { @@ -75,6 +77,16 @@ return this->exact().impl_not_eq(rhs); } + comp_type& operator [](const unsigned int &i) + { + return this->exact().impl_op_sqbr(i); + } + + const comp_type operator [](const unsigned int &i) const + { + return this->exact().impl_op_sqbr(i); + } + protected: color() {} };

20 years, 1 month

proto-1.0 45: Add ppm and pbm i/o methods.

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/io/write_image_2d_pnm.hh: Add ppm and pbm output methods. * oln/io/read_image_2d_pnm.hh: Add ppm and pbm input methods. * oln/io/utils.hh: Fix an error occuring when writing pbm headers. * oln/core/abstract/image_with_data.hh: Remove an unexpected `return'. * oln/core/2d/image2d.hh: Fix circular inclusion problem. core/2d/image2d.hh | 8 + core/abstract/image_with_data.hh | 4 io/read_image_2d_pnm.hh | 163 +++++++++++++++++++++++++++++++-------- io/utils.hh | 8 - io/write_image_2d_pnm.hh | 102 ++++++++++++++++++++++-- 6 files changed, 242 insertions(+), 45 deletions(-) Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 44) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -53,16 +53,16 @@ namespace impl { template <typename I> - struct write_image_2d_pgm_raw - : public oln::abstract::void_op<write_image_2d_pgm_raw > + struct write_image_2d_raw + : public oln::abstract::void_op<write_image_2d_raw > { typedef oln_value_type(I) value_type; - typedef typename mlc::traits<value_type>::encoding_type out_type; + typedef ntg_io_type(value_type) io_type; const I& to_write_; std::ofstream& ostr_; - write_image_2d_pgm_raw(const I& to_write, std::ofstream& ostr): + write_image_2d_raw(const I& to_write, std::ofstream& ostr): to_write_(to_write), ostr_(ostr) {} @@ -70,19 +70,57 @@ void impl_run() { point2d p; - out_type c; + value_type c; + bool b; for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) { c = to_write_[p]; - ostr_ << c; + b = write_value_type(c); } + while (b == false) + b = write_value_type(c); ostr_.close(); } + bool write_value_type(const ntg::integer<value_type> &c) + { + ostr_ << (io_type)(c.exact()); + return true; + } + + bool write_value_type(const ntg::color<value_type> &c) + { + assert ((ntg_nb_comp(value_type) == 3)); + + for (unsigned i = 0; i < 3; i++) + ostr_ << (io_type)(c[i]); + return true; + } + + bool write_value_type(const ntg::enum_value<value_type> &c) + { + assert ((ntg_max_val(value_type) == 1)); + static int offset = 7; + static unsigned char v = 0; + bool ret = false; + + if (offset == -1) + { + ostr_ << v; + offset = 7; + v = 0; + ret = true; + } + if (c == 1) + v |= 1 << offset; + offset--; + return ret; + } }; + template <typename I, typename T> void write(const abstract::image2d& to_write, const ntg::integer<T>&, @@ -98,7 +136,7 @@ s.ncols(), s.nrows(), ntg_max_val(T))) { - write_image_2d_pgm_raw tmp(to_write.exact(), ostr); + write_image_2d_raw tmp(to_write.exact(), ostr); tmp.run(); } else @@ -108,6 +146,56 @@ << " file extension (`" << ext << "')" << std::endl; } + template <typename I, typename T> + void write(const abstract::image2d& to_write, + const ntg::color<T>&, + const std::string& name, + const std::string& ext) + { + std::ofstream ostr; + point2d p; + size2d s = to_write.size(); + + if (ext == "ppm") + if (internal::write_pnm_header(ostr, name, "P6", + s.ncols(), s.nrows(), + ntg_max_val(T))) + { + write_image_2d_raw tmp(to_write.exact(), ostr); + tmp.run(); + } + else + std::cerr << "error: unable to write header" << std::endl; + else + std::cerr << "error: image data type (`color') does not match" + << " file extension (`" << ext << "')" << std::endl; + } + + template <typename I, typename T> + void write(const abstract::image2d& to_write, + const ntg::enum_value<T>&, + const std::string& name, + const std::string& ext) + { + std::ofstream ostr; + point2d p; + size2d s = to_write.size(); + + if (ext == "pbm") + if (internal::write_pnm_header(ostr, name, "P4", + s.ncols(), s.nrows(), + ntg_max_val(T))) + { + write_image_2d_raw tmp(to_write.exact(), ostr); + tmp.run(); + } + else + std::cerr << "error: unable to write header" << std::endl; + else + std::cerr << "error: image data type (`enum_value') does not match" + << " file extension (`" << ext << "')" << std::endl; + } + } } Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 44) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -28,27 +28,56 @@ namespace impl { + template <typename I> + struct read_image_2d_raw; + } + + } + + template <typename I> + struct category_type< io::impl::read_image_2d_raw > + { + typedef cat::image ret; + }; + + template <typename I> + struct props <cat::image, io::impl::read_image_2d_raw > + : public props<cat::image, I> + { + typedef I delegated_type; + }; + + + + namespace io { + + namespace impl { + template <typename I> - struct read_image_2d_pgm_raw: - oln::abstract::void_op<read_image_2d_pgm_raw > + struct read_image_2d_raw: + oln::abstract::op<I, read_image_2d_raw > { + + typedef oln::abstract::op<I, read_image_2d_raw > super_type; + typedef oln_value_type(I) value_type; + typedef ntg_io_type(value_type) io_type; + mlc::box image_; std::ifstream& istr_; internal::pnm_info& info_; - read_image_2d_pgm_raw(I& image, - std::ifstream &istr, - internal::pnm_info &info) : + read_image_2d_raw(I& image, + std::ifstream &istr, + internal::pnm_info &info) : + super_type(image), image_(image), istr_(istr), info_(info) {} - typedef oln_value_type(I) value_type; - typedef typename mlc::traits<value_type>::encoding_type encoding_type; - read_image_2d_pgm_raw& output(I& output) + read_image_2d_raw& output(I& output) { output = *image_; return *this; @@ -56,7 +85,9 @@ void impl_run() { - encoding_type c; + value_type c; + point2d p; + oln::image2d<value_type> tmp(info_.rows, info_.cols); if (info_.max_val > ntg_max_val(value_type)) { @@ -64,26 +95,57 @@ << std::endl; return; } - point2d p; - oln::image2d<value_type> tmp(info_.rows, info_.cols); - std::cout << info_.cols << "," << info_.rows << "," - << info_.max_val << std::endl; - - for (p.row() = 0; p.row() < info_.rows && !istr_.eof(); ++p.row()) for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col()) { - istr_.read(&c, sizeof (encoding_type)); + read_value_type(c); tmp[p] = c; } istr_.close(); *image_ = tmp; - std::cout << "debug : size = " << image_->size() << std::endl; } + + void read_value_type(ntg::integer<value_type> &c) + { + io_type v; + istr_.read(&v, sizeof (io_type)); + c = v; + } + + void read_value_type(ntg::color<value_type> &c) + { + assert((ntg_nb_comp(value_type) == 3)); + io_type v; + + for (unsigned i = 0; i < 3; i++) + { + istr_.read(&v, sizeof (v)); + c[i] = v; + } + } + + void read_value_type(ntg::enum_value<value_type> &c) + { + static io_type v; + static int offset = -1; + + if (offset == -1) + { + istr_.read((char *)(&v), sizeof (v)); + offset = 7; + } + if ((int)(v & (1<<offset--)) == 0) + c = 0; + else + c = 1; + } + + }; + template <typename I, typename T> void read(abstract::image2d& ima, const ntg::integer<T>&, @@ -97,27 +159,25 @@ if (ext == "pgm") if (info.type == "P5") { - read_image_2d_pgm_raw tmp(ima.exact(), istr, info); + read_image_2d_raw tmp(ima.exact(), istr, info); tmp.run(); tmp.output(ima.exact()); } + else if (info.type == "P2") + std::cerr << "error: read_image_2d_pgm_ascii not implemented" + << std::endl; else - if (info.type == "P2") - std::cerr << "error: read_image_2d_pgm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; + std::cerr << "error: file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; else std::cerr << "error: image data type (`integer') does not match" << " file extension (`" << ext << "')" << std::endl; else std::cerr << "error: unable to get a valid header" << std::endl; - std::cout << "debug : size = " << ima.size() << std::endl; + } - } template <typename I, typename T> void read(abstract::image2d& ima, @@ -125,7 +185,29 @@ const std::string& filename, const std::string& ext) { - std::cout << "read for image2d<color>" << std::endl; + std::ifstream istr; + internal::pnm_info info; + + if (internal::read_pnm_header(istr, info, filename)) + if (ext == "ppm") + if (info.type == "P6") + { + read_image_2d_raw tmp(ima.exact(), istr, info); + tmp.run(); + tmp.output(ima.exact()); + } + else if (info.type == "P3") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else + std::cerr << "error: file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; + else + std::cerr << "error: image data type (`color') does not match" + << " file extension (`" << ext << "')" << std::endl; + else + std::cerr << "error: unable to get a valid header" << std::endl; } template <typename I, typename T> @@ -134,10 +216,31 @@ const std::string& filename, const std::string& ext) { - std::cout << "read for image2d<enum>" << std::endl; + std::ifstream istr; + internal::pnm_info info; + + if (internal::read_pnm_header(istr, info, filename)) + if (ext == "pbm") + if (info.type == "P4") + { + read_image_2d_raw tmp(ima.exact(), istr, info); + tmp.run(); + tmp.output(ima.exact()); + } + else if (info.type == "P1") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else + std::cerr << "error: file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; + else + std::cerr << "error: image data type (`enum_value') does not match" + << " file extension (`" << ext << "')" << std::endl; + else + std::cerr << "error: unable to get a valid header" << std::endl; } - } } Index: oln/io/utils.hh --- oln/io/utils.hh (revision 44) +++ oln/io/utils.hh (working copy) @@ -160,11 +160,11 @@ return false; } - - ostr << "P5" << std::endl + ostr << type << std::endl << "# Olena 1.0" << std::endl - << ncols << " " << nrows << std::endl - << max_val << std::endl; + << ncols << " " << nrows << std::endl; + if (type != "P1" && type != "P4") + ostr << max_val << std::endl; return true; } Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 44) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -121,7 +121,7 @@ template <typename V> void impl_set(const oln_point_type(E)& p, const V& v) { - return this->data_->set(p, v); + this->data_->set(p, v); } /*! \brief True if the image contains data. @@ -130,8 +130,8 @@ { return data_ != 0; } - + protected: /*! \brief Constructor (protected) with no memory allocation for Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 44) +++ oln/core/2d/image2d.hh (working copy) @@ -34,14 +34,20 @@ # include <oln/core/abstract/image_with_data.hh> # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> -# include <oln/io/read_image.hh> /*! \namespace oln ** \brief oln namespace. */ namespace oln { + namespace io { + struct filename; + + template <typename I> + void do_read(abstract::image&, const filename&); + } + // fwd decl template <typename T> class image2d;

20 years, 1 month

proto-1.0 44: g++-3.4 compliance

by simon odou

Index: ChangeLog from simon odou <simon(a)lrde.epita.fr> * oln/core/entry.hh: g++-3.4 compliance. entry.hh | 8 +++++--- 1 files changed, 5 insertions(+), 3 deletions(-) Index: oln/core/entry.hh --- oln/core/entry.hh (revision 43) +++ oln/core/entry.hh (working copy) @@ -48,9 +48,11 @@ template <typename E> struct image_entry : - public props < cat::image, E >::image_constness::inherits<E>::ret, - public props < cat::image, E >::image_dimension::inherits<E>::ret - // ... + public props < cat::image, E >::image_constness + ::template inherits<E>::ret, + public props < cat::image, E >::image_dimension + ::template inherits<E>::ret + // ... { protected: image_entry() {}

20 years, 1 month

proto-1.0 42: A basic property heredity system

by simon odou

Index: ChangeLog from simon odou <simon(a)lrde.epita.fr> * oln/core/entry.hh: New. Just a basic and temporary property heredity system. * oln/core/abstract/images.hh: Likewise. * oln/core/abstract/image_with_data.hh: Likewiwe. * oln/core/abstract/image_identity.hh: Likewiwe. * oln/core/1d/image1d.hh: Likewiwe. * oln/core/2d/image2d.hh: Likewiwe. * oln/core/3d/image3d.hh: Likewiwe. * tests/core/tests/readonly_image: Likewiwe. * tests/core/tests/readwrite_image: Likewiwe. * oln/core/tags.hh: Remove. Old heredity system. * oln/makefile.src: Remove tags.hh, add entry.hh. oln/core/1d/image1d.hh | 8 - oln/core/2d/image2d.hh | 8 - oln/core/3d/image3d.hh | 8 - oln/core/abstract/image_identity.hh | 2 oln/core/abstract/image_with_data.hh | 2 oln/core/abstract/images.hh | 2 oln/core/entry.hh | 64 +++++++++++++++ oln/core/tags.hh | 144 ----------------------------------- oln/makefile.src | 2 tests/core/tests/readonly_image | 4 tests/core/tests/readwrite_image | 5 - 11 files changed, 85 insertions(+), 164 deletions(-) Index: tests/core/tests/readonly_image --- tests/core/tests/readonly_image (revision 41) +++ tests/core/tests/readonly_image (working copy) @@ -24,8 +24,8 @@ typedef mlc_encoding_type_(value_type) value_storage_type; typedef array2d<value_storage_type> value_container_type; - typedef tag::readonly constness_tag; - typedef tag::dimension2 dimension_tag; + typedef prop_of<abstract::readonly_image> image_constness; + typedef prop_of<abstract::image2d> image_dimension; typedef mlc::no_type delegated_type; }; Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 41) +++ tests/core/tests/readwrite_image (working copy) @@ -17,6 +17,9 @@ struct props <cat::image, dummy_image> : public default_props < cat::image > { + typedef prop_of<abstract::readwrite_image> image_constness; + typedef prop_of<abstract::image2d> image_dimension; + typedef size2d size_type; typedef point2d point_type; typedef ntg::int_u8 value_type; @@ -24,8 +27,6 @@ typedef mlc_encoding_type_(value_type) value_storage_type; typedef array2d<value_storage_type> value_container_type; - typedef tag::readwrite constness_tag; - typedef tag::dimension2 dimension_tag; typedef mlc::no_type delegated_type; }; Index: oln/makefile.src --- oln/makefile.src (revision 41) +++ oln/makefile.src (working copy) @@ -38,7 +38,7 @@ core/coord.hh \ core/macros.hh \ core/props.hh \ - core/tags.hh \ + core/entry.hh \ core/value_box.hh \ fancy/iota.hh \ fancy/print.hh \ Index: oln/core/entry.hh --- oln/core/entry.hh (revision 0) +++ oln/core/entry.hh (revision 0) @@ -0,0 +1,64 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ENTRY_HH +# define OLENA_CORE_ENTRY_HH + +# include <oln/core/abstract/image_constness.hh> +# include <oln/core/abstract/image_dimension.hh> + + +namespace oln { + + template <template <typename> class Base> + struct prop_of + { + template <typename E> + struct inherits + { + typedef Base<E> ret; + }; + }; + + namespace abstract { + + template <typename E> + struct image_entry : + public props < cat::image, E >::image_constness::inherits<E>::ret, + public props < cat::image, E >::image_dimension::inherits<E>::ret + // ... + { + protected: + image_entry() {} + }; + + } + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ENTRY_HH Index: oln/core/abstract/images.hh --- oln/core/abstract/images.hh (revision 41) +++ oln/core/abstract/images.hh (working copy) @@ -36,7 +36,7 @@ # include <oln/core/abstract/image_constness.hh> -# include <oln/core/tags.hh> +# include <oln/core/entry.hh> #endif // ! OLENA_CORE_ABSTRACT_IMAGES_HH Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 41) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -31,7 +31,7 @@ # include <mlc/tracked_ptr.hh> -# include <oln/core/tags.hh> +# include <oln/core/entry.hh> # include <oln/core/macros.hh> /*! \namespace oln Index: oln/core/abstract/image_identity.hh --- oln/core/abstract/image_identity.hh (revision 41) +++ oln/core/abstract/image_identity.hh (working copy) @@ -30,7 +30,7 @@ # include <mlc/box.hh> -# include <oln/core/tags.hh> +# include <oln/core/entry.hh> namespace oln { Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 41) +++ oln/core/1d/image1d.hh (working copy) @@ -57,6 +57,10 @@ template <typename T> struct props < cat::image, image1d<T> > : public default_props < cat::image > { + // intrusive properties + typedef prop_of<abstract::readwrite_image> image_constness; + typedef prop_of<abstract::image1d> image_dimension; + typedef mlc::no_type delegated_type; typedef size1d size_type; @@ -72,10 +76,6 @@ // FIXME: find a better name... typedef array1d<value_storage_type> value_container_type; - // tags - typedef tag::readwrite constness_tag; - typedef tag::dimension1 dimension_tag; - // functions template <typename U> Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 41) +++ oln/core/2d/image2d.hh (working copy) @@ -61,6 +61,10 @@ template <typename T> struct props < cat::image, image2d<T> > : public default_props < cat::image > { + // intrusive properties + typedef prop_of<abstract::readwrite_image> image_constness; + typedef prop_of<abstract::image2d> image_dimension; + typedef mlc::no_type delegated_type; typedef size2d size_type; @@ -79,10 +83,6 @@ // FIXME: find a better name... typedef array2d<value_storage_type> value_container_type; - // tags - typedef tag::readwrite constness_tag; - typedef tag::dimension2 dimension_tag; - // functions template <typename U> Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 41) +++ oln/core/3d/image3d.hh (working copy) @@ -58,6 +58,10 @@ template <typename T> struct props < cat::image, image3d<T> > : public default_props < cat::image > { + // intrusive properties + typedef prop_of<abstract::readwrite_image> image_constness; + typedef prop_of<abstract::image3d> image_dimension; + typedef mlc::no_type delegated_type; typedef size3d size_type; @@ -73,10 +77,6 @@ // FIXME: find a better name... typedef array3d<value_storage_type> value_container_type; - // tags - typedef tag::readwrite constness_tag; - typedef tag::dimension3 dimension_tag; - // functions template <typename U> Index: oln/core/tags.hh --- oln/core/tags.hh (revision 41) +++ oln/core/tags.hh (working copy) @@ -1,144 +0,0 @@ -// Copyright (C) 2005 EPITA Research and Development Laboratory -// -// This file is part of the Olena Library. This library is free -// software; you can redistribute it and/or modify it under the terms -// of the GNU General Public License version 2 as published by the -// Free Software Foundation. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this library; see the file COPYING. If not, write to -// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -// MA 02111-1307, USA. -// -// As a special exception, you may use this file as part of a free -// software library without restriction. Specifically, if other files -// instantiate templates or use macros or inline functions from this -// file, or you compile this file and link it with other files to -// produce an executable, this file does not by itself cause the -// resulting executable to be covered by the GNU General Public -// License. This exception does not however invalidate any other -// reasons why the executable file might be covered by the GNU General -// Public License. - -#ifndef OLENA_CORE_TAGS_HH -# define OLENA_CORE_TAGS_HH - -# include <oln/core/abstract/image_constness.hh> -# include <oln/core/abstract/image_dimension.hh> - -#define oln_tag_decl(TAG) \ - \ -struct TAG \ -{ \ -protected: \ - TAG() {} \ -} - - -#define oln_tag_decl_case(MTAG, TAG, MCLASS) \ - \ -struct TAG : public MTAG \ -{ \ -protected: \ - TAG() {} \ -}; \ - \ -namespace internal { \ - \ - template <typename E> \ - struct image_case < TAG, E > : public MCLASS <E> \ - { \ - protected: \ - image_case() {} \ - }; \ -} - - -#define oln_tag_decl_retrieve_from_props(TAG) \ - \ -template <typename E> \ -struct retrieve < tag::TAG, E > \ -{ \ - typedef typename props<cat::image,E>::TAG##_tag ret; /* FIXME: ok? */ \ - /* static test if ret derives from tag::TAG */ \ -} - - - -namespace oln { - - - namespace tag { - - - namespace internal { - - template <typename TAG, typename E> struct image_case; - template <typename TAG, typename E> struct retrieve; - - } // end of namespace tag::internal - - - oln_tag_decl ( constness ); - oln_tag_decl_case( constness, readonly, abstract::readonly_image ) - oln_tag_decl_case( constness, readwrite, abstract::readwrite_image ) - - oln_tag_decl ( dimension ); - oln_tag_decl_case( dimension, dimension1, abstract::image1d) - oln_tag_decl_case( dimension, dimension2, abstract::image2d) - oln_tag_decl_case( dimension, dimension3, abstract::image3d) - - namespace internal { - - template <typename E> - struct retrieve < tag::constness, E > - { - typedef typename props<cat::image,E>::constness_tag ret; // FIXME: ok? - // test if ret derives from constness_tag - }; - - template <typename E> - struct retrieve < tag::dimension, E > - { - typedef typename props<cat::image,E>::dimension_tag ret; // FIXME: ok? - // test if ret derives from constness_tag - }; - - - template <typename TAG, typename E> - struct image_switch : - public image_case< typename retrieve<TAG,E>::ret, E> - { - protected: - image_switch() {} - }; - - - } // end of namespace tag::internal - - } // end of namespace tag - - - namespace abstract { - - template <typename E> - struct image_entry : - public tag::internal::image_switch < tag::constness, E >, - public tag::internal::image_switch < tag::dimension, E > - // ... - { - protected: - image_entry() {} - }; - - } - -} // end of namespace oln - - -#endif // ! OLENA_CORE_TAGS_HH

20 years, 1 month

proto-1.0 41: More pgm i/o on image2d

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Add new files. * oln/io/write_image_2d_pnm.hh: New. pgm output method for 2D images. * oln/io/read_image_2d_pnm.hh: Handle mlc::box correctly. * oln/io/write_image.hh: New. Dispatch for output methods. * oln/io/read_image.hh: Handle mlc::box correctly.. * oln/io/utils.hh: Add pnm_write_header function. io/read_image.hh | 30 +++++++++++ io/read_image_2d_pnm.hh | 20 +++++-- io/utils.hh | 32 ++++++++++++ io/write_image.hh | 63 ++++++++++++++++++++++++ io/write_image_2d_pnm.hh | 119 +++++++++++++++++++++++++++++++++++++++++++++++ makefile.src | 5 + 6 files changed, 260 insertions(+), 9 deletions(-) Index: oln/makefile.src --- oln/makefile.src (revision 40) +++ oln/makefile.src (working copy) @@ -30,6 +30,7 @@ core/abstract/image_with_data.hh \ core/abstract/images.hh \ core/abstract/internal/image_impl.hh \ + core/abstract/op.hh \ core/abstract/piter.hh \ core/abstract/point.hh \ core/abstract/size.hh \ @@ -43,4 +44,6 @@ fancy/print.hh \ io/read_image.hh \ io/read_image_2d_pnm.hh \ - io/utils.hh + io/utils.hh \ + io/write_image.hh \ + io/write_image_2d_pnm.hh Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 0) +++ oln/io/write_image_2d_pnm.hh (revision 0) @@ -0,0 +1,119 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + + +#ifndef OLN_IO_WRITE_IMAGE_2D_PNM_HH +# define OLN_IO_WRITE_IMAGE_2D_PNM_HH + +# include <iostream> +# include <string> + +# include <mlc/box.hh> + +# include <ntg/core/macros.hh> +# include <ntg/real/int_u8.hh> +# include <ntg/real/integer.hh> +# include <ntg/enum/enum.hh> +# include <ntg/color/color.hh> + +# include <oln/core/2d/image2d.hh> +# include <oln/core/macros.hh> +# include <oln/core/abstract/op.hh> + +# include <oln/io/utils.hh> + +namespace oln { + + namespace io { + + namespace impl { + + template <typename I> + struct write_image_2d_pgm_raw + : public oln::abstract::void_op<write_image_2d_pgm_raw > + { + typedef oln_value_type(I) value_type; + typedef typename mlc::traits<value_type>::encoding_type out_type; + + const I& to_write_; + std::ofstream& ostr_; + + write_image_2d_pgm_raw(const I& to_write, std::ofstream& ostr): + to_write_(to_write), + ostr_(ostr) + {} + + void impl_run() + { + point2d p; + out_type c; + + for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) + for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) + { + c = to_write_[p]; + ostr_ << c; + } + ostr_.close(); + } + + }; + + template <typename I, typename T> + void write(const abstract::image2d& to_write, + const ntg::integer<T>&, + const std::string& name, + const std::string& ext) + { + std::ofstream ostr; + point2d p; + size2d s = to_write.size(); + + if (ext == "pgm") + if (internal::write_pnm_header(ostr, name, "P5", + s.ncols(), s.nrows(), + ntg_max_val(T))) + { + write_image_2d_pgm_raw tmp(to_write.exact(), ostr); + tmp.run(); + } + else + std::cerr << "error: unable to write header" << std::endl; + else + std::cerr << "error: image data type (`integer') does not match" + << " file extension (`" << ext << "')" << std::endl; + } + + } + + } + +} + + + +#endif // ! OLN_IO_WRITE_IMAGE_2D_PNM_HH Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 40) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -48,6 +48,12 @@ typedef oln_value_type(I) value_type; typedef typename mlc::traits<value_type>::encoding_type encoding_type; + read_image_2d_pgm_raw& output(I& output) + { + output = *image_; + return *this; + } + void impl_run() { encoding_type c; @@ -58,7 +64,6 @@ << std::endl; return; } - c =c ; point2d p; oln::image2d<value_type> tmp(info_.rows, info_.cols); @@ -74,7 +79,7 @@ } istr_.close(); *image_ = tmp; - + std::cout << "debug : size = " << image_->size() << std::endl; } }; @@ -94,21 +99,24 @@ { read_image_2d_pgm_raw tmp(ima.exact(), istr, info); tmp.run(); + tmp.output(ima.exact()); } else if (info.type == "P2") - std::cerr << "read_image_2d_pgm_ascii not implemented" + std::cerr << "error: read_image_2d_pgm_ascii not implemented" << std::endl; else - std::cerr << "file header (`" << info.type + std::cerr << "error: file header (`" << info.type << "') does not match file extension (`" << ext << "')" << std::endl; else - std::cerr << "image data type (`integer') does not match" + std::cerr << "error: image data type (`integer') does not match" << " file extension (`" << ext << "')" << std::endl; else - std::cerr << "bad header" << std::endl; + std::cerr << "error: unable to get a valid header" << std::endl; + std::cout << "debug : size = " << ima.size() << std::endl; + } template <typename I, typename T> Index: oln/io/write_image.hh --- oln/io/write_image.hh (revision 0) +++ oln/io/write_image.hh (revision 0) @@ -0,0 +1,63 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_IO_WRITE_IMAGE_HH +# define OLN_IO_WRITE_IMAGE_HH + +# include <string> + +# include <oln/io/utils.hh> +# include <oln/io/write_image_2d_pnm.hh> + +namespace oln { + + namespace io { + + template <typename E> + void write(const abstract::image<E>& im, const std::string& name) + { + std::string ext; + oln_value_type(E) t; + + ext = internal::utils::extension(name); + + if (ext == "pgm" || + ext == "ppm" || + ext == "pbm") + impl::write(im.exact(), t, name, ext); + else + std::cerr << "error: output method for '" + << name.c_str() + << "' not implemented" + << std::endl; + } + + } + +} + +#endif // ! OLN_IO_WRITE_IMAGE_HH Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 40) +++ oln/io/read_image.hh (working copy) @@ -1,3 +1,30 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + #ifndef OLN_IO_READ_IMAGE_HH # define OLN_IO_READ_IMAGE_HH @@ -13,7 +40,6 @@ namespace oln { - namespace io { struct filename @@ -51,7 +77,7 @@ { std::cout << "input method for '" << name.get() - << "' not implemented yet" + << "' not implemented" << std::endl; } Index: oln/io/utils.hh --- oln/io/utils.hh (revision 40) +++ oln/io/utils.hh (working copy) @@ -137,6 +137,38 @@ return true; } + bool write_pnm_header(std::ofstream& ostr, + const std::string& name, + const std::string& type, + int ncols, + int nrows, + int max_val) + { + if (max_val > 65535) + { + std::cerr << "error: can't save " << name + << ", data type too large" + << std::endl; + return false; + } + + ostr.open(name.c_str(), std::ofstream::out); + + if (ostr.is_open() == false) + { + std::cerr << "error: couldn't open " << name << std::endl; + return false; + } + + + ostr << "P5" << std::endl + << "# Olena 1.0" << std::endl + << ncols << " " << nrows << std::endl + << max_val << std::endl; + return true; + } + + } // end of namespace internal } // end of namespace io

20 years, 1 month

proto-1.0 40: Add pgm i/o for image2d

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Add new files. * oln/io: New. * oln/io/read_image_2d_pnm.hh: New. 2D image pnm i/o (only raw pgm at the moment). * oln/io/read_image.hh: New. Abstract input routine. * oln/io/utils.hh: New. Tools for i/o manipulations. * oln/core/abstract/op.hh: New. Algorithms abstract class. core/abstract/op.hh | 75 ++++++++++++++++++++++++ io/read_image.hh | 64 +++++++++++++++++++++ io/read_image_2d_pnm.hh | 140 ++++++++++++++++++++++++++++++++++++++++++++++ io/utils.hh | 146 ++++++++++++++++++++++++++++++++++++++++++++++++ makefile.src | 10 +-- 5 files changed, 430 insertions(+), 5 deletions(-) Index: oln/makefile.src --- oln/makefile.src (revision 37) +++ oln/makefile.src (working copy) @@ -26,21 +26,21 @@ core/abstract/data_storage.hh \ core/abstract/image.hh \ core/abstract/image_constness.hh \ + core/abstract/image_identity.hh \ core/abstract/image_with_data.hh \ core/abstract/images.hh \ core/abstract/internal/image_impl.hh \ - core/abstract/morpher.hh \ core/abstract/piter.hh \ core/abstract/point.hh \ core/abstract/size.hh \ core/cats.hh \ core/coord.hh \ core/macros.hh \ - core/id_morpher.hh \ core/props.hh \ core/tags.hh \ core/value_box.hh \ fancy/iota.hh \ - fancy/print.hh - - + fancy/print.hh \ + io/read_image.hh \ + io/read_image_2d_pnm.hh \ + io/utils.hh Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 0) +++ oln/io/read_image_2d_pnm.hh (revision 0) @@ -0,0 +1,140 @@ +#ifndef OLN_IO_READ_IMAGE_2D_PNM_HH +# define OLN_IO_READ_IMAGE_2D_PNM_HH + +# include <iostream> +# include <string> + +# include <mlc/box.hh> + +# include <ntg/core/macros.hh> +# include <ntg/real/int_u8.hh> +# include <ntg/real/integer.hh> +# include <ntg/enum/enum.hh> +# include <ntg/color/color.hh> + +# include <oln/core/2d/image2d.hh> +# include <oln/core/macros.hh> +# include <oln/core/abstract/op.hh> + +# include <oln/io/utils.hh> + + +namespace oln { + + template <typename I> + struct image2d; + + namespace io { + + namespace impl { + + + template <typename I> + struct read_image_2d_pgm_raw: + oln::abstract::void_op<read_image_2d_pgm_raw > + { + mlc::box image_; + std::ifstream& istr_; + internal::pnm_info& info_; + + read_image_2d_pgm_raw(I& image, + std::ifstream &istr, + internal::pnm_info &info) : + image_(image), + istr_(istr), + info_(info) + {} + + typedef oln_value_type(I) value_type; + typedef typename mlc::traits<value_type>::encoding_type encoding_type; + + void impl_run() + { + encoding_type c; + + if (info_.max_val > ntg_max_val(value_type)) + { + std::cerr << "Can't load image, data type is not large enough" + << std::endl; + return; + } + c =c ; + point2d p; + oln::image2d<value_type> tmp(info_.rows, info_.cols); + + std::cout << info_.cols << "," << info_.rows << "," + << info_.max_val << std::endl; + + + for (p.row() = 0; p.row() < info_.rows && !istr_.eof(); ++p.row()) + for (p.col() = 0; p.col() < info_.cols && !istr_.eof(); ++p.col()) + { + istr_.read(&c, sizeof (encoding_type)); + tmp[p] = c; + } + istr_.close(); + *image_ = tmp; + + } + }; + + + template <typename I, typename T> + void read(abstract::image2d& ima, + const ntg::integer<T>&, + const std::string& filename, + const std::string& ext) + { + std::ifstream istr; + internal::pnm_info info; + + if (internal::read_pnm_header(istr, info, filename)) + if (ext == "pgm") + if (info.type == "P5") + { + read_image_2d_pgm_raw tmp(ima.exact(), istr, info); + tmp.run(); + } + else + if (info.type == "P2") + std::cerr << "read_image_2d_pgm_ascii not implemented" + << std::endl; + else + std::cerr << "file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; + else + std::cerr << "image data type (`integer') does not match" + << " file extension (`" << ext << "')" << std::endl; + else + std::cerr << "bad header" << std::endl; + + } + + template <typename I, typename T> + void read(abstract::image2d& ima, + const ntg::color<T>&, + const std::string& filename, + const std::string& ext) + { + std::cout << "read for image2d<color>" << std::endl; + } + + template <typename I, typename T> + void read(abstract::image2d& ima, + const ntg::enum_value<T>&, + const std::string& filename, + const std::string& ext) + { + std::cout << "read for image2d<enum>" << std::endl; + } + + + } + + } + +} + + +#endif // ! OLN_IO_READ_IMAGE_2D_PNM_HH Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 0) +++ oln/io/read_image.hh (revision 0) @@ -0,0 +1,64 @@ +#ifndef OLN_IO_READ_IMAGE_HH +# define OLN_IO_READ_IMAGE_HH + +# include <iostream> +# include <string> + +# include <mlc/box.hh> + +# include <oln/core/macros.hh> + +# include <oln/io/read_image_2d_pnm.hh> +# include <oln/io/utils.hh> + +namespace oln { + + + namespace io { + + struct filename + { + explicit filename(const std::string& str) : + str_(str) + {} + const std::string& get() const + { + return str_; + } + private: + std::string str_; + }; + + filename read(const std::string& str) + { + filename tmp(str); + return tmp; + } + + template <typename I> + void do_read(abstract::image& ima, const filename& name) + { + std::string ext; + const oln_value_type(I) t; + + ext = internal::utils::extension(name.get()); + + if (ext == "pgm" || + ext == "pbm" || + ext == "ppm") + impl::read(ima.exact(), t, name.get(), ext); + else + { + std::cout << "input method for '" + << name.get() + << "' not implemented yet" + << std::endl; + } + + } + + } + +} + +#endif // ! OLN_IO_READ_IMAGE_HH Index: oln/io/utils.hh --- oln/io/utils.hh (revision 0) +++ oln/io/utils.hh (revision 0) @@ -0,0 +1,146 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_IO_UTILS_HH +# define OLENA_IO_UTILS_HH + +# include <oln/config/system.hh> + +# include <iostream> +# include <fstream> +# include <string> + +namespace oln { + + namespace io { + + namespace internal { + + /*! + ** \brief Utils for io (get extension of a file). + */ + struct utils + { + + /*! + ** \brief Return the extension of a filename. + ** \arg name The filename. + ** \return The extension (lower case). + */ + static std::string + extension(const std::string& name) + { + std::string ext; + int pos = name.rfind('.'); + if (pos > 0) + { + ext.assign(name, pos + 1, name.size() - pos); + for (std::string::iterator i = ext.begin(); i != ext.end(); ++i) + *i = tolower(*i); + } + return ext; + } + + }; + + + struct pnm_info + { + int max_val; + int rows; + int cols; + std::string type; + }; + + bool read_pnm_header(std::ifstream& istr, + internal::pnm_info& info, + const std::string& name) + { + istr.open(name.c_str(), std::ifstream::in); + + if (!istr.is_open()) + return false; + + std::getline(istr, info.type); + + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + // read size + istr >> info.cols; + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + + istr >> info.rows; + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + if (info.cols <= 0 || info.rows <= 0) return false; + + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + + // FIXME: it can be either '\n', 'whitespace', ..., not only '\n'! + + // extract or skip maxvalue + if (istr.get() != '\n') return false; + if (info.type != "P1" && info.type != "P4") + { + istr >> info.max_val; + if (info.max_val > 65535 || + istr.get() != '\n' || + info.max_val <= 0) + return false; + } + return true; + } + + } // end of namespace internal + + } // end of namespace io + +} // end of namespace oln + +#endif // ! OLENA_IO_UTILS_HH Index: oln/core/abstract/op.hh --- oln/core/abstract/op.hh (revision 0) +++ oln/core/abstract/op.hh (revision 0) @@ -0,0 +1,75 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_CORE_ABSTRACT_OP_HH +# define OLENA_CORE_ABSTRACT_OP_HH + +# include <oln/core/abstract/image_identity.hh> + +namespace oln { + + namespace abstract { + + template <typename I, typename E> + struct op : public oln::abstract::image_identity<I, E> + { + typedef oln::abstract::image_identity<I, E> super_type; + + op(I& ref): super_type(ref) + { + this->exact_ptr = (E*)(void*)(this); + } + + op() {} + + void run() + { + impl_run(); + } + virtual void impl_run() + { + std::cerr << "oops (nothing)" << std::endl; + } + }; + + + template <typename E> + struct void_op : public mlc::any<E> + { + void_op() {} + + void run() + { + this->exact().impl_run(); + } + }; + + } + +} + +#endif // ! OLENA_CORE_ABSTRACT_OP_HH

20 years, 1 month

proto-1.0 39: Fix on revision 38

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/any.hh: Fix. any.hh | 3 +-- 1 files changed, 1 insertion(+), 2 deletions(-) Index: mlc/any.hh --- mlc/any.hh (revision 38) +++ mlc/any.hh (working copy) @@ -1,4 +1,3 @@ -vcs: warn: unknown method cat! // Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free @@ -30,7 +29,7 @@ #ifndef METALIC_ANY_HH # define METALIC_ANY_HH -# include <contract.hh> +# include <mlc/contract.hh> // abbrev

20 years, 1 month

proto-1.0 38: Add empty constructor to mlc::box

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/any.hh: Add missing header inclusion. * mlc/box.hh: Add empty constructor for mlc::box. any.hh | 9 +++++---- box.hh | 6 +++++- 2 files changed, 10 insertions(+), 5 deletions(-) Index: mlc/any.hh --- mlc/any.hh (revision 37) +++ mlc/any.hh (working copy) @@ -1,3 +1,4 @@ +vcs: warn: unknown method cat! // Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free @@ -29,9 +30,9 @@ #ifndef METALIC_ANY_HH # define METALIC_ANY_HH +# include <contract.hh> - // abbrev #define any_mem(E) any <E, dispatch_policy::best_memory> @@ -70,7 +71,7 @@ precondition(exact_ptr != 0); return *exact_ptr; } - + /// Assignment (op=). any& operator=(const any& rhs) @@ -118,11 +119,11 @@ const E& exact() const { return *(const E*)((const char*)this - exact_offset); } - + static const int exact_offset; static const E exact_obj; static const any_mem(E)& ref_exact_obj; - + protected: any() {} any(E* exact_ptr_does_not_exist_in_this_version); // safety Index: mlc/box.hh --- mlc/box.hh (revision 37) +++ mlc/box.hh (working copy) @@ -29,7 +29,7 @@ # define METALIC_BOX_HH -namespace mlc +namespace mlc { template <class T> @@ -39,6 +39,8 @@ ref(ref) {} + box() {} + box(const box<T>& rhs) : ref(rhs.ref) {} @@ -80,6 +82,8 @@ ref(const_cast<T&>(ref)) {} + box() {} + box(const box<T>& rhs) : ref(const_cast<T&>(rhs.ref)) {}

20 years, 1 month

oln 10.221: Fix the definition of oln_fwd_iter_type_

by Roland Levillain

When I found this bug, I thought I was lucky not to have wasted too much time understanding the strange messages of the compiler (damn macros!). Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * oln/core/abstract/image.hh (oln_fwd_iter_type_): Fix macro definition. Index: olena/oln/core/abstract/image.hh --- olena/oln/core/abstract/image.hh Tue, 13 Apr 2004 17:31:32 +0200 van-vl_n (oln/t/25_image.hh 1.32 600) +++ olena/oln/core/abstract/image.hh Thu, 24 Feb 2005 10:08:32 +0100 levill_r (oln/t/25_image.hh 1.32 600) @@ -356,7 +356,7 @@ # define oln_fwd_iter_type(Fwd_Iterable) \ mlc_exact_type(Fwd_Iterable)::fwd_iter_type # define oln_fwd_iter_type_(Fwd_Iterable) \ -mlc_exact_type_(Fwd_Iterable) +mlc_exact_type_(Fwd_Iterable)::fwd_iter_type # define oln_bkd_iter_type(Bkd_Iterable) \ mlc_exact_type(Bkd_Iterable)::bkd_iter_type

20 years, 1 month

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches