Index: ChangeLog from Damien Thivolle &lt;damien(a)lrde.epita.fr&gt; * tests/morpho/tests/dilation: New. * tests/morpho/tests/erosion: New. * tests/level/Makefile.am: Add missing inclusions. * oln/core/abstract/image_with_data.hh: Use resize_border for const images. * oln/utils/key.hh: Add md5 key implementation. * oln/utils/key.hxx: Likewise. * oln/utils/buffer.hh: Add md5 buffer implementation. * oln/utils/buffer.hxx: Likewise. * oln/utils/md5.hh: Add md5 algorithm implementation. * oln/utils/md5.hxx: Likewise. * oln/utils/clone.hh: Make it respect algorithm coding style. * oln/morpho/dilation.hh: New. Classical dilation implementation * oln/morpho/stat.hh: Replace obsolete use of ::dim by size properties. * oln/morpho/erosion.hh: New. Classical erosion implementation * oln/io/write_image_2d_pnm.hh: Fix binary file handling. * oln/io/read_image_2d_pnm.hh: Likewise. oln/core/abstract/image_with_data.hh | 4 oln/io/read_image_2d_pnm.hh | 4 oln/io/write_image_2d_pnm.hh | 1 oln/morpho/dilation.hh | 178 +++++++++++++++++++ oln/morpho/erosion.hh | 209 ++++++++++++++++++++++ oln/morpho/stat.hh | 12 - oln/utils/buffer.hh | 127 +++++++++++++ oln/utils/buffer.hxx | 163 +++++++++++++++++ oln/utils/clone.hh | 53 +++-- oln/utils/key.hh | 122 +++++++++++++ oln/utils/key.hxx | 80 ++++++++ oln/utils/md5.hh | 241 ++++++++++++++++++++++++++ oln/utils/md5.hxx | 324 +++++++++++++++++++++++++++++++++++ tests/level/Makefile.am | 5 tests/morpho/tests/dilation | 32 +++ tests/morpho/tests/erosion | 31 +++ 16 files changed, 1554 insertions(+), 32 deletions(-) Index: tests/morpho/tests/dilation --- tests/morpho/tests/dilation (revision 0) +++ tests/morpho/tests/dilation (revision 0) @@ -0,0 +1,32 @@ +#include "data.hh" +#include <oln/utils/md5.hh> + +#include <oln/io/read_image.hh> +#include <oln/basics2d.hh> +#include <oln/morpho/dilation.hh> +#include <oln/level/compare.hh> +#include <ntg/all.hh> + +bool check() +{ + oln::utils::key::value_type data_key[16] = + {0xbf, 0x67, 0x3, 0xa1, 0x2d, 0x6c, 0xac, 0xe9, + 0xf3, 0x7c, 0x19, 0x4c, 0x3a, 0x3b, 0x4d, 0xaa}; + + oln::utils::key key(data_key); + + typedef oln::image2d<ntg::bin> im_type; + im_type ima; + ima = oln::io::read(rdata("object.pbm")); + + if (oln::utils::md5(oln::morpho::dilation(ima, oln::win_c8p())) == key) + { + std::cout << "OK" << std::endl; + return false; + } + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} Index: tests/morpho/tests/erosion --- tests/morpho/tests/erosion (revision 0) +++ tests/morpho/tests/erosion (revision 0) @@ -0,0 +1,31 @@ +#include "data.hh" +#include <oln/utils/md5.hh> + +#include <oln/io/read_image.hh> +#include <oln/basics2d.hh> +#include <oln/morpho/erosion.hh> +#include <oln/level/compare.hh> +#include <ntg/all.hh> + +bool check() +{ + oln::utils::key::value_type data_key[16] = + {0x7c, 0x4f, 0xf, 0xc7, 0x27, 0x1, 0x98, 0x81, + 0xfd, 0xb, 0x2e, 0xf6, 0x1c, 0x84, 0xc9, 0x1e}; + + oln::utils::key key(data_key); + + typedef oln::image2d<ntg::bin> im_type; + im_type ima; + ima = oln::io::read(rdata("object.pbm")); + if (oln::utils::md5(oln::morpho::erosion(ima, oln::win_c8p())) == key) + { + std::cout << "OK" << std::endl; + return false; + } + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} Index: tests/level/Makefile.am --- tests/level/Makefile.am (revision 92) +++ tests/level/Makefile.am (working copy) @@ -1,4 +1,5 @@ include ../check/Makefile.runtests +include ../check/Makefile.check -CLEANFILES += cc 2nd_cc connected_out lena_inverted set_level \ - set_level2 threshold_128 + +check-local: check-runtests Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 92) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -178,9 +178,9 @@ return data_ != 0; } - void resize_border(size_t new_border, bool copy_border = false) + void resize_border(size_t new_border, bool copy_border = false) const { - this->data_->resize_border(new_border, copy_border); + (const_cast<storage_type&>(*this->data_)).resize_border(new_border, copy_border); } Index: oln/utils/buffer.hxx --- oln/utils/buffer.hxx (revision 0) +++ oln/utils/buffer.hxx (revision 0) @@ -0,0 +1,163 @@ +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_OLN_UTILS_BUFFER_HXX +# define OLENA_OLN_UTILS_BUFFER_HXX + +// Ctor implementation +inline +buffer::buffer(): current_bit_(0), + data_(), + len1_(ntg_zero_val(value_type)), + len2_(ntg_zero_val(value_type)), + padding_appended_(false), + length_appended_(false) +{ + data_.reserve(length_); + data_.push_back(ntg_zero_val(value_type)); +} + +// add implementation +template <class E> +inline +void buffer::add(const E &e, bool count) +{ + ntg_storage_type(E) mask = 1 << (ntg_nbits(E) - 1); + ntg_storage_type(E) e_cast = e; + + while (mask) + { + push_back(e_cast & mask, !count); + mask >>= 1; + } +} + +// push_back implementation +inline +void buffer::push_back(bool bit, bool is_padding) +{ + precondition(current_bit_ < 32); + + current_bit_ += 1; + data_.back() *= 2; + if (bit) + data_.back() += ntg_unit_val(value_type); + if (current_bit_ == 32) + { + if (data_.size() == data_.capacity()) + data_.reserve(data_.capacity() + length_); + current_bit_ = 0; + data_.push_back(ntg_zero_val(value_type)); + } + if (!is_padding) + { + if (len1_ == ntg_max_val(value_type)) + { + if (len2_ == ntg_max_val(value_type)) + len2_ = ntg_unit_val(value_type); + else + len2_ += ntg_unit_val(value_type); + } + len1_ += ntg_unit_val(value_type); + } +} + +// reorder implementation +inline +buffer::value_type buffer::reorder(value_type x) const +{ + ntg_storage_type_(value_type) r = 0; + ntg_storage_type_(value_type) mask = 0xFF; + + for (unsigned i = 0; i < (sizeof(ntg_storage_type_(value_type))); ++i) + { + r <<= 8; + r |= (mask & ntg_storage_type_(value_type)(x)) >> (i * 8); + mask <<= 8; + } + return r; +} + +// [] operator implementation +inline +ntg::int_u32 buffer::operator[] (unsigned n) const +{ + precondition(n < data_.size()); + + return reorder(data_[n]); +} + +// append padding implementation +inline +void buffer::append_padding() +{ + push_back(true, true); + while (((data_.size() * 32) % 512) != 448) + push_back(false, true); + padding_appended_ = true; +} + +// append_length implementation +inline +void buffer::append_length() +{ + precondition(padding_appended_); + + add(reorder(len2_), false); + add(reorder(len1_), false); + length_appended_ = true; +} + +// size implementation. +inline +unsigned buffer::size() const +{ + return data_.size(); +} + +// bit len implementation. +inline +unsigned buffer::bit_len() const +{ + return data_.size() * 32; +} + +// is_append_padding implementation. +inline +bool buffer::is_append_padding() const +{ + return padding_appended_; +} + +// is append_length implementation. +inline +bool buffer::is_append_length() const +{ + return length_appended_; +} + +#endif // !OLENA_OLN_UTILS_BUFFER_HXX Index: oln/utils/md5.hh --- oln/utils/md5.hh (revision 0) +++ oln/utils/md5.hh (revision 0) @@ -0,0 +1,241 @@ +// Copyright (C) 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_OLN_UTILS_MD5_HH +# define OLENA_OLN_UTILS_MD5_HH + +# include <ntg/all.hh> +# include <vector> + +# include <oln/core/abstract/image_vectorialness.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/piter.hh> + +# include <oln/utils/key.hh> +# include <oln/utils/buffer.hh> + +namespace oln { + namespace utils { + /*! + ** \brief Class used to compute a MD5 digest. + */ + class MD5 + { + public: + typedef ntg::int_u32 value_type; ///< Value to work on. + typedef ntg_storage_type_(value_type) storage_type; ///< Representation type of value type. + + /*! + ** \brief Constructor. + ** + ** Initialization from a buffer. + ** + ** \arg The buffer to use. + */ + explicit MD5(buffer b); + + /*! + ** \brief Compute the digest. + */ + key execute(); + + /*! + ** \brief Generate the key. + ** + ** \pre To avoid meaningless result, you should call execute before. + */ + key gen_key(); + + protected: + /*! + ** \brief initialization of a MD5 algorithm step. + */ + void sav(); + + /*! + ** \brief Round 1 of the algorithm. + */ + void round1(); + + /*! + ** \brief Round 2 of the algorithm. + */ + void round2(); + + /*! + ** \brief Round 3 of the algorithm. + */ + void round3(); + + /*! + ** \brief Round 4 of the algorithm. + */ + void round4(); + + /*! + ** \brief A step of the algorithm. + */ + void step(); + + /*! + ** \brief Sub step to update a register value. + */ + template <class Fun> + void sub_step(const Fun &fun, + storage_type &a, + const storage_type &b, + const storage_type &c, + const storage_type &d, + unsigned k, + unsigned s, + unsigned i); + + /*! + ** \brief Generate a sub part of the key. + ** + ** \arg v Vector of values (output). + ** \arg x Data to put in v. + ** \arg base Where to put x in v. + */ + void gen_sub_key(std::vector<key::value_type> &v, + storage_type x, + unsigned base); + + + buffer buffer_; ///< The buffer to process. + std::vector<storage_type> X; ///< Vector of 16 words. + std::vector<storage_type> T; ///< Vector of 64 words. + unsigned current_; ///< Current position in the buffer. + storage_type aa; ///< Save of a. + storage_type bb; ///< Save of b. + storage_type cc; ///< Save of c. + storage_type dd; ///< Save of d. + storage_type a; ///< A register. + storage_type b; ///< B register. + storage_type c; ///< C register. + storage_type d; ///< D register. + + /*! + ** \brief Functor for bit operations. + ** + ** F(X,Y,Z) = XY v not(X) Z + */ + struct F_ + { + storage_type operator()(const storage_type &x, + const storage_type &y, + const storage_type &z) const + { + // return z ^ (x & (y ^ z)); + return x & y | ~x & z; + } + }; + + F_ F; + + /*! + ** \brief Functor for bit operations. + ** + ** G(X,Y,Z) = XZ v Y not(Z) + */ + struct G_ + { + storage_type operator()(const storage_type &x, + const storage_type &y, + const storage_type &z) const + { + return x & z | y & ~z; + } + }; + + G_ G; + + /*! + ** \brief Functor for bit operations. + ** + ** H(X,Y,Z) = X xor Y xor Z + */ + struct H_ + { + storage_type operator()(const storage_type &x, + const storage_type &y, + const storage_type &z) const + { + return x ^ y ^ z; + } + }; + + H_ H; + + /*! + ** \brief Functor for bit operations. + ** + ** I(X,Y,Z) = Y xor (X v not(Z)) + */ + struct I_ + { + storage_type operator()(const storage_type &x, + const storage_type &y, + const storage_type &z) const + { + return y ^ (x | ~z); + } + }; + + I_ I; + + }; + +#include <oln/utils/md5.hxx> + + /*! + ** \brief Compute The Md5 value of an image. + ** + ** \param I Exact type of the image. + ** + ** \arg im Image to process. + ** + ** Non vectorial image version. + */ + template <class I> + key md5(const oln::abstract::non_vectorial_image<I> &im); + + /*! + ** \brief Compute The Md5 value of an image. + ** + ** \param I Exact type of the image. + ** + ** \arg im Image to process. + ** + ** Vectorial image version. + */ + template <class I> + key md5(const oln::abstract::vectorial_image<I> &im); + + } // !utils +} // !oln +#endif // !OLENA_OLN_UTILS_MD5_HH Index: oln/utils/key.hh --- oln/utils/key.hh (revision 0) +++ oln/utils/key.hh (revision 0) @@ -0,0 +1,122 @@ +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_OLN_UTILS_KEY_HH +# define OLENA_OLN_UTILS_KEY_HH +# include <ntg/all.hh> +# include <vector> +# include <iostream> + +namespace oln { + namespace utils { + /*! + ** \brief 16 bytes key + ** + ** Object to have a nice representation of a MD5 result. + */ + class key + { + public: + typedef ntg::int_u8 value_type; ///< Used data type. + + /*! + ** \brief Constructor used to initialize the key. + ** + ** \pre There must at least 16 elements in data. + ** \arg data Inuput data. + */ + explicit key(const std::vector<value_type> &data); + + /*! + ** \brief Constructor used to initialize the key. + ** + ** \pre There must at least 16 elements in data. + ** \arg data Inuput data. + */ + explicit key(const value_type *data); + + /*! + ** \brief [] operator. + ** + ** \return the ith byte of the key. + ** + ** \arg i Index of the byte wanted. + ** + ** This is the non const version of the operator. + */ + value_type &operator[](unsigned i); + + /*! + ** \brief [] operator. + ** + ** \return the ith byte of the key. + ** + ** \arg i Index of the byte wanted. + ** + ** This is the const version of the operator. + */ + const value_type &operator[](unsigned i) const; + + /*! + ** \brief Check equality between two keys. + ** + ** \arg k Key to be compared with. + */ + bool operator ==(const key &k); + + /*! + ** \brief Check whether two key are different. + ** + ** \arg k Key to be compared with. + */ + bool operator !=(const key &k); + + /*! + ** \brief Write of representation of the key on a stream. + ** + ** stream Stream to put the key on. + ** k Key to represent. + */ + friend std::ostream &operator<<(std::ostream &stream, const key &k) + { + stream << "{"; + for (unsigned i = 0; i < 15; ++i) + stream << "0x" << std::hex << k[i] << ", "; + stream << "0x" << std::hex << k[15] << "}"; + return stream; + } + + + protected: + value_type data_[16]; ///< Internal data. + }; + +# include <oln/utils/key.hxx> + + } // !utils +} // !oln +#endif // !OLENA_OLN_UTILS_KEY_HH Index: oln/utils/buffer.hh --- oln/utils/buffer.hh (revision 0) +++ oln/utils/buffer.hh (revision 0) @@ -0,0 +1,127 @@ +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + + +#ifndef OLENA_OLN_UTILS_BUFFER_HH +# define OLENA_OLN_UTILS_BUFFER_HH + +# include <ntg/int.hh> +# include <vector> + +namespace oln { + namespace utils { + /*! + ** \brief Buffer used for MD5 data type abstraction. + */ + class buffer + { + public: + typedef ntg::int_u32 value_type; ///< Used data type. + + /*! + ** \brief Initialization of data. + */ + buffer(); + + /*! + ** \brief Add every bits of e in data. + ** + ** \arg e Element to work on. + ** \arg count Tell if you want to count e size in the buffer size. + */ + template <class E> + void add(const E &e, bool count = true); + + /*! + ** \brief Push back a bit at the end of the buffer. + ** + ** true -> push back a 1\n + ** false -> push back a 0\n + ** + ** \arg bit Bit to push. + ** \arg is_padding Are you adding padding bytes ? + */ + void push_back(bool bit, bool is_padding = false); + + /*! + ** \brief Return the nth word. + */ + ntg::int_u32 operator[] (unsigned n) const; + + /*! + ** \brief Append padding bits. + */ + void append_padding(); + + /*! + ** \brief Append length. + */ + void append_length(); + + /*! + ** \brief Return the number of words. + */ + unsigned size() const; + + /*! + ** \brief Return the length in bits. + */ + unsigned bit_len() const; + + /*! + ** \brief Tell if the buffer has already been padded. + */ + bool is_append_padding() const; + + /*! + ** \brief Tell if the length has already been appended. + */ + bool is_append_length() const; + + protected: + /*! + ** \brief Change order of data in a word. + ** + ** \arg x Data to reorder. + */ + value_type reorder(value_type x) const; + + static const unsigned length_ = 100; ///< Capacity chunk. + /// Number of the current bit in the current word. + unsigned char current_bit_; + std::vector<value_type> data_; ///< The buffer data. + value_type len1_; ///< first word length + value_type len2_; ///< second word length + bool padding_appended_; ///< Status of padding. + bool length_appended_; ///< Status of length appending. + }; + +# include <oln/utils/buffer.hxx> + + } // !utils +} // !oln +#endif // !OLENA_OLN_UTILS_BUFFER_HH Index: oln/utils/md5.hxx --- oln/utils/md5.hxx (revision 0) +++ oln/utils/md5.hxx (revision 0) @@ -0,0 +1,324 @@ +// Copyright (C) 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_OLN_UTILS_MD5_HXX +# define OLENA_OLN_UTILS_MD5_HXX + +// Ctor. +inline +MD5::MD5(buffer b): buffer_(b), + X(16), + T(), + current_(0), + a(0x67452301), + b(0xefcdab89), + c(0x98badcfe), + d(0x10325476) + // a(0x01234567), + // b(0x89abcdef), + // c(0xfedcba98), + // d(0x76543210) +{ + precondition(buffer_.is_append_padding()); + precondition(buffer_.is_append_length()); + T.reserve(64); + T.push_back(0xd76aa478); /* 1 */ + T.push_back(0xe8c7b756); /* 2 */ + T.push_back(0x242070db); /* 3 */ + T.push_back(0xc1bdceee); /* 4 */ + T.push_back(0xf57c0faf); /* 5 */ + T.push_back(0x4787c62a); /* 6 */ + T.push_back(0xa8304613); /* 7 */ + T.push_back(0xfd469501); /* 8 */ + T.push_back(0x698098d8); /* 9 */ + T.push_back(0x8b44f7af); /* 10 */ + T.push_back(0xffff5bb1); /* 11 */ + T.push_back(0x895cd7be); /* 12 */ + T.push_back(0x6b901122); /* 13 */ + T.push_back(0xfd987193); /* 14 */ + T.push_back(0xa679438e); /* 15 */ + T.push_back(0x49b40821); /* 16 */ + T.push_back(0xf61e2562); /* 17 */ + T.push_back(0xc040b340); /* 18 */ + T.push_back(0x265e5a51); /* 19 */ + T.push_back(0xe9b6c7aa); /* 20 */ + T.push_back(0xd62f105d); /* 21 */ + T.push_back(0x2441453); /* 22 */ + T.push_back(0xd8a1e681); /* 23 */ + T.push_back(0xe7d3fbc8); /* 24 */ + T.push_back(0x21e1cde6); /* 25 */ + T.push_back(0xc33707d6); /* 26 */ + T.push_back(0xf4d50d87); /* 27 */ + T.push_back(0x455a14ed); /* 28 */ + T.push_back(0xa9e3e905); /* 29 */ + T.push_back(0xfcefa3f8); /* 30 */ + T.push_back(0x676f02d9); /* 31 */ + T.push_back(0x8d2a4c8a); /* 32 */ + T.push_back(0xfffa3942); /* 33 */ + T.push_back(0x8771f681); /* 34 */ + T.push_back(0x6d9d6122); /* 35 */ + T.push_back(0xfde5380c); /* 36 */ + T.push_back(0xa4beea44); /* 37 */ + T.push_back(0x4bdecfa9); /* 38 */ + T.push_back(0xf6bb4b60); /* 39 */ + T.push_back(0xbebfbc70); /* 40 */ + T.push_back(0x289b7ec6); /* 41 */ + T.push_back(0xeaa127fa); /* 42 */ + T.push_back(0xd4ef3085); /* 43 */ + T.push_back(0x4881d05); /* 44 */ + T.push_back(0xd9d4d039); /* 45 */ + T.push_back(0xe6db99e5); /* 46 */ + T.push_back(0x1fa27cf8); /* 47 */ + T.push_back(0xc4ac5665); /* 48 */ + T.push_back(0xf4292244); /* 49 */ + T.push_back(0x432aff97); /* 50 */ + T.push_back(0xab9423a7); /* 51 */ + T.push_back(0xfc93a039); /* 52 */ + T.push_back(0x655b59c3); /* 53 */ + T.push_back(0x8f0ccc92); /* 54 */ + T.push_back(0xffeff47d); /* 55 */ + T.push_back(0x85845dd1); /* 56 */ + T.push_back(0x6fa87e4f); /* 57 */ + T.push_back(0xfe2ce6e0); /* 58 */ + T.push_back(0xa3014314); /* 59 */ + T.push_back(0x4e0811a1); /* 60 */ + T.push_back(0xf7537e82); /* 61 */ + T.push_back(0xbd3af235); /* 62 */ + T.push_back(0x2ad7d2bb); /* 63 */ + T.push_back(0xeb86d391); /* 64 */ +} + +// sav() implementation. +inline +void MD5::sav() +{ + for (unsigned i = 0; i < 16; ++i) + X[i] = buffer_[current_ + i]; + current_ += 16; + aa = a; + bb = b; + cc = c; + dd = d; +} + +// round1() implementation. +inline +void MD5::round1() +{ + sub_step(F, a, b, c, d, 0, 7, 1); + sub_step(F, d, a, b, c, 1, 12, 2); + sub_step(F, c, d, a, b, 2, 17, 3); + sub_step(F, b, c, d, a, 3, 22, 4); + sub_step(F, a, b, c, d, 4, 7, 5); + sub_step(F, d, a, b, c, 5, 12, 6); + sub_step(F, c, d, a, b, 6, 17, 7); + sub_step(F, b, c, d, a, 7, 22, 8); + sub_step(F, a, b, c, d, 8, 7, 9); + sub_step(F, d, a, b, c, 9, 12, 10); + sub_step(F, c, d, a, b, 10, 17, 11); + sub_step(F, b, c, d, a, 11, 22, 12); + sub_step(F, a, b, c, d, 12, 7, 13); + sub_step(F, d, a, b, c, 13, 12, 14); + sub_step(F, c, d, a, b, 14, 17, 15); + sub_step(F, b, c, d, a, 15, 22, 16); +} + +// round2() implementation. +inline +void MD5::round2() +{ + sub_step(G, a, b, c, d, 1, 5, 17); + sub_step(G, d, a, b, c, 6, 9, 18); + sub_step(G, c, d, a, b, 11, 14, 19); + sub_step(G, b, c, d, a, 0, 20, 20); + sub_step(G, a, b, c, d, 5, 5, 21); + sub_step(G, d, a, b, c, 10, 9, 22); + sub_step(G, c, d, a, b, 15, 14, 23); + sub_step(G, b, c, d, a, 4, 20, 24); + sub_step(G, a, b, c, d, 9, 5, 25); + sub_step(G, d, a, b, c, 14, 9, 26); + sub_step(G, c, d, a, b, 3, 14, 27); + sub_step(G, b, c, d, a, 8, 20, 28); + sub_step(G, a, b, c, d, 13, 5, 29); + sub_step(G, d, a, b, c, 2, 9, 30); + sub_step(G, c, d, a, b, 7, 14, 31); + sub_step(G, b, c, d, a, 12, 20, 32); +} + +// round3() implementation. +inline +void MD5::round3() +{ + sub_step(H, a, b, c, d, 5, 4, 33); + sub_step(H, d, a, b, c, 8, 11, 34); + sub_step(H, c, d, a, b, 11, 16, 35); + sub_step(H, b, c, d, a, 14, 23, 36); + sub_step(H, a, b, c, d, 1, 4, 37); + sub_step(H, d, a, b, c, 4, 11, 38); + sub_step(H, c, d, a, b, 7, 16, 39); + sub_step(H, b, c, d, a, 10, 23, 40); + sub_step(H, a, b, c, d, 13, 4, 41); + sub_step(H, d, a, b, c, 0, 11, 42); + sub_step(H, c, d, a, b, 3, 16, 43); + sub_step(H, b, c, d, a, 6, 23, 44); + sub_step(H, a, b, c, d, 9, 4, 45); + sub_step(H, d, a, b, c, 12, 11, 46); + sub_step(H, c, d, a, b, 15, 16, 47); + sub_step(H, b, c, d, a, 2, 23, 48); +} + +// round 4() implementation. +inline +void MD5::round4() +{ + sub_step(I, a, b, c, d, 0, 6, 49); + sub_step(I, d, a, b, c, 7, 10, 50); + sub_step(I, c, d, a, b, 14, 15, 51); + sub_step(I, b, c, d, a, 5, 21, 52); + sub_step(I, a, b, c, d, 12, 6, 53); + sub_step(I, d, a, b, c, 3, 10, 54); + sub_step(I, c, d, a, b, 10, 15, 55); + sub_step(I, b, c, d, a, 1, 21, 56); + sub_step(I, a, b, c, d, 8, 6, 57); + sub_step(I, d, a, b, c, 15, 10, 58); + sub_step(I, c, d, a, b, 6, 15, 59); + sub_step(I, b, c, d, a, 13, 21, 60); + sub_step(I, a, b, c, d, 4, 6, 61); + sub_step(I, d, a, b, c, 11, 10, 62); + sub_step(I, c, d, a, b, 2, 15, 63); + sub_step(I, b, c, d, a, 9, 21, 64); +} + +// step implementation. +inline +void MD5::step() +{ + sav(); + round1(); + round2(); + round3(); + round4(); + a += aa; + b += bb; + c += cc; + d += dd; +} + +// sub step implementation. +template <class Fun> +inline +void MD5::sub_step(const Fun &fun, + storage_type &a, + const storage_type &b, + const storage_type &c, + const storage_type &d, + unsigned k, + unsigned s, + unsigned i) +{ + a += fun(b, c, d) + (X[k] + T[i - 1]); + a = a<<s | a>>(32-s); + a += b; + //a = b + ((a + fun(b, c, d) + X[k] + T[i - 1]) << s); +} + +// gen_sub_key implementation. +inline +void MD5::gen_sub_key(std::vector<key::value_type> &v, + storage_type x, + unsigned base) +{ + base *= sizeof(value_type); + + for (unsigned i = 0; i < sizeof(value_type); ++i) + v[base + i] = (x & (0xFF << (i * 8))) >> (i * 8); +} + +// gen_key implementation. + +inline +key MD5::gen_key() +{ + std::vector<key::value_type> k; + + k.reserve(16); + gen_sub_key(k, a, 0); + gen_sub_key(k, b, 1); + gen_sub_key(k, c, 2); + gen_sub_key(k, d, 3); + return key(k); +} + +// execute implementation. +inline +key MD5::execute() +{ + while (buffer_.size() > current_) + step(); + return gen_key(); +} + + +// md5 implementation. +template <class I> +inline +key md5(const oln::abstract::non_vectorial_image<I> &im) +{ + buffer b; + oln_type_of(I, fwd_piter) p(im.size()); + + for_all(p) + b.add(im[p].value()); + b.append_padding(); + b.append_length(); + + oln::utils::MD5 md5(b); + return md5.execute(); +} + +// md5 implementation. +template <class I> +inline +key md5(const oln::abstract::vectorial_image<I> &im) +{ + oln_type_of(I, fwd_piter) p(im.size()); + buffer b; + // unsigned nb = + + for_all(p) + { + for (unsigned i = 0; i < ntg_nb_comp(oln_type_of(I, value)); ++i) + b.add(im[p].value()[i]); + } + b.append_padding(); + b.append_length(); + + oln::utils::MD5 md5(b); + return md5.execute(); +} + +#endif // !OLENA_OLN_UTILS_MD5_HXX Index: oln/utils/clone.hh --- oln/utils/clone.hh (revision 92) +++ oln/utils/clone.hh (working copy) @@ -35,56 +35,63 @@ // fwd decl namespace utils { + + namespace impl { template <typename I> struct clone_type; + } + } // category template <typename I> - struct set_category < utils::clone_type<I> > + struct set_category < utils::impl::clone_type<I> > { typedef category::image ret; }; // super_type template <typename I> - struct set_super_type < utils::clone_type<I> > + struct set_super_type < utils::impl::clone_type<I> > { - typedef abstract::op<I, utils::clone_type<I> > ret; + typedef abstract::op<I, utils::impl::clone_type<I> > ret; }; namespace utils { - template <typename I> - struct clone_type : abstract::op<I, clone_type<I> > - { - typedef abstract::op<I, clone_type<I> > super_type; + namespace impl { - mlc::box<I> input_; + template <typename I> + struct clone_type : abstract::op<I, clone_type<I> > + { + typedef abstract::op<I, clone_type<I> > super_type; - clone_type(I& input) : input_(input) - {} + mlc::box<I> input_; - void impl_run() - { - I ima(input_->size()); - oln_type_of(I, fwd_piter) it(input_->size()); + clone_type(I& input) : input_(input) + {} - for_all(it) - { - ima[it] = (*input_)[it]; - } + void impl_run() + { + I ima(input_->size()); + oln_type_of(I, fwd_piter) it(input_->size()); - *this->image_ = ima; - } - }; + for_all(it) + { + ima[it] = (*input_)[it]; + } + *this->image_ = ima; + } + }; + } + template <typename I> - clone_type<I> clone(abstract::image<I>& ima) + impl::clone_type<I> clone(abstract::image<I>& ima) { - clone_type<I> tmp(ima.exact()); + impl::clone_type<I> tmp(ima.exact()); tmp.run(); return tmp; } Index: oln/utils/key.hxx --- oln/utils/key.hxx (revision 0) +++ oln/utils/key.hxx (revision 0) @@ -0,0 +1,80 @@ +// Copyright (C) 2004 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_OLN_UTILS_KEY_HXX +# define OLENA_OLN_UTILS_KEY_HXX + +// Ctor implementation. +inline +key::key(const std::vector<value_type> &data) +{ + for (unsigned i = 0; i < 16; ++i) + data_[i] = data[i]; +} + +// Ctor implementation. +inline +key::key(const value_type *data) +{ + for (unsigned i = 0; i < 16; ++i) + data_[i] = data[i]; +} + +// [] operator implementation +inline +key::value_type &key::operator[](unsigned i) +{ + precondition(i < 16); + return data_[i]; +} + +// [] operator +inline +const key::value_type &key::operator[](unsigned i) const +{ + precondition(i < 16); + return data_[i]; +} + +// == operator +inline +bool key::operator ==(const key &k) +{ + for (unsigned i = 0; i < 16; ++i) + if (data_[i] != k[i]) + return false; + return true; +} + +// != operator +inline +bool key::operator !=(const key &k) +{ + return !(*this == k); +} + +#endif // !OLENA_OLN_UTILS_KEY_HXX Index: oln/morpho/dilation.hh --- oln/morpho/dilation.hh (revision 0) +++ oln/morpho/dilation.hh (revision 0) @@ -0,0 +1,178 @@ +// Copyright (C) 2001, 2002, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this 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_MORPHO_DILATION_HH +# define OLENA_MORPHO_DILATION_HH + +# include <oln/basics.hh> +# include <oln/morpho/stat.hh> +// # include <oln/morpho/fast_morpho.hh> +# include <mlc/cmp.hh> + +namespace oln { + + namespace morpho { + + /*! + ** \brief Processing dilation. + ** + ** Compute the morphological dilation of input using se + ** as structural element.\n + ** + ** On grey-scale images, each point is replaced by the maximum value + ** of its neighbors, as indicated by se. On binary images, + ** a logical or is performed between neighbors.\n + ** + ** The morpho::fast version of this function use a different + ** algorithm: This algorithm is described in + ** Implementation of morphological operations from: + ** M. Van Droogenbroeck and H. Talbot. + ** "Fast computation of morphological operations with arbitrary + ** structuring elements". Pattern Recognition Letters, + ** 17(14):1451-1460, 1996.\n + ** + ** An histogram of the value of the neighborhood indicated by + ** se is updated while iterating over all point of the + ** image. Doing so is more efficient when the + ** structural element is large.\n + ** + ** \param I Exact type of the input image. + ** \param E Exact type of the neighborhood. + ** + ** \arg input The input image. + ** \arg se Structuring element to use. + ** + ** \code + ** #include <oln/basics2d.hh> + ** #include <oln/morpho/dilation.hh> + ** #include <oln/level/compare.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** typedef oln::image2d<ntg::bin> im_type; + ** + ** im_type im1(oln::load(IMG_IN "object.pbm")); + ** save(oln::morpho::dilation(im1, oln::win_c8p()), + ** IMG_OUT "oln_morpho_dilation.pbm"); + ** } + ** \endcode + ** + ** \image html object_pbm.png + ** \image latex object_pbm.png + ** => + ** \image html oln_morpho_dilation.png + ** \image latex oln_morpho_dilation.png + */ + + // fwd decl + namespace impl { + template <typename I, typename E> struct dilation_type; + } + + } + + // category + template <typename I, typename E> + struct set_category< morpho::impl::dilation_type<I,E> > { typedef category::image ret; }; + + // super_type + template <typename I, typename E> + struct set_super_type< morpho::impl::dilation_type<I,E> > + { + typedef abstract::op<I, morpho::impl::dilation_type<I, E> > ret; + }; + + namespace morpho { + + namespace impl { + + template <class I, class E> + struct dilation_type : abstract::op<I, dilation_type<I, E> > + { + mlc::box<const I> input_; + mlc::box<const E> se_; + + dilation_type(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) : + input_(input.exact()), + se_(se.exact()) + {} + + }; + + template <class I, class E> + struct dilation_type_classic : dilation_type<I, E> + { + typedef dilation_type<I, E> super_type; + + dilation_type_classic(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) : + super_type(input, se) + {} + + void impl_run() + { + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); + I output(this->input_->size()); + this->input_->resize_border(this->se_->get_delta()); + oln_type_of(I, fwd_piter) p(this->input_->size()); + + for_all (p) + output[p] = morpho::max(*this->input_, p, *this->se_); + *this->image_ = output; + } + }; + + } + + template<class I, class E> + impl::dilation_type<I, E> + dilation(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) + { + impl::dilation_type_classic<I, E> tmp(input, se); + tmp.run(); + return tmp; + } + + +// namespace fast { +// template<class I, class E> +// oln_concrete_type(I) +// dilation(const abstract::non_vectorial_image<I>& input, +// const abstract::struct_elt<E>& se) +// { +// return fast_morpho<I, E, utils::histogram_max<oln_value_type(I)> > +// (input, se); +// } +// } + } // end of morpho + +} // end of oln + +#endif // ! OLENA_MORPHO_DILATION_HH Index: oln/morpho/stat.hh --- oln/morpho/stat.hh (revision 92) +++ oln/morpho/stat.hh (working copy) @@ -63,7 +63,9 @@ static V max(const I& input, const oln_type_of(I, point)& p, const E& se) { - // FIXME: test dim I == dim E + // FIXME: test dim I == dim + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); dp.start(); @@ -88,6 +90,8 @@ min(const I& input, const oln_type_of(I, point)& p, const E& se) { // FIXME: test dim I == dim E + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); dp.start(); @@ -108,7 +112,8 @@ static ntg::bin max(const I& input, const oln_type_of(I, point)& p, const E& se) { - mlc::eq<I::dim, E::dim>::ensure(); + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); for_all (dp) if (input[p + dp] == true) @@ -119,7 +124,8 @@ static ntg::bin min(const I& input, const oln_type_of(I, point)& p, const E& se) { - mlc::eq<I::dim, E::dim>::ensure(); + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); oln_type_of(E, fwd_witer) dp(se); for_all (dp) if (input[p + dp] == false) Index: oln/morpho/erosion.hh --- oln/morpho/erosion.hh (revision 0) +++ oln/morpho/erosion.hh (revision 0) @@ -0,0 +1,209 @@ +// Copyright (C) 2001, 2002, 2003, 2004, 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_MORPHO_EROSION_HH +# define OLENA_MORPHO_EROSION_HH + +# include <oln/basics.hh> +# include <oln/morpho/stat.hh> +// # include <oln/morpho/fast_morpho.hh> +# include <oln/core/abstract/op.hh> +# include <mlc/cmp.hh> + +namespace oln { + + namespace morpho { + /*! + ** \brief Perform a morphological erosion. + ** + ** Compute the morphological erosion of input using se + ** as structuring element. + ** + ** On grey-scale images, each point is replaced by the minimum + ** value of its neighbors, as indicated by se. On binary + ** images, a logical and is performed between neighbors. The + ** morpho::fast version of this function use a different + ** algorithm: an histogram of the value of the neighborhood + ** indicated by se is updated while iterating over all point of + ** the image. Doing so is more efficient when the structuring + ** element is large. + ** + ** \param I Exact type of the input image. + ** \param E Exact type of the structuring element. + ** + ** + ** \arg input Input image. + ** \arg se Structuring element to use. + ** + ** \code + ** #include <oln/basics2d.hh> + ** #include <oln/morpho/erosion.hh> + ** #include <oln/level/compare.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** typedef oln::image2d<ntg::bin> im_type; + ** + ** im_type im1(oln::load(IMG_IN "object.pbm")); + ** save(oln::morpho::erosion(im1, oln::win_c8p()), + ** IMG_OUT "oln_morpho_erosion.pbm"); + ** } + ** \endcode + ** + ** \image html object_pbm.png + ** \image latex object_pbm.png + ** => + ** \image html oln_morpho_erosion.png + ** \image latex oln_morpho_erosion.png + ** + ** \see oln::morpho::fast::erosion() + */ + + // fwd decl + namespace impl { + template <typename I, typename E> struct erosion_type; + } + + } + + // category + template <typename I, typename E> + struct set_category< morpho::impl::erosion_type<I,E> > { typedef category::image ret; }; + + // super_type + template <typename I, typename E> + struct set_super_type< morpho::impl::erosion_type<I,E> > + { + typedef abstract::op<I, morpho::impl::erosion_type<I, E> > ret; + }; + + namespace morpho { + + namespace impl { + + template <class I, class E> + struct erosion_type : abstract::op<I, erosion_type<I, E> > + { + mlc::box<const I> input_; + mlc::box<const E> se_; + + erosion_type(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) : + input_(input.exact()), + se_(se.exact()) + {} + + }; + + template <class I, class E> + struct erosion_type_classic : erosion_type<I, E> + { + typedef erosion_type<I, E> super_type; + + erosion_type_classic(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) : + super_type(input, se) + {} + + void impl_run() + { + mlc::is_true<mlc::type::eq<oln_type_of(I, size), + oln_type_of(E, size)>::ret>::ensure(); + I output(this->input_->size()); + this->input_->resize_border(this->se_->get_delta()); + oln_type_of(I, fwd_piter) p(this->input_->size()); + + for_all (p) + output[p] = morpho::min(*this->input_, p, *this->se_); + *this->image_ = output; + } + }; + + } + + + template<class I, class E> + impl::erosion_type<I, E> + erosion(const abstract::non_vectorial_image<I>& input, + const abstract::struct_elt<E>& se) + { + impl::erosion_type_classic<I, E> tmp(input, se); + tmp.run(); + return tmp; + } + + namespace fast { + /*! + ** \brief Perform a morphological erosion. + ** + ** Compute the morphological erosion of input using se + ** as structuring element. + ** + ** \param I Exact type of the input image. + ** \param E Exact type of the structuring element. + ** + ** + ** \arg input Input image. + ** \arg se Structuring element to use. + ** + ** \code + ** #include <oln/basics2d.hh> + ** #include <oln/morpho/erosion.hh> + ** #include <oln/level/compare.hh> + ** #include <ntg/all.hh> + ** int main() + ** { + ** typedef oln::image2d<ntg::bin> im_type; + ** + ** im_type im1(oln::load(IMG_IN "object.pbm")); + ** save(oln::morpho::fast::erosion(im1, oln::win_c8p()), + ** IMG_OUT "oln_morpho_fast_erosion.pbm"); + ** } + ** \endcode + ** + ** \image html object_pbm.png + ** \image latex object_pbm.png + ** => + ** \image html oln_morpho_fast_erosion.png + ** \image latex oln_morpho_fast_erosion.png + */ +// template<class I, class E> +// oln_concrete_type(I) +// erosion(const abstract::non_vectorial_image<I>& input, +// const abstract::struct_elt<E>& se) +// { +// return fast_morpho<I, E, utils::histogram_min<oln_value_type(I)> > +// (input, se); +// } + } // end of fast + + } // end of morpho + +} // end of oln + + +#endif // ! OLENA_MORPHO_EROSION_HH Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 92) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -116,6 +116,7 @@ if (bin_offset == -1) { + bin_v = ~bin_v; ostr_.write(&bin_v, 1); bin_offset = 7; bin_v = 0; Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 92) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -172,9 +172,9 @@ offset = 7; } if ((int)(v & (1<<offset--)) == 0) + c = 1; + else c = 0; - else - c = 1; } };