Index: ChangeLog from Damien Thivolle <damien@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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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<I>& 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