Olena-patches July 2005

olena-patches@lrde.epita.fr

4 participants
41 discussions

by Roland Levillain

ChangeLog | 9 +++++++++ oln/morpho/elementary_dilation.hh | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix elementary dilation. * oln/morpho/elementary_dilation.hh (elementary_dilation_(const abstract::binary_image&)) (elementary_dilation_(const abstract::not_binary_image&)): Fix elementary dilation definition. 2005-07-19 Roland Levillain <roland(a)lrde.epita.fr> Index: olena/oln/morpho/elementary_dilation.hh --- olena/oln/morpho/elementary_dilation.hh (révision 252) +++ olena/oln/morpho/elementary_dilation.hh (copie de travail) @@ -66,7 +66,7 @@ oln_type_of(I, piter) p(input.size()); for_all_p (p) - output[p] = local_and_value(input, p); + output[p] = local_or_value(input, p); exiting("->generic_on_set"); return output; @@ -89,7 +89,7 @@ oln_type_of(I, piter) p(input.size()); for_all_p (p) - output[p] = local_inf_value(input, p); + output[p] = local_sup_value(input, p); exiting("->generic_on_function"); return output;

19 years, 5 months

proto-1.0 252: Fix PBM (binary) image reading and writing (cont.)

by Roland Levillain

Rappel : il y a un piège avec les images binaires PBM : un bit à 0 signifie « objet » (blanc), un bit à 1 signifie « fond » (noir). C'est contre-intuitif, mais c'est comme ça qu'est défini le format binaire. ChangeLog | 8 ++++++++ oln/io/pnm_bin.hh | 6 +++--- 2 files changed, 11 insertions(+), 3 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix PBM (binary) image reading and writing (cont.). * oln/io/pnm_bin.hh (read_bin<oln::grid2d>::impl_read_value) (write_bin<oln::grid2d>::impl_write_value): Swap read value, as specified in the PBM specification (1 for black, 0 for white). 2005-07-19 Roland Levillain <roland(a)lrde.epita.fr> Index: olena/oln/io/pnm_bin.hh --- olena/oln/io/pnm_bin.hh (révision 250) +++ olena/oln/io/pnm_bin.hh (copie de travail) @@ -80,9 +80,9 @@ offset = 7; } if ((int)(v & (1<<offset--)) == 0) - return false; - else return true; + else + return false; } void impl_next_point() @@ -154,7 +154,7 @@ offset = 7; v = 0; } - if (b == true) + if (b == false) v |= 1 << offset; offset--; }

19 years, 5 months

proto-1.0 251: Force ntg to use its own operators.

by Thierry GERAUD

2005-07-19 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> Force ntg to use its own operators when a third part also defines similar operators. * ntg/real/behavior.hh (get<T>): Move method impls to... * ntg/real/behavior2.hh: ...this new file. * ntg/makefile.src: Update. * ntg/real/optraits_builtin_int.hh: Include new file. * ntg/real/builtin_float.hh: Likewise.

19 years, 5 months

proto-1.0 250: Fix PBM (binary) image reading

by Roland Levillain

Rappels : 1. les mauvaises initialisations sont une plaie du C/C++, il faut y faire attention ; 2. il existe des tests dans Olena, c'est bien de les lancer de temps en temps pour voir si on casse pas trop de choses en avançant ! ChangeLog | 29 +++++++++++++++++++++++++++++ oln/core/abstract/grid.hh | 2 ++ oln/core/abstract/image.hh | 4 +++- oln/core/gen/internal/value_box.hh | 32 ++++++++++++++++++++++++++++++-- oln/funobj/invert.hh | 2 ++ oln/io/gz_stream.hh | 6 ++++++ oln/io/pnm_bin.hh | 26 ++++++++++---------------- oln/io/pnm_header.hh | 3 +++ oln/io/pnm_real.hh | 3 ++- oln/io/pnm_vect.hh | 2 ++ oln/level/invert.hh | 1 + tests/io/tests/2d | 2 ++ 12 files changed, 92 insertions(+), 20 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Fix PBM (binary) image reading. * oln/core/abstract/grid.hh (oln_grd_type_of_): New macro. * oln/io/pnm_bin (read_bin<oln::grid2d>::size_type) (read_bin<oln::grid2d>::point_type) (write_bin<oln::grid2d>::size_type) (write_bin<oln::grid2d>::point_type): Define these typedefs using oln_grd_type_of_. (read_bin<oln::grid2d>::read_bin): Initialize v to 0. (write_bin<oln::grid2d>::write_bin): Initialize offset and v. Fix io/2d test. * oln/io/pnm_header.hh (iostream, string): Include these files. * oln/io/pnm_bin.hh, oln/io/pnm_real.hh, oln/io/pnm_vect.hh (oln/core/2d/point2d.hh, oln/core/2d/size2d.hh): Likewise. * oln/funobj/invert.hh (oln/core/gen/internal/value_box.hh): Likewise. * oln/core/abstract/image.hh: Add forward declaration of oln::value_box. * oln/core/gen/internal/value_box.hh (oln/overloaded_cmp_op_operand): New helper. (oln_decl_comp_binop_vb_whatever): Use it. * oln/io/gz_stream.hh: Add forward declarations to please G++ 4.0. * tests/io/tests/2d (oln/core/2d/image2d.hh): Include this file. Index: olena/tests/io/tests/2d --- olena/tests/io/tests/2d (révision 248) +++ olena/tests/io/tests/2d (copie de travail) @@ -29,6 +29,8 @@ #include "loadsave.hh" +#include <oln/core/2d/image2d.hh> + bool check(void) { Index: olena/oln/funobj/invert.hh --- olena/oln/funobj/invert.hh (révision 248) +++ olena/oln/funobj/invert.hh (copie de travail) @@ -32,6 +32,8 @@ # include <ntg/all.hh> +# include <oln/core/gen/internal/value_box.hh> + namespace oln { namespace funobj { Index: olena/oln/core/abstract/image.hh --- olena/oln/core/abstract/image.hh (révision 248) +++ olena/oln/core/abstract/image.hh (copie de travail) @@ -30,7 +30,6 @@ # include <oln/core/typedefs.hh> - # define oln_type_of_(ImageType, Alias) \ mlc_type_of_(oln, oln::category::image, ImageType, Alias) @@ -42,6 +41,9 @@ namespace oln { + // fwd decl + template <typename I> + class value_box; // fwd decls namespace abstract Index: olena/oln/core/abstract/grid.hh --- olena/oln/core/abstract/grid.hh (révision 248) +++ olena/oln/core/abstract/grid.hh (copie de travail) @@ -35,6 +35,8 @@ # define oln_grd_type_of(GridType, Alias) \ mlc_type_of(oln, oln::category::grid, GridType, Alias) +# define oln_grd_type_of_(GridType, Alias) \ +mlc_type_of_(oln, oln::category::grid, GridType, Alias) namespace oln { Index: olena/oln/core/gen/internal/value_box.hh --- olena/oln/core/gen/internal/value_box.hh (révision 248) +++ olena/oln/core/gen/internal/value_box.hh (copie de travail) @@ -350,6 +350,33 @@ | Comparison operators. | `-----------------------*/ +// Helper used in the resolution of right operand of a comparison +// operator having a value_box as left operand. +// FIXME: To be replaced by the oln::utils::overload mechanism. +namespace oln +{ + + template <typename T> + struct overloaded_cmp_op_operand + { + static T value(const T& t) + { + return t; + } + }; + + template <typename I> + struct overloaded_cmp_op_operand<oln::value_box > + { + static typename oln::value_box::value_type + value(const oln::value_box& vb) + { + return vb.value(); + } + }; + +} // end of namespace oln + // oln::value_box and whatever. # define oln_decl_comp_binop_vb_whatever(OpSymbol) \ template <typename I, typename V> \ @@ -357,7 +384,8 @@ operator OpSymbol (const oln::value_box& lhs, \ const V& rhs) \ { \ - return lhs.value() OpSymbol rhs; \ + return \ + lhs.value() OpSymbol oln::overloaded_cmp_op_operand<V>::value(rhs); \ } // ntg::value<V> and oln::value_box. @@ -400,7 +428,7 @@ // Helper used in the resolution of right operand of an arithmetical // operator having a value_box as left operand. -// FIXME: To be replaced by the upcoming oln::utils::overload mechanism. +// FIXME: To be replaced by the oln::utils::overload mechanism. namespace oln { Index: olena/oln/io/pnm_bin.hh --- olena/oln/io/pnm_bin.hh (révision 248) +++ olena/oln/io/pnm_bin.hh (copie de travail) @@ -33,7 +33,8 @@ # include <oln/canvas/io.hh> # include <oln/io/pnm_header.hh> # include <oln/core/2d/grid2d.hh> - +# include <oln/core/2d/point2d.hh> +# include <oln/core/2d/size2d.hh> namespace oln { @@ -53,13 +54,8 @@ struct read_bin<oln::grid2d> : public canvas::read_from_file<bool, grid2d, read_bin<grid2d> > { - - // FIXME: these macros should work -// typedef oln_grd_type_of(grid2d, size) size_type; -// typedef oln_grd_type_of(grid2d, point) point_type; - - typedef size2d size_type; - typedef point2d point_type; + typedef oln_grd_type_of_(grid2d, size) size_type; + typedef oln_grd_type_of_(grid2d, point) point_type; unsigned impl_npoints() { @@ -109,6 +105,7 @@ read_bin(std::istream& istr, const header& hdr) : istr(istr), hdr(hdr), + v(0), offset(-1) { p.col() = 0; @@ -130,12 +127,8 @@ struct write_bin<oln::grid2d> : public canvas::write_to_file<bool, grid2d, write_bin<grid2d> > { - // FIXME: these macros should work -// typedef oln_grd_type_of(grid2d, size) size_type; -// typedef oln_grd_type_of(grid2d, point) point_type; - - typedef size2d size_type; - typedef point2d point_type; + typedef oln_grd_type_of_(grid2d, size) size_type; + typedef oln_grd_type_of_(grid2d, point) point_type; void set_size(const size_type& size) { @@ -189,11 +182,12 @@ } write_bin(std::ostream& ostr) : - ostr(ostr) + ostr(ostr), + offset(7), + v(0) { p.col() = 0; p.row() = 0; - offset = 7; } std::ostream& ostr; Index: olena/oln/io/pnm_header.hh --- olena/oln/io/pnm_header.hh (révision 248) +++ olena/oln/io/pnm_header.hh (copie de travail) @@ -28,6 +28,9 @@ #ifndef OLN_IO_PNM_HEADER_HH # define OLN_IO_PNM_HEADER_HH +# include <iostream> +# include <string> + namespace oln { Index: olena/oln/io/gz_stream.hh --- olena/oln/io/gz_stream.hh (révision 248) +++ olena/oln/io/gz_stream.hh (copie de travail) @@ -297,6 +297,12 @@ }; + // Forward declarations. + class zifstream; + class zofstream; + zofstream& setcompressionlevel(zofstream&, int); + zofstream& setcompressionstrategy(zofstream&, int); + ///Define an interface for compressed file stream manipulation. class zfilestream_common : virtual public std::ios { Index: olena/oln/io/pnm_vect.hh --- olena/oln/io/pnm_vect.hh (révision 248) +++ olena/oln/io/pnm_vect.hh (copie de travail) @@ -33,6 +33,8 @@ # include <oln/canvas/io.hh> # include <oln/io/pnm_header.hh> # include <oln/core/2d/grid2d.hh> +# include <oln/core/2d/point2d.hh> +# include <oln/core/2d/size2d.hh> Index: olena/oln/io/pnm_real.hh --- olena/oln/io/pnm_real.hh (révision 248) +++ olena/oln/io/pnm_real.hh (copie de travail) @@ -33,7 +33,8 @@ # include <oln/canvas/io.hh> # include <oln/io/pnm_header.hh> # include <oln/core/2d/grid2d.hh> - +# include <oln/core/2d/point2d.hh> +# include <oln/core/2d/size2d.hh> namespace oln { Index: olena/oln/level/invert.hh --- olena/oln/level/invert.hh (révision 248) +++ olena/oln/level/invert.hh (copie de travail) @@ -28,6 +28,7 @@ #ifndef OLENA_LEVEL_INVERT_HH # define OLENA_LEVEL_INVERT_HH +# include <oln/utils/record.hh> # include <oln/funobj/invert.hh> namespace oln

19 years, 5 months

proto-1.0 249: Add (some) missing traits in color

by Roland Levillain

ChangeLog | 15 +++++++++++++++ ntg/color/color.hh | 36 ++++++++++++++++++++++++++++++++++++ ntg/vect/cplx.hh | 15 +++++++++++---- 3 files changed, 62 insertions(+), 4 deletions(-) Index: integre/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add (some) missing traits in color. * ntg/color/color.hh (optraits<color<ncomps, qbits, color_system> >::cmp_eq): New. (operator_traits<operator_cmp, color<ncomps1, qbits1, color_system1>, color<ncomps2, qbits2, color_system2> >): New traits. * ntg/vect/cplx.hh (cplx<rect, T>::to_polar): Move definition of this method outside the class, after the definition of cplx<polar, T>, in order to pacify G++ 4.0 (which requires the complete definition of cplx<polar, T> to instantiate cplx<rect, T>::to_polar. Index: integre/ntg/core/internal/global_ops_defs.hh Index: integre/ntg/vect/cplx.hh --- integre/ntg/vect/cplx.hh (révision 248) +++ integre/ntg/vect/cplx.hh (copie de travail) @@ -323,11 +323,10 @@ return cplx<rect, T>(-this->val_[0], -this->val_[1]); } + // Declaration of to_polar (definition is given after + // cplx<polar, T> definition. const cplx<polar, float_d> - to_polar() const - { - return cplx<polar, float_d>(magn(), angle()); - } + to_polar() const; }; @@ -422,6 +421,14 @@ }; + /// Definition of cplx<rect, T>::to_polar. + template <class T> + const cplx<polar, float_d> + cplx<rect, T>::to_polar() const + { + return cplx<polar, float_d>(magn(), angle()); + } + template<class T> inline std::ostream& operator<<(std::ostream& ostr, const cplx<rect, T>& rhs) Index: integre/ntg/color/color.hh --- integre/ntg/color/color.hh (révision 248) +++ integre/ntg/color/color.hh (copie de travail) @@ -267,6 +267,27 @@ typedef color<ncomps, qbits, color_system> self; typedef typename typetraits<self>::storage_type storage_type; + /* FIXME: Copied and pasted from optraits<vec>. There are + obvious lacks in these traits; Maybe we could inherit from + optraits<vect_value> or something like that? */ + public: + template <class T1, class T2> + inline static bool + cmp_eq (const T1& lhs, const T2& rhs) + { + ntg_is_a(T1, ntg::vectorial)::ensure(); + ntg_is_a(T2, ntg::vectorial)::ensure(); + ntg_assert(lhs.size() == rhs.size()); + + typedef ntg_return_type(cmp, T1, T2) tmp_type; + + unsigned s = lhs.size(); + for (unsigned i = 0; i < s; ++i) + if (lhs[i] != rhs[i]) + return false; + return true; + } + public: static unsigned max_print_width () { @@ -283,6 +304,21 @@ } }; + template<unsigned ncomps1, unsigned qbits1, + template <unsigned> class color_system1, + unsigned ncomps2, unsigned qbits2, + template <unsigned> class color_system2> + struct operator_traits<operator_cmp, + color<ncomps1, qbits1, color_system1>, + color<ncomps2, qbits2, color_system2> > + { + enum { commutative = true }; + typedef color<ncomps1, qbits1, color_system1> ret; + typedef color<ncomps1, qbits1, color_system1> impl; + }; + + // FIXME: Add missing operator_traits for color. + template <typename T> struct default_less;

19 years, 5 months

proto-1.0 248: Strengthen ntg deduced ops.

by Thierry GERAUD

2005-07-18 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr> The main changes are the removals of deduced operators the arguments of which were not strongly typed. * ntg/real/range.hh (operator T): New. * ntg/core/internal/global_ops.hh (operator!=, operator>=, operator>, operator<=): Strengthen signatures. (GLOBAL_DEDUCED_CMP_OPS): Call value-builtin versions of above operators. (operator+, operator++, operator-, operator--): Strengthen signatures. (min, max): Likewise. * ntg/core/internal/global_ops_defs.hh (GLOBAL_DEDUCED_CMP_OPS_BUILTIN): New macro. (GLOBAL_DEDUCED_CMP_OPS): New macro. * ntg/vect/vect_value.hh (nb_comp): Turn to an int. * ntg/vect/vec.hh (nb_comp): Likewise. * ntg/color/color.hh (nb_comp): Likewise.

19 years, 5 months

proto-1.0 247: Remove files that were previously deleted

by Christophe Berger

Index: ChangeLog from Christophe Berger <christophe(a)lrde.epita.fr> * olena/oln/makefile.src: Remove deleted files. makefile.src | 6 ------ 1 files changed, 6 deletions(-) Index: olena/oln/makefile.src --- olena/oln/makefile.src (revision 246) +++ olena/oln/makefile.src (working copy) @@ -154,14 +154,8 @@ funobj/logic.hh \ \ io/gz_stream.hh \ - io/read_image_pnm_2d.hh \ - io/read_image_pnm_decl.hh \ - io/read_image_pnm.hh \ io/read_image.hh \ io/utils.hh \ - io/write_image_pnm_2d.hh \ - io/write_image_pnm_decl.hh \ - io/write_image_pnm.hh \ io/write_image.hh \ \ level/arith.hh \

19 years, 5 months

proto-1.0 246: Add new I/O implementations and facades

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/io/pnm_bin.hh: New. I/O functions for writing and reading a binary PNM file. * oln/io/pnm_read.hh: New. Facade to PNM input methods. * oln/io/read_image_pnm.hh: Remove. * oln/io/vectorial.hh: New. Read to and write from vectorial images. * oln/io/write_image_pnm_2d.hh: Remove. * oln/io/write_image.hh: Adapt to the new I/O modeling. * oln/io/write_image_pnm_decl.hh: Remove. * oln/io/pnm_real.hh: New. I/O functions for writing and reading a grey scale PNM file. * oln/io/utils.hh: Move pnm functions and structures to pnm_header.hh. * oln/io/pnm_header.hh: New. Contain functions and structures to read and write a PNM header. * oln/io/pnm_write.hh: New. Facade to PNM output methods. * oln/io/scalar.hh: New. Read to and write from scalar images. * oln/io/write_image_pnm.hh: Remove. * oln/io/pnm_vect.hh: New. I/O functions for writing and reading a rgb PNM file. * oln/io/read_image_pnm_2d.hh: Remove. * oln/io/read_image.hh: Adapt to the new I/O modeling. * oln/io/read_image_pnm_decl.hh: Remove. pnm_bin.hh | 215 ++++++++++++++++++++++++++++++++++++++++++++++++ pnm_header.hh | 129 ++++++++++++++++++++++++++++ pnm_read.hh | 198 ++++++++++++++++++++++++++++++++++++++++++++ pnm_real.hh | 169 +++++++++++++++++++++++++++++++++++++ pnm_vect.hh | 169 +++++++++++++++++++++++++++++++++++++ pnm_write.hh | 165 ++++++++++++++++++++++++++++++++++++ read_image.hh | 6 - read_image_pnm.hh | 157 ----------------------------------- read_image_pnm_2d.hh | 166 ------------------------------------- read_image_pnm_decl.hh | 57 ------------ scalar.hh | 78 +++++++++++++++++ utils.hh | 98 --------------------- vectorial.hh | 88 +++++++++++++++++++ write_image.hh | 5 - write_image_pnm.hh | 173 -------------------------------------- write_image_pnm_2d.hh | 153 ---------------------------------- write_image_pnm_decl.hh | 57 ------------ 17 files changed, 1217 insertions(+), 866 deletions(-) Index: oln/io/pnm_write.hh --- oln/io/pnm_write.hh (revision 0) +++ oln/io/pnm_write.hh (revision 0) @@ -0,0 +1,165 @@ +// 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_PNM_WRITE_HH +# define OLN_IO_PNM_WRITE_HH + +# include <iostream> + +# include <ntg/core/macros.hh> + +# include <oln/core/abstract/image.hh> + +# include <oln/io/scalar.hh> +# include <oln/io/vectorial.hh> + +# include <oln/io/pnm_real.hh> +# include <oln/io/pnm_bin.hh> +# include <oln/io/pnm_vect.hh> + +namespace oln { + + + namespace io { + + + namespace pnm { + + + namespace impl { + + template <typename V, typename I> + void write(const ntg::real_value<V>&, + const abstract::image& ima, + std::ostream& ostr, + const std::string& ext) + { + typedef oln_type_of(I, grid) grid_type; + + if (ext == "pgm") + { + if (ntg_max_val(V) - ntg_min_val(V) < 256) + { + typedef write_real<char, grid_type> writer_type; + writer_type pnm_writer(ostr); + write_scalar<I, writer_type> writer(ima, pnm_writer); + + writer.run(); + } + else + { + typedef write_real<short, grid_type> writer_type; + writer_type pnm_writer(ostr); + write_scalar<I, writer_type> writer(ima, pnm_writer); + + writer.run(); + } + } + else + std::cerr << "io error: extension mismatch data type" << std::endl; + } + + template <typename V, typename I> + void write(const ntg::enum_value<V>&, + const abstract::image& ima, + std::ostream& ostr, + const std::string& ext) + { + typedef oln_type_of(I, grid) grid_type; + + if (ext == "pbm") + { + assert(ntg_max_val(V) == 1 && ntg_min_val(V) == 0); + + typedef write_bin<grid_type> writer_type; + writer_type pnm_writer(ostr); + write_scalar<I, writer_type> writer(ima, pnm_writer); + + writer.run(); + } + else + std::cerr << "io error: extension mismatch data type" << std::endl; + } + + template <typename V, typename I> + void write(const ntg::vect_value<V>&, + const abstract::image& ima, + std::ostream& ostr, + const std::string& ext) + { + typedef oln_type_of(I, grid) grid_type; + + if (ext == "ppm") + { + assert(ntg_nb_comp(V) == 3); + + if (ntg_max_val(ntg_comp_type(V)) - + ntg_min_val(ntg_comp_type(V)) < 256) + { + typedef write_vect<char, grid_type> writer_type; + writer_type pnm_writer(ostr); + write_vectorial<I, writer_type> writer(ima, pnm_writer); + + writer.run(); + } + else + { + typedef write_vect<short, grid_type> writer_type; + writer_type pnm_writer(ostr); + write_vectorial<I, writer_type> writer(ima, pnm_writer); + + writer.run(); + } + } + else + std::cerr << "io error: extension mismatch data type" << std::endl; + } + + + } + + template <typename I> + void write(const abstract::image& ima, + std::ostream& ostr, + const std::string& ext) + { + typedef oln_type_of(I, value) value_type; + typedef ntg_type(value_type) ntg_value_type; + + impl::write(ntg_value_type(), ima.exact(), ostr, ext); + } + + + } + + + } + + +} + +# endif // ! OLN_IO_PNM_WRITE_HH Index: oln/io/vectorial.hh --- oln/io/vectorial.hh (revision 0) +++ oln/io/vectorial.hh (revision 0) @@ -0,0 +1,88 @@ +// 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 filek 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_VECTORIAL_HH +# define OLENA_IO_VECTORIAL_HH + +# include <oln/core/abstract/image.hh> +# include <oln/canvas/io.hh> + +namespace oln { + + + namespace io { + + + template <typename I, typename F> + struct read_vectorial + : public canvas::read_to_oln<I, F, read_vectorial<I, F> > + { + typedef oln_type_of(I, value) value_type; + typedef ntg_comp_type(value_type) comp_type; + typedef canvas::read_to_oln<I, F, read_vectorial<I, F> > super_type; + + void impl_read_point() + { + value_type tmp; + + for (unsigned i = 0; i < ntg_nb_comp(value_type); ++i) + tmp[i] = (ntg_storage_type(comp_type))this->reader.read_value(); + + this->output[this->reader.point()] = tmp; + } + + read_vectorial(F& reader) : + super_type(reader) {} + + }; + + template <typename I, typename F> + struct write_vectorial : + public canvas::write_from_oln<I, F, write_vectorial<I, F> > + { + typedef oln_type_of(I, value) value_type; + typedef canvas::write_from_oln<I, F, write_vectorial<I, F> > super_type; + + void impl_write_point() + { + value_type tmp = this->input[this->writer.point()]; + + for (unsigned i = 0; i < ntg_nb_comp(value_type); ++i) + this->writer.write_value(tmp[i]); + } + + write_vectorial(const abstract::image& input, F& writer) : + super_type(input, writer) {} + + }; + + } + + +} + +#endif // ! OLENA_IO_VECTORIAL_HH Index: oln/io/scalar.hh --- oln/io/scalar.hh (revision 0) +++ oln/io/scalar.hh (revision 0) @@ -0,0 +1,78 @@ +// 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 filek 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_SCALAR_HH +# define OLENA_IO_SCALAR_HH + +# include <oln/core/abstract/image.hh> +# include <oln/canvas/io.hh> + +namespace oln { + + + namespace io { + + + template <typename I, typename F> + struct read_scalar : public canvas::read_to_oln<I, F, read_scalar<I, F> > + { + typedef oln_type_of(I, value) value_type; + typedef canvas::read_to_oln<I, F, read_scalar<I, F> > super_type; + + void impl_read_point() + { + this->output[this->reader.point()] = + (ntg_storage_type(value_type))this->reader.read_value(); + } + + read_scalar(F& reader) : + super_type(reader) {} + + }; + + template <typename I, typename F> + struct write_scalar : + public canvas::write_from_oln<I, F, write_scalar<I, F> > + { + typedef canvas::write_from_oln<I, F, write_scalar<I, F> > super_type; + + void impl_write_point() + { + this->writer.write_value(this->input[this->writer.point()]); + } + + write_scalar(const abstract::image& input, F& writer) : + super_type(input, writer) {} + + }; + + } + + +} + +#endif // ! OLENA_IO_SCALAR_HH Index: oln/io/pnm_real.hh --- oln/io/pnm_real.hh (revision 0) +++ oln/io/pnm_real.hh (revision 0) @@ -0,0 +1,169 @@ +// 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_PNM_REAL_HH +# define OLN_IO_PNM_REAL_HH + +# include <iostream> + +# include <oln/canvas/io.hh> +# include <oln/io/pnm_header.hh> +# include <oln/core/2d/grid2d.hh> + + + +namespace oln { + + namespace io { + + namespace pnm { + + + template <typename T, typename G> + struct read_real {}; + + template <typename T, typename G> + struct write_real {}; + + template <typename T> + struct read_real<T, oln::grid2d> + : public canvas::read_from_file<T, grid2d, read_real<T, grid2d> > + { + typedef oln_grd_type_of(grid2d, size) size_type; + typedef oln_grd_type_of(grid2d, point) point_type; + + unsigned impl_npoints() + { + return hdr.cols * hdr.rows; + } + + size_type impl_size() + { + return size_type(hdr.rows, hdr.cols); + } + + T impl_read_value() + { + T v; + + istr.read((char*)&v, sizeof (T)); + return v; + } + + void impl_next_point() + { + precondition(p.row() < hdr.rows && p.col() < hdr.cols); + ++p.col(); + if (p.col() >= hdr.cols) + { + p.col() = 0; + ++p.row(); + } + } + + const point_type& impl_point() + { + return p; + } + + read_real(std::istream& istr, const header& hdr) : + istr(istr), + hdr(hdr) + { + p.col() = 0; + p.row() = 0; + } + + std::istream& istr; + const header& hdr; + point_type p; + + }; + + + template <typename T> + struct write_real<T, oln::grid2d> + : public canvas::write_to_file<T, grid2d, write_real<T, grid2d> > + { + typedef oln_grd_type_of(grid2d, size) size_type; + typedef oln_grd_type_of(grid2d, point) point_type; + + void set_size(const size_type& size) + { + nrows = size.nrows(); + ncols = size.ncols(); + } + + void impl_write_value(T& v) + { + ostr.write((char*)&v, sizeof (T)); + } + + void impl_next_point() + { + precondition(p.row() < nrows && p.col() < ncols); + ++p.col(); + if (p.col() >= ncols) + { + p.col() = 0; + ++p.row(); + } + } + + bool impl_write_header() + { + return pnm::write_header(ostr, "P5", ncols, nrows, + ntg_max_val(ntg_type(T)) - + ntg_min_val(ntg_type(T))); + } + + const point_type& impl_point() + { + return p; + } + + write_real(std::ostream& ostr) : + ostr(ostr) + { + p.col() = 0; + p.row() = 0; + } + + std::ostream& ostr; + point_type p; + int nrows, ncols; + + }; + + + } + + } + +} + +#endif // ! OLN_IO_PNM_REAL_HH Index: oln/io/write_image_pnm_decl.hh --- oln/io/write_image_pnm_decl.hh (revision 245) +++ oln/io/write_image_pnm_decl.hh (working copy) @@ -1,57 +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 OLN_IO_WRITE_IMAGE_PNM_DECL_HH -# define OLN_IO_WRITE_IMAGE_PNM_DECL_HH - -namespace oln { - - - namespace io { - - - namespace impl { - - template <typename I, typename S> - struct write_pnm_vect {}; - - template <typename I, typename S> - struct write_pnm_real {}; - - template <typename I, typename S> - struct write_pnm_bin {}; - - - } - - - } - - -} - -#endif // ! OLN_IO_WRITE_IMAGE_PNM_DECL_HH Index: oln/io/read_image_pnm.hh --- oln/io/read_image_pnm.hh (revision 245) +++ oln/io/read_image_pnm.hh (working copy) @@ -1,157 +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 OLN_IO_READ_IMAGE_PNM_HH -# define OLN_IO_READ_IMAGE_PNM_HH - -# include <iostream> -# include <string> - -# include <oln/io/read_image_pnm_decl.hh> -# include <oln/io/read_image_pnm_2d.hh> -# include <oln/core/abstract/image.hh> -# include <oln/io/utils.hh> - -namespace oln { - - - namespace io { - - - namespace impl { - - template <typename V, typename I> - void read_pnm_(const ntg::real_value<V>&, - abstract::image& ima, - std::istream& istr, - const internal::pnm_header &hdr) - { - typedef oln_type_of(I, size) size_type; - - if (hdr.type == "P5") - { - read_pnm_real<I, size_type> tmp(istr, hdr); - - tmp.run(); - tmp.get_output(ima.exact()); - } - else - std::cerr << "io error: pnm type mismatch data type" << std::endl; - } - - template <typename V, typename I> - void read_pnm_(const ntg::enum_value<V>&, - abstract::image& ima, - std::istream& istr, - const internal::pnm_header &hdr) - { - typedef oln_type_of(I, size) size_type; - - if (hdr.type == "P4") - { - read_pnm_bin<I, size_type> tmp(istr, hdr); - - tmp.run(); - tmp.get_output(ima.exact()); - } - else - std::cerr << "io error: pnm type mismatch data type" << std::endl; - } - - template <typename V, typename I> - void read_pnm_(const ntg::vect_value<V>&, - abstract::image& ima, - std::istream& istr, - const internal::pnm_header &hdr) - { - typedef oln_type_of(I, size) size_type; - - if (hdr.type == "P6") - { - read_pnm_vect<I, size_type> tmp(istr, hdr); - - tmp.run(); - tmp.get_output(ima.exact()); - } - else - std::cerr << "io error: pnm type mismatch data type" << std::endl; - } - - template <typename V, typename I> - void read_pnm(const ntg::value<V>& v, - abstract::image& ima, - std::istream& istr, - const internal::pnm_header &hdr) - { - read_pnm_(v.exact(), ima.exact(), istr, hdr); - } - - } - - - void check_hdr_ext(const internal::pnm_header& hdr, - const std::string& ext) - { - if ((ext == "pbm" && hdr.type != "P4") || - (ext == "pgm" && hdr.type != "P5") || - (ext == "ppm" && hdr.type != "P6")) - std::cerr << "io warning: extension mismatch pnm type." << std::cerr; - } - - - - template <typename I> - void read_pnm(abstract::image& ima, - std::istream& istr, - const std::string& ext) - { - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - internal::pnm_header hdr; - - if (!internal::read_pnm_header(istr, hdr)) - { - std::cerr << "io error: invalid pnm header." << std::cerr; - return; - } - - if (hdr.type == "P1" || hdr.type == "P2" || hdr.type == "P3") - std::cerr << "io error: ascii pnm format not supported." << std::endl; - - check_hdr_ext(hdr, ext); - - impl::read_pnm(ntg_value_type(), ima, istr, hdr); - - } - - - } - - -} - -#endif // ! OLN_IO_READ_IMAGE_PNM_HH Index: oln/io/write_image_pnm.hh --- oln/io/write_image_pnm.hh (revision 245) +++ oln/io/write_image_pnm.hh (working copy) @@ -1,173 +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 OLN_IO_WRITE_IMAGE_PNM_HH -# define OLN_IO_WRITE_IMAGE_PNM_HH - -# include <oln/io/write_image_pnm_decl.hh> -# include <oln/io/write_image_pnm_2d.hh> - -namespace oln { - - - namespace io { - - - namespace impl { - - - template <typename V, typename I> - void write_pnm_(const ntg::real_value<V>&, - const abstract::image& ima, - std::ostream& istr, - const std::string& ext) - { - typedef oln_type_of(I, size) size_type; - - if (ext == "pgm") - { - write_pnm_real<I, size_type> tmp(ima, istr); - - tmp.run(); - } - else - std::cerr << "io error: extension mismatch data type" << std::endl; - } - - template <typename V, typename I> - void write_pnm_(const ntg::enum_value<V>&, - const abstract::image& ima, - std::ostream& ostr, - const std::string& ext) - { - typedef oln_type_of(I, size) size_type; - - if (ext == "pbm") - { - write_pnm_bin<I, size_type> tmp(ima, ostr); - - tmp.run(); - } - else - std::cerr << "io error: extension mismatch data type" << std::endl; - } - - template <typename V, typename I> - void write_pnm_(const ntg::vect_value<V>&, - const abstract::image& ima, - std::ostream& ostr, - const std::string& ext) - { - typedef oln_type_of(I, size) size_type; - precondition(ntg_nb_comp(V) == 3); - - if (ext == "ppm") - { - write_pnm_vect<I, size_type> tmp(ima, ostr); - - tmp.run(); - } - else - std::cerr << "io error: extension mismatch data type" << std::endl; - } - - template <typename V, typename I> - void write_pnm(const ntg::value<V>& v, - const abstract::image& ima, - std::ostream& ostr, - const std::string& ext) - { - write_pnm_(v.exact(), ima.exact(), ostr, ext); - } - - } - - - template <typename V> - std::string get_pnm_type(const ntg::enum_value<V>&) - { - return "P4"; - } - - template <typename V> - std::string get_pnm_type(const ntg::real_value<V>&) - { - return "P5"; - } - - template <typename V> - std::string get_pnm_type(const ntg::vect_value<V>&) - { - return "P6"; - } - - template <typename V> - int get_max_val(const ntg::value<V>&) - { - return ntg_max_val(V) - ntg_min_val(V); - } - - template <typename V> - int get_max_val(const ntg::vect_value<V>&) - { - return ntg_max_val(ntg_comp_type(V)) - ntg_min_val(ntg_comp_type(V)); - } - - - template <typename I> - void write_pnm(const abstract::image& ima, - std::ostream& ostr, - const std::string& ext) - { - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - int max_val = get_max_val(ntg_value_type()); - - if (max_val <= 65535) - { - internal::write_pnm_header(ostr, get_pnm_type(ntg_value_type()), - ima.exact().size().ncols(), - ima.exact().size().nrows(), - max_val); - - impl::write_pnm(ntg_value_type(), ima.exact(), ostr, ext); - } - else - std::cerr << "io error: data type too large" << std::endl; - - - } - - - } - - -} - - - -# endif // ! OLN_IO_WRITE_IMAGE_PNM_HH Index: oln/io/pnm_bin.hh --- oln/io/pnm_bin.hh (revision 0) +++ oln/io/pnm_bin.hh (revision 0) @@ -0,0 +1,215 @@ +// 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_PNM_BIN_HH +# define OLN_IO_PNM_BIN_HH + +# include <iostream> + +# include <oln/canvas/io.hh> +# include <oln/io/pnm_header.hh> +# include <oln/core/2d/grid2d.hh> + + + +namespace oln { + + namespace io { + + namespace pnm { + + + template <typename G> + struct read_bin {}; + + template <typename G> + struct write_bin {}; + + template <> + struct read_bin<oln::grid2d> + : public canvas::read_from_file<bool, grid2d, read_bin<grid2d> > + { + + // FIXME: these macros should work +// typedef oln_grd_type_of(grid2d, size) size_type; +// typedef oln_grd_type_of(grid2d, point) point_type; + + typedef size2d size_type; + typedef point2d point_type; + + unsigned impl_npoints() + { + return hdr.cols * hdr.rows; + } + + size_type impl_size() + { + return size_type(hdr.rows, hdr.cols); + } + + void extra_work() + { + offset = -1; + } + + bool impl_read_value() + { + if (offset == -1) + { + this->istr.read(&v, 1); + offset = 7; + } + if ((int)(v & (1<<offset--)) == 0) + return false; + else + return true; + } + + void impl_next_point() + { + precondition(p.row() < hdr.rows && p.col() < hdr.cols); + ++p.col(); + if (p.col() >= hdr.cols) + { + p.col() = 0; + ++p.row(); + extra_work(); + } + } + + const point_type& impl_point() + { + return p; + } + + read_bin(std::istream& istr, const header& hdr) : + istr(istr), + hdr(hdr), + offset(-1) + { + p.col() = 0; + p.row() = 0; + + } + + std::istream& istr; + const header& hdr; + point_type p; + + char v; + int offset; + + }; + + + template <> + struct write_bin<oln::grid2d> + : public canvas::write_to_file<bool, grid2d, write_bin<grid2d> > + { + // FIXME: these macros should work +// typedef oln_grd_type_of(grid2d, size) size_type; +// typedef oln_grd_type_of(grid2d, point) point_type; + + typedef size2d size_type; + typedef point2d point_type; + + void set_size(const size_type& size) + { + nrows = size.nrows(); + ncols = size.ncols(); + } + + void extra_work() + { + if (offset != 7) + { + this->ostr.write(&v, 1); + offset = 7; + v = 0; + } + } + + void impl_write_value(bool& b) + { + if (offset == -1) + { + this->ostr.write(&v, 1); + offset = 7; + v = 0; + } + if (b == true) + v |= 1 << offset; + offset--; + } + + void impl_next_point() + { + precondition(p.row() < nrows && p.col() < ncols); + ++p.col(); + if (p.col() >= ncols) + { + p.col() = 0; + ++p.row(); + extra_work(); + } + } + + bool impl_write_header() + { + return pnm::write_header(ostr, "P4", ncols, nrows, 0); + } + + const point_type& impl_point() + { + return p; + } + + write_bin(std::ostream& ostr) : + ostr(ostr) + { + p.col() = 0; + p.row() = 0; + offset = 7; + } + + std::ostream& ostr; + point_type p; + int nrows, ncols; + + int offset; + char v; + + }; + + + } + + } + +} + +#endif // ! OLN_IO_PNM_BIN_HH Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 245) +++ oln/io/read_image.hh (working copy) @@ -34,11 +34,13 @@ # include <mlc/box.hh> # include <ntg/core/macros.hh> +# include <oln/core/abstract/image.hh> -# include <oln/io/read_image_pnm.hh> +# include <oln/io/pnm_read.hh> # include <oln/io/utils.hh> # include <oln/io/gz_stream.hh> + namespace oln { namespace io { @@ -71,7 +73,7 @@ { if (ext == "pgm" || ext == "pbm" || ext == "ppm" || ext == "pnm") - read_pnm(ima, istr, ext); + pnm::read(ima, istr, ext); else std::cout << "io error: format not supported." << std::endl; Index: oln/io/pnm_vect.hh --- oln/io/pnm_vect.hh (revision 0) +++ oln/io/pnm_vect.hh (revision 0) @@ -0,0 +1,169 @@ +// 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_PNM_VECT_HH +# define OLN_IO_PNM_VECT_HH + +# include <iostream> + +# include <oln/canvas/io.hh> +# include <oln/io/pnm_header.hh> +# include <oln/core/2d/grid2d.hh> + + + +namespace oln { + + namespace io { + + namespace pnm { + + + template <typename T, typename G> + struct read_vect {}; + + template <typename T, typename G> + struct write_vect {}; + + template <typename T> + struct read_vect<T, oln::grid2d> + : public canvas::read_from_file<T, grid2d, read_vect<T, grid2d> > + { + typedef oln_grd_type_of(grid2d, size) size_type; + typedef oln_grd_type_of(grid2d, point) point_type; + + unsigned impl_npoints() + { + return hdr.cols * hdr.rows; + } + + size_type impl_size() + { + return size_type(hdr.rows, hdr.cols); + } + + T impl_read_value() + { + T v; + + istr.read((char*)&v, sizeof (T)); + return v; + } + + void impl_next_point() + { + precondition(p.row() < hdr.rows && p.col() < hdr.cols); + ++p.col(); + if (p.col() >= hdr.cols) + { + p.col() = 0; + ++p.row(); + } + } + + const point_type& impl_point() + { + return p; + } + + read_vect(std::istream& istr, const header& hdr) : + istr(istr), + hdr(hdr) + { + p.col() = 0; + p.row() = 0; + } + + std::istream& istr; + const header& hdr; + point_type p; + + }; + + + template <typename T> + struct write_vect<T, oln::grid2d> + : public canvas::write_to_file<T, grid2d, write_vect<T, grid2d> > + { + typedef oln_grd_type_of(grid2d, size) size_type; + typedef oln_grd_type_of(grid2d, point) point_type; + + void set_size(const size_type& size) + { + nrows = size.nrows(); + ncols = size.ncols(); + } + + void impl_write_value(T& v) + { + ostr.write((char*)&v, sizeof (T)); + } + + void impl_next_point() + { + precondition(p.row() < nrows && p.col() < ncols); + ++p.col(); + if (p.col() >= ncols) + { + p.col() = 0; + ++p.row(); + } + } + + bool impl_write_header() + { + return pnm::write_header(ostr, "P6", ncols, nrows, + ntg_max_val(ntg_type(T)) - + ntg_min_val(ntg_type(T))); + } + + const point_type& impl_point() + { + return p; + } + + write_vect(std::ostream& ostr) : + ostr(ostr) + { + p.col() = 0; + p.row() = 0; + } + + std::ostream& ostr; + point_type p; + int nrows, ncols; + + }; + + + } + + } + +} + +#endif // ! OLN_IO_PNM_VECT_HH Index: oln/io/pnm_header.hh --- oln/io/pnm_header.hh (revision 0) +++ oln/io/pnm_header.hh (revision 0) @@ -0,0 +1,129 @@ +// 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_PNM_HEADER_HH +# define OLN_IO_PNM_HEADER_HH + +namespace oln { + + + namespace io { + + + namespace pnm { + + + struct header + { + int max_val; + int rows; + int cols; + std::string type; + }; + + bool read_header(std::istream& istr, + header& hdr) + { + std::getline(istr, hdr.type); + + hdr.max_val = 1; + + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + // read size + istr >> hdr.cols; + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + + istr >> hdr.rows; + // skip comments + while (istr.peek() == '#') + { + std::string line; + std::getline(istr, line); + } + + if (hdr.cols <= 0 || hdr.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'! + if (istr.get() != '\n') return false; + // extract or skip maxvalue + if (hdr.type != "P1" && hdr.type != "P4") + { + istr >> hdr.max_val; + if (hdr.max_val > 65535 || + istr.get() != '\n' || + hdr.max_val <= 0) + return false; + } + return true; + } + + bool write_header(std::ostream& ostr, + const std::string& type, + int ncols, + int nrows, + int max_val) + { + if (max_val > 65535) + return false; + + ostr << type << std::endl + << "# Olena 1.0" << std::endl + << ncols << " " << nrows << std::endl; + if (type != "P1" && type != "P4") + ostr << max_val << std::endl; + return true; + } + + + } + + + } + + +} + +#endif // ! OLN_IO_PNM_HEADER_HH Index: oln/io/write_image.hh --- oln/io/write_image.hh (revision 245) +++ oln/io/write_image.hh (working copy) @@ -31,8 +31,7 @@ # include <string> # include <oln/io/gz_stream.hh> -# include <oln/io/utils.hh> -# include <oln/io/write_image_pnm.hh> +# include <oln/io/pnm_write.hh> namespace oln { @@ -45,7 +44,7 @@ { if (ext == "pgm" || ext == "pbm" || ext == "ppm" || ext == "pnm") - write_pnm(ima, ostr, ext); + pnm::write(ima, ostr, ext); else std::cout << "io error: format not supported." << std::endl; Index: oln/io/read_image_pnm_decl.hh --- oln/io/read_image_pnm_decl.hh (revision 245) +++ oln/io/read_image_pnm_decl.hh (working copy) @@ -1,57 +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 OLN_IO_READ_IMAGE_PNM_DECL_HH -# define OLN_IO_READ_IMAGE_PNM_DECL_HH - -namespace oln { - - - namespace io { - - - namespace impl { - - - template <typename I, typename S> - struct read_pnm_vect {}; - - template <typename I, typename S> - struct read_pnm_real {}; - - template <typename I, typename S> - struct read_pnm_bin {}; - - } - - - } - - -} - -#endif // ! OLN_IO_READ_IMAGE_PNM_DECL_HH Index: oln/io/write_image_pnm_2d.hh --- oln/io/write_image_pnm_2d.hh (revision 245) +++ oln/io/write_image_pnm_2d.hh (working copy) @@ -1,153 +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 OLN_IO_WRITE_IMAGE_PNM_2D_HH -# define OLN_IO_WRITE_IMAGE_PNM_2D_HH - -# include <ntg/all.hh> - -# include <oln/canvas/io.hh> - -# include <oln/core/2d/image2d.hh> -# include <oln/io/write_image_pnm_decl.hh> - -namespace oln { - - - namespace io { - - - namespace impl { - - - template <typename I> - struct write_pnm_vect<I, oln::size2d> - : public canvas::write_2d<I, write_pnm_vect<I, oln::size2d> > - { - typedef canvas::write_2d<I, write_pnm_vect<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_comp_type(value_type) comp_type; - typedef oln_io_type(ntg_nbits(ntg_comp_type(value_type))) v_type; - - void impl_write_point() - { - value_type c = this->input[this->p]; - for (unsigned i = 0; i < ntg_nb_comp(value_type); ++i) - { - v_type v; - v = c[i]; - this->ostr.write((char*)&v, sizeof (v_type)); - } - } - - write_pnm_vect(const abstract::image& input, - std::ostream& ostr) : - super_type(input, ostr) - {} - - }; - - template <typename I> - struct write_pnm_real<I, oln::size2d> - : public canvas::write_2d<I, write_pnm_real<I, oln::size2d> > - { - typedef canvas::write_2d<I, write_pnm_real<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - typedef oln_io_type(ntg_nbits(ntg_value_type)) v_type; - - - void impl_write_point() - { - v_type v; - v = this->input[this->p]; - this->ostr.write((char*)&v, sizeof (v_type)); - } - - write_pnm_real(const abstract::image& input, - std::ostream& ostr) : - super_type(input, ostr) - {} - - }; - - template <typename I> - struct write_pnm_bin<I, oln::size2d> - : public canvas::write_2d<I, write_pnm_bin<I, oln::size2d> > - { - typedef canvas::write_2d<I, write_pnm_bin<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - typedef oln_io_type(ntg_nbits(ntg_value_type)) v_type; - - int offset; - char v; - - void impl_extra_work() - { - if (offset != 7) - { - this->ostr.write(&v, 1); - offset = 7; - v = 0; - } - } - - void impl_write_point() - { - if (offset == -1) - { - this->ostr.write(&v, 1); - offset = 7; - v = 0; - } - if (this->input[this->p] == value_type(0)) - v |= 1 << offset; - offset--; - } - - write_pnm_bin(const abstract::image& input, - std::ostream& ostr) : - super_type(input, ostr), - offset(7), - v(0) - { - } - - }; - - - - } - - - } - - -} - -#endif // ! OLN_IO_WRITE_IMAGE_PNM_2D_HH Index: oln/io/pnm_read.hh --- oln/io/pnm_read.hh (revision 0) +++ oln/io/pnm_read.hh (revision 0) @@ -0,0 +1,198 @@ +// 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_PNM_HH +# define OLN_IO_PNM_HH + +# include <iostream> +# include <string> + +# include <oln/core/abstract/image.hh> + +# include <oln/io/scalar.hh> +# include <oln/io/vectorial.hh> +# include <oln/io/pnm_header.hh> + +# include <oln/io/pnm_real.hh> +# include <oln/io/pnm_bin.hh> +# include <oln/io/pnm_vect.hh> + +namespace oln { + + + namespace io { + + + namespace pnm { + + + namespace impl { + + template <typename V, typename I> + void read(const ntg::real_value<V>&, + oln::abstract::image& ima, + std::istream& istr, + const header &hdr) + { + typedef oln_type_of(I, grid) grid_type; + + if (hdr.type == "P5") + { + assert(ntg_max_val(V) - ntg_min_val(V) <= hdr.max_val); + + if (hdr.max_val < 256) + { + typedef read_real<char, grid_type> reader_type; + reader_type pnm_reader(istr, hdr); + read_scalar<I, reader_type> reader(pnm_reader); + + reader.run(); + reader.assign(ima); + } + else + { + typedef read_real<short, grid_type> reader_type; + reader_type pnm_reader(istr, hdr); + read_scalar<I, reader_type> reader(pnm_reader); + + reader.run(); + reader.assign(ima); + } + } + else + std::cerr << "io error: pnm type mismatch data type" << std::endl; + } + + template <typename V, typename I> + void read(const ntg::enum_value<V>&, + abstract::image& ima, + std::istream& istr, + const header &hdr) + { + typedef oln_type_of(I, grid) grid_type; + + if (hdr.type == "P4") + { + assert(ntg_max_val(V) == 1 && ntg_min_val(V) == 0); + + typedef read_bin<grid_type> reader_type; + reader_type pnm_reader(istr, hdr); + read_scalar<I, reader_type> reader(pnm_reader); + + reader.run(); + reader.assign(ima); + } + else + std::cerr << "io error: pnm type mismatch data type" << std::endl; + } + + template <typename V, typename I> + void read(const ntg::vect_value<V>&, + abstract::image& ima, + std::istream& istr, + const header &hdr) + { + typedef oln_type_of(I, grid) grid_type; + + assert(ntg_nb_comp(V) == 3); + if (hdr.type == "P6") + { + assert(ntg_max_val(ntg_comp_type(V)) - + ntg_min_val(ntg_comp_type(V)) <= hdr.max_val); + + if (hdr.max_val < 256) + { + typedef read_vect<char, grid_type> reader_type; + reader_type pnm_reader(istr, hdr); + read_vectorial<I, reader_type> reader(pnm_reader); + + reader.run(); + reader.assign(ima); + } + else + { + typedef read_vect<short, grid_type> reader_type; + reader_type pnm_reader(istr, hdr); + read_vectorial<I, reader_type> reader(pnm_reader); + + reader.run(); + reader.assign(ima); + } + } + else + std::cerr << "io error: pnm type mismatch data type" << std::endl; + } + + + } + + + void check_hdr_ext(const header& hdr, + const std::string& ext) + { + if ((ext == "pbm" && hdr.type != "P4") || + (ext == "pgm" && hdr.type != "P5") || + (ext == "ppm" && hdr.type != "P6")) + std::cerr << "io warning: extension mismatch pnm type." << std::cerr; + } + + + + template <typename I> + void read(abstract::image& ima, + std::istream& istr, + const std::string& ext) + { + typedef oln_type_of(I, value) value_type; + typedef ntg_type(value_type) ntg_value_type; + header hdr; + + if (!read_header(istr, hdr)) + { + std::cerr << "io error: invalid pnm header." << std::cerr; + return; + } + + if (hdr.type == "P1" || hdr.type == "P2" || hdr.type == "P3") + std::cerr << "io error: ascii pnm format not supported." + << std::endl; + + check_hdr_ext(hdr, ext); + + impl::read(ntg_value_type(), ima.exact(), istr, hdr); + } + + + } + + + } + + +} + +#endif // ! OLN_IO_PNM_HH Index: oln/io/read_image_pnm_2d.hh --- oln/io/read_image_pnm_2d.hh (revision 245) +++ oln/io/read_image_pnm_2d.hh (working copy) @@ -1,166 +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 OLN_IO_READ_IMAGE_PNM_2D_HH -# define OLN_IO_READ_IMAGE_PNM_2D_HH - -# include <ntg/all.hh> - -# include <oln/canvas/io.hh> - -# include <oln/core/2d/image2d.hh> -# include <oln/io/read_image_pnm_decl.hh> - -namespace oln { - - - namespace io { - - - namespace impl { - - - template <typename I> - struct read_pnm_vect<I, oln::size2d> - : public canvas::read_2d<I, read_pnm_vect<I, oln::size2d> > - { - typedef canvas::read_2d<I, read_pnm_vect<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_comp_type(value_type) comp_type; - typedef oln_io_type(ntg_nbits(ntg_comp_type(value_type))) v_type; - - void impl_read_point() - { - value_type c; - for (unsigned i = 0; i < ntg_nb_comp(value_type); ++i) - { - v_type v; - this->istr.read((char*)&v, sizeof (v_type)); - c[i] = (ntg_storage_type(ntg_comp_type(value_type)))v; - } - this->output[this->p] = c; - } - - void impl_preconditions() - { - precondition(ntg_max_val(comp_type) - ntg_min_val(comp_type) - <= this->hdr.max_val); - precondition(ntg_nb_comp(value_type) == 3); - } - - read_pnm_vect(std::istream& istr, - const internal::pnm_header& hdr) : - super_type(istr, hdr) - {} - - }; - - template <typename I> - struct read_pnm_real<I, oln::size2d> - : public canvas::read_2d<I, read_pnm_real<I, oln::size2d> > - { - typedef canvas::read_2d<I, read_pnm_real<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - typedef oln_io_type(ntg_nbits(ntg_value_type)) v_type; - - - void impl_read_point() - { - v_type v; - this->istr.read((char*)&v, sizeof (v_type)); - this->output[this->p] = (ntg_storage_type(value_type))v; - } - - void impl_preconditions() - { - precondition(ntg_max_val(value_type) - ntg_min_val(value_type) - <= this->hdr.max_val); - } - - read_pnm_real(std::istream& istr, - const internal::pnm_header& hdr) : - super_type(istr, hdr) - {} - - }; - - template <typename I> - struct read_pnm_bin<I, oln::size2d> - : public canvas::read_2d<I, read_pnm_bin<I, oln::size2d> > - { - typedef canvas::read_2d<I, read_pnm_bin<I, oln::size2d> > super_type; - typedef oln_type_of(I, value) value_type; - typedef ntg_type(value_type) ntg_value_type; - typedef oln_io_type(ntg_nbits(ntg_value_type)) v_type; - - char v; - int offset; - - void impl_extra_work() - { - offset = -1; - } - - void impl_read_point() - { - if (offset == -1) - { - this->istr.read(&v, 1); - offset = 7; - } - if ((int)(v & (1<<offset--)) == 0) - this->output[this->p] = 1; - else - this->output[this->p] = 0; - } - - void impl_preconditions() - { - precondition(ntg_max_val(value_type) - ntg_min_val(value_type) - <= this->hdr.max_val); - } - - read_pnm_bin(std::istream& istr, - const internal::pnm_header& hdr) : - super_type(istr, hdr), - offset(-1) - {} - - }; - - - - } - - - } - - -} - -#endif // ! OLN_IO_READ_IMAGE_PNM_2D_HH Index: oln/io/utils.hh --- oln/io/utils.hh (revision 245) +++ oln/io/utils.hh (working copy) @@ -60,104 +60,6 @@ } - struct pnm_header - { - int max_val; - int rows; - int cols; - std::string type; - }; - - bool read_pnm_header(std::istream& istr, - internal::pnm_header& hdr) - { - std::getline(istr, hdr.type); - - hdr.max_val = 1; - - // skip comments - while (istr.peek() == '#') - { - std::string line; - std::getline(istr, line); - } - - // read size - istr >> hdr.cols; - // skip comments - while (istr.peek() == '#') - { - std::string line; - std::getline(istr, line); - } - - - istr >> hdr.rows; - // skip comments - while (istr.peek() == '#') - { - std::string line; - std::getline(istr, line); - } - - if (hdr.cols <= 0 || hdr.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'! - if (istr.get() != '\n') return false; - // extract or skip maxvalue - if (hdr.type != "P1" && hdr.type != "P4") - { - istr >> hdr.max_val; - if (hdr.max_val > 65535 || - istr.get() != '\n' || - hdr.max_val <= 0) - return false; - } - return true; - } - - bool write_pnm_header(std::ostream& ostr, - const std::string& type, - int ncols, - int nrows, - int max_val) - { - if (max_val > 65535) - return false; - - ostr << type << std::endl - << "# Olena 1.0" << std::endl - << ncols << " " << nrows << std::endl; - if (type != "P1" && type != "P4") - ostr << max_val << std::endl; - return true; - } - - template <bool b> - struct pnm_io_helper_bool - { - typedef unsigned char type; - }; - - template <> - struct pnm_io_helper_bool<false> - { - typedef unsigned short type; - }; - - template <unsigned N> - struct pnm_io_helper - { - typedef typename pnm_io_helper_bool<N <= 8>::type type; - }; - } // end of namespace internal } // end of namespace io

19 years, 5 months

proto-1.0 245: Add new I/O canvas

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/canvas/io.hh: Contain New I/O Canvas. Two hierarchies are now handling I/O. The first one fills the image. The second one is dedicated to reading specific file formats. Two classes of those hierarchies communicate to fill an image from a file. io.hh | 203 ++++++++++++++++++++++++------------------------------------------ 1 files changed, 75 insertions(+), 128 deletions(-) Index: oln/canvas/io.hh --- oln/canvas/io.hh (revision 244) +++ oln/canvas/io.hh (working copy) @@ -42,197 +42,144 @@ namespace canvas { - template <typename I, typename E> - struct write : public mlc::any<E> + template <typename I, typename F, typename E> + struct write_from_oln : public mlc::any<E> { + typedef oln_type_of(I, value) value_type; - void impl_extra_work() - { - } - - void work() + void write_point() { - this->exact().impl_work(); + this->exact().impl_write_point(); } - void extra_work() + void run() { - this->exact().impl_extra_work(); - } + unsigned npoints = input.size().npoints(); - void write_point() + writer.set_size(input.size()); + if (writer.write_header() == false) { - this->exact().impl_write_point(); + std::cerr << "io error: data type too large" << std::endl; + return; } - void run() - { - for (p.row() = 0; p.row() < input.size().nrows(); ++p.row()) + for (unsigned i = 0; i < npoints; ++i) { - work(); - extra_work(); + write_point(); + writer.next_point(); } } + write_from_oln(const abstract::image& input, F& writer) : + writer(writer), + input(input) {} - protected: - - write(const oln::abstract::image& input, - std::ostream& ostr) : - input(input.exact()), - ostr(ostr) - {} - + F& writer; box<const I> input; - std::ostream& ostr; - oln_type_of(I, point) p; - }; - - template <typename I, typename E> - struct write_2d: public write<I, E> - { - - void impl_work() + template <typename T, typename G, typename E> + struct write_to_file : public mlc::any<E> { - for (this->p.col() = 0; - this->p.col() < this->input.size().ncols(); - ++this->p.col()) - this->write_point(); - } - protected: - typedef write<I, E> super_type; + typedef oln_grd_type_of(G, size) size_type; + typedef oln_grd_type_of(G, point) point_type; - write_2d(const abstract::image& input, - std::ostream& ostr) : - super_type(input, ostr) - {} - }; - - template <typename I, typename E> - struct write_1d: public write<I, E> + bool write_header() { - - void impl_work() - { - this->write_point(); + return this->exact().impl_write_header(); } - protected: - typedef write<I, E> super_type; - - write_1d(const abstract::image& input, - std::ostream& ostr) : - super_type(input, ostr) - {} - - }; - - - template <typename I, typename E> - struct read : public mlc::any<E> + void set_size(const size_type& size) { + this->exact().impl_set_size(size); + } - void impl_extra_work() {} - - void extra_work() + void write_value(T v) { - this->exact().impl_extra_work(); + this->exact().impl_write_value(v); } - void read_point() + void next_point() { - this->exact().impl_read_point(); + this->exact().impl_next_point(); } - void preconditions() + const point_type& point() { - this->exact().impl_preconditions(); + return this->exact().impl_point(); } - void work() + }; + + + template <typename I, typename F, typename E> + struct read_to_oln : public mlc::any<E> { - this->exact().impl_work(); - } + typedef oln_type_of(I, value) value_type; - void get_output(I& ima) + void read_point() { - ima = output.unbox(); + this->exact().impl_read_point(); } void run() { - preconditions(); - - I tmp(hdr.rows, hdr.cols); - + I tmp(reader.size()); output = tmp; + unsigned npoints = reader.npoints(); - for (p.row() = 0; p.row() < hdr.rows && !istr.eof(); ++p.row()) + for (unsigned i = 0; i < npoints; ++i) { - extra_work(); - work(); + read_point(); + reader.next_point(); } } - protected: + void assign(abstract::image& ima) + { + ima.exact() = output.unbox(); + } - read(std::istream& istr, - const io::internal::pnm_header& hdr) : - istr(istr), - hdr(hdr) - {} + read_to_oln(F& reader) : reader(reader) {} + F& reader; box output; - std::istream& istr; - const io::internal::pnm_header& hdr; - oln_type_of(I, point) p; - }; - template <typename I, typename E> - struct read_2d: public read<I, E> + template <typename T, typename G, typename E> + struct read_from_file : public mlc::any<E> { - void impl_work() + typedef oln_grd_type_of(G, size) size_type; + typedef oln_grd_type_of(G, point) point_type; + + size_type size() { - for (this->p.col() = 0; - this->p.col() < this->hdr.cols && !this->istr.eof(); - ++this->p.col()) - this->read_point(); + return this->exact().impl_size(); } - protected: - typedef read<I, E> super_type; - - read_2d(std::istream& istr, - const io::internal::pnm_header& hdr) : - super_type(istr, hdr) - {} - - }; - - - template <typename I, typename E> - struct read_1d: public read<I, E> + T read_value() { + return this->exact().impl_read_value(); + } - void impl_work() + void next_point() { - this->read_point(); + this->exact().impl_next_point(); } - protected: - typedef read<I, E> super_type; + unsigned npoints() + { + return this->exact().impl_npoints(); + } - read_1d(std::istream& istr, - const io::internal::pnm_header& hdr) : - super_type(istr, hdr) - {} + const point_type& point() + { + return this->exact().impl_point(); + } };

19 years, 5 months

proto-1.0 243: Fix typo in makefile.src

by Christophe Berger

Index: ChangeLog from Christophe Berger <christophe(a)lrde.epita.fr> * olena/oln/makefile.src: Fix typo. makefile.src | 2 +- 1 files changed, 1 insertion(+), 1 deletion(-) Index: olena/oln/makefile.src --- olena/oln/makefile.src (revision 242) +++ olena/oln/makefile.src (working copy) @@ -7,7 +7,7 @@ all.hh \ \ appli/astro/clean.hh \ - appli/astro/tree_coherance_checks.hh \ + appli/astro/tree_coherance_check.hh \ appli/astro/tree_statistics.hh \ \ basics1d.hh \

19 years, 5 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches July 2005