Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

by Nicolas Widynski

Index: ChangeLog from Nicolas Widynski <nicolas.widynski(a)lrde.epita.fr> * oln/core/abstract/image.hh: Add concrete type. * oln/core/abstract/image_with_data.hh: Likewise. * oln/core/properties.hh: Likewise. abstract/image.hh | 2 ++ abstract/image_with_data.hh | 1 + properties.hh | 1 + 3 files changed, 4 insertions(+) Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 96) +++ oln/core/abstract/image.hh (working copy) @@ -60,6 +60,7 @@ { typedef mlc::true_type user_defined_; + mlc_decl_prop(category::image, concrete_type); mlc_decl_prop(category::image, value_type); mlc_decl_prop(category::image, point_type); mlc_decl_prop(category::image, size_type); @@ -95,6 +96,7 @@ }; + mlc_register_prop(category::image, concrete_type); mlc_register_prop(category::image, value_type); mlc_register_prop(category::image, point_type); mlc_register_prop(category::image, size_type); Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 96) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -65,6 +65,7 @@ { // intrusive property: typedef is_a<abstract::readwrite_image> image_constness_type; + typedef E concrete_type; }; Index: oln/core/properties.hh --- oln/core/properties.hh (revision 96) +++ oln/core/properties.hh (working copy) @@ -58,6 +58,7 @@ struct value_storage_type; struct storage_type; struct point_type; + struct concrete_type; struct dpoint_type; struct fwd_piter_type; struct bkd_piter_type; -- Widynski Nicolas Promo 2007

19 years, 9 months

proto-1.0 95: Add dpoint3d and point3d implementations

by Christophe Berger

19 years, 9 months

proto-1.0 96: Add dpoint3d and point3d implementations

by Christophe Berger

Index: ChangeLog from Christophe Berger <christophe(a)lrde.epita.fr> * oln/core/abstract/point.hh: Fix point type. * oln/core/3d/dpoint3d.hh: New. * oln/core/3d/point3d.hh: Add operators (+-) implementations. * oln/basics3d.hh: Add new header inclusion. * oln/makefile.src: Add new file. basics3d.hh | 1 core/3d/dpoint3d.hh | 131 +++++++++++++++++++++++++++++++++++++++++++++++++ core/3d/point3d.hh | 22 ++++++++ core/abstract/point.hh | 11 ++-- makefile.src | 1 5 files changed, 163 insertions(+), 3 deletions(-) Index: oln/core/abstract/point.hh --- oln/core/abstract/point.hh (revision 95) +++ oln/core/abstract/point.hh (working copy) @@ -94,7 +94,7 @@ ** ** \return True if both points are the same, false otherwise. */ - bool operator==(const point& rhs) const + bool operator==(const exact_type& rhs) const { return this->exact().impl_eq(rhs.exact()); } @@ -104,7 +104,7 @@ ** ** \return True if both points are different, false otherwise. */ - bool operator!=(const point& rhs) const + bool operator!=(const exact_type& rhs) const { return ! this->operator==(rhs); } @@ -118,7 +118,7 @@ return this->exact().impl_plus(dp); } - const dpoint_type operator-(const point& rhs) const + const dpoint_type operator-(const exact_type& rhs) const { return this->exact().impl_minus(rhs); } @@ -126,6 +126,11 @@ protected: point() {} + + /*! \brief Cpy constructor (protected, empty). + */ + point(const exact_type& pt) {} + }; } // end of namespace abstract Index: oln/core/3d/dpoint3d.hh --- oln/core/3d/dpoint3d.hh (revision 0) +++ oln/core/3d/dpoint3d.hh (revision 0) @@ -0,0 +1,131 @@ +// 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_CORE_3D_DPOINT3D_HH +# define OLENA_CORE_3D_DPOINT3D_HH + +# include <iostream> + +# include <oln/core/coord.hh> + +// FIXME: there's an assumption here: we do not need inheritance for +// dpoints. so abstract::dpoint does not exist... + +// FIXME: doc! + +namespace oln { + + struct point3d; + + struct dpoint3d + { + dpoint3d() + { + } + + dpoint3d(coord_t slice_, coord_t row_, coord_t col_) : + slice_(slice_), + row_(row_), + col_(col_) + { + } + + dpoint3d(const dpoint3d& rhs) : + slice_(rhs.slice_), + row_(rhs.row_), + col_(rhs.col_) + { + } + + dpoint3d& operator=(const dpoint3d& rhs) + { + if (&rhs == this) + return *this; + this->slice_ = rhs.slice_; + this->row_ = rhs.row_; + this->col_ = rhs.col_; + return *this; + } + + bool operator==(const dpoint3d& rhs) const + { + return this->row_ == rhs.row_ && this->col_ == rhs.col_ && this->slice_ == rhs.slice_; + } + + bool operator!=(const dpoint3d& rhs) const + { + return ! this->operator==(rhs); + } + + const dpoint3d operator+(const dpoint3d& rhs) const + { + dpoint3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + + const point3d operator+(const point3d& rhs) const; + + const dpoint3d operator-() const + { + dpoint3d tmp(-this->slice(), -this->row(), -this->col()); + return tmp; + } + + const coord_t row() const { return row_; } + const coord_t col() const { return col_; } + const coord_t slice() const { return slice_; } + + coord_t& row() { return row_; } + coord_t& col() { return col_; } + coord_t& slice() { return slice_; } + + protected: + coord_t slice_, row_, col_; + }; + +} // end of namespace oln + + +std::ostream& operator<<(std::ostream& ostr, const oln::dpoint3d& dp) +{ + return ostr << '(' << dp.slice() << ',' << dp.row() << ',' << dp.col() << ')'; +} + +# include <oln/core/3d/point3d.hh> + +namespace oln { + + const point3d dpoint3d::operator+(const point3d& rhs) const + { + point3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + +} + + +#endif // ! OLENA_CORE_3D_DPOINT3D_HH Index: oln/core/3d/point3d.hh --- oln/core/3d/point3d.hh (revision 95) +++ oln/core/3d/point3d.hh (working copy) @@ -92,6 +92,8 @@ this->row_ == rhs.row_ and this->col_ == rhs.col_; } + const point3d impl_plus(const dpoint3d& rhs) const; + const dpoint3d impl_minus(const point3d& rhs) const; const coord_t slice() const { return slice_; } const coord_t row() const { return row_; } @@ -114,4 +116,24 @@ } +# include <oln/core/3d/dpoint3d.hh> + + +namespace oln { + + const point3d point3d::impl_plus(const dpoint3d& rhs) const + { + point3d tmp(this->slice() + rhs.slice(), this->row() + rhs.row(), this->col() + rhs.col()); + return tmp; + } + + const dpoint3d point3d::impl_minus(const point3d& rhs) const + { + dpoint3d tmp(this->slice() - rhs.slice(), this->row() - rhs.row(), this->col() - rhs.col()); + return tmp; + } + +} // end of namespace oln + + #endif // ! OLENA_CORE_3D_POINT3D_HH Index: oln/basics3d.hh --- oln/basics3d.hh (revision 95) +++ oln/basics3d.hh (working copy) @@ -33,6 +33,7 @@ # include <oln/core/3d/size3d.hh> # include <oln/core/3d/point3d.hh> +# include <oln/core/3d/dpoint3d.hh> # include <oln/core/3d/image3d.hh> #endif // ! OLENA_BASICS3D_HH Index: oln/makefile.src --- oln/makefile.src (revision 95) +++ oln/makefile.src (working copy) @@ -36,6 +36,7 @@ core/3d/fwd_piter3d.hh \ core/3d/image3d.hh \ core/3d/point3d.hh \ + core/3d/dpoint3d.hh \ core/3d/size3d.hh \ core/abstract/data_storage.hh \ core/abstract/dpoint.hh \

19 years, 9 months

proto-1.0 94: Make the `any__best_memory' fast when using gcc-3

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * mlc/any.hh: Make the `any__best_memory' fast when using gcc-3. any.hh | 18 ++++++++++++++++++ 1 files changed, 18 insertions Index: mlc/any.hh --- mlc/any.hh (revision 93) +++ mlc/any.hh (working copy) @@ -108,20 +108,36 @@ // "best memory" version of 'any' + // FIXME: + // We should test with autotools if the compiler allows us to write a + // static_cast or not (diamond inheritance problem). gcc-2.95 gives a + // different adress but not gcc-3. + // On Mac OS X, the compilation fails with a strange link error if you + // try to use the offset computation. template <typename E> struct any <E, dispatch_policy::best_memory> { E& exact() { +# if defined __GNUC__ && __GNUC__ >= 3 + return static_cast<E&>(*this); +# else return *(E*)((char*)this - exact_offset); +# endif } const E& exact() const { +# if defined __GNUC__ && __GNUC__ >= 3 + return static_cast<const E&>(*this); +# else return *(const E*)((const char*)this - exact_offset); +# endif } +# if not defined __GNUC__ || __GNUC__ < 3 static const int exact_offset; static const E exact_obj; static const any_mem(E)& ref_exact_obj; +# endif protected: any() {} @@ -137,11 +153,13 @@ any__best_memory() : super() {} }; +# if not defined __GNUC__ || __GNUC__ < 3 template <typename E> const E any_mem(E)::exact_obj = E(); template <typename E> const any_mem(E)& any_mem(E)::ref_exact_obj = any_mem(E)::exact_obj; template <typename E> const int any_mem(E)::exact_offset = (const char*)(void*)(&any_mem(E)::ref_exact_obj) - (const char*)(void*)(&any_mem(E)::exact_obj); +# endif // "simple" version of 'any'

19 years, 9 months

proto-1.0 95: Add missing image, fixes

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/convert/tests/value_to_point: Fix a wrong instruction. * oln/io/read_image_2d_pnm.hh: Move static variables inside an inline function to attributes. * img/object.pbm: New. Add missing image for dilation and erosion tests. img/object.pbm | 0 oln/io/read_image_2d_pnm.hh | 7 ++++--- tests/convert/tests/value_to_point | 1 - 3 files changed, 4 insertions, 4 deletions Index: tests/convert/tests/value_to_point --- tests/convert/tests/value_to_point (revision 94) +++ tests/convert/tests/value_to_point (working copy) @@ -17,7 +17,6 @@ std::cout << p2.col() << std::endl; std::cout << p2.slice() << std::endl; std::cout << p2 << std::endl; -fdas if (p.index() != 42 || p2.row() != 6 || p2.col() != 64 || Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 94) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -84,6 +84,8 @@ mlc::box image_; std::istream& istr_; internal::pnm_info& info_; + char v; + int offset; read_image_2d_raw(I& image, std::istream &istr, @@ -91,7 +93,8 @@ super_type(image), image_(image), istr_(istr), - info_(info) + info_(info), + offset(-1) {} @@ -163,8 +166,6 @@ void read_value_type(ntg::bin &c) { - static char v; - static int offset = -1; if (offset == -1) { Index: img/object.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/object.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream

19 years, 9 months

proto-1.0 61: Add comparison traits in metalic

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * mlc/cmp.hh: Add comparison traits (greatereq, greater, neq, ...). cmp.hh | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 81 insertions(+), 1 deletion(-) Index: mlc/cmp.hh --- mlc/cmp.hh (revision 59) +++ mlc/cmp.hh (working copy) @@ -32,11 +32,16 @@ # include <mlc/bool.hh> -namespace mlc +namespace mlc { namespace type { + /*-----------------. + | Type comparisons | + `-----------------*/ + + template <typename T, typename U> struct eq : returns_bool_<false> {}; @@ -45,7 +50,82 @@ } // end of namespace type + /*-------------------. + | Values comparisons | + `-------------------*/ + // These struct are quite handy since constructions like + // is_true<a ::ensure() cannot be parsed. + + template<int i, int j> + struct less + { + enum { ret = (i < j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct lesseq + { + enum { ret = (i <= j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct eq + { + enum { ret = (i == j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct neq + { + enum { ret = (i != j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct greater + { + enum { ret = (i > j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct greatereq + { + enum { ret = (i >= j) }; + static void ensure() { is_true<ret>::ensure(); }; + }; + + template<int i, int j> + struct min + { + enum { ret = (i < j ? i : j) }; + }; + + template<int i, int j> + struct max + { + enum { ret = (i > j ? i : j) }; + }; + + template<int i, int j, int N> + struct maxN + { + enum { ret = (i > j ? + (i > N ? N : i) : + (j > N ? N : j)) }; + }; + + template<int i, int N> + struct saturateN + { + enum { ret = (i > N ? N : i) }; + }; + + } // end of namespace mlc

19 years, 9 months

proto-1.0 93: Add dilation and erosion

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * 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 &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 &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 &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 &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 > + struct set_category < utils::impl::clone_type > { typedef category::image ret; }; // super_type template <typename I> - struct set_super_type < utils::clone_type > + struct set_super_type < utils::impl::clone_type > { - typedef abstract::op<I, utils::clone_type > ret; + typedef abstract::op<I, utils::impl::clone_type > ret; }; namespace utils { - template <typename I> - struct clone_type : abstract::op<I, clone_type > - { - typedef abstract::op<I, clone_type > super_type; + namespace impl { - mlc::box input_; + template <typename I> + struct clone_type : abstract::op<I, clone_type > + { + typedef abstract::op<I, clone_type > super_type; - clone_type(I& input) : input_(input) - {} + mlc::box 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 clone(abstract::image& ima) + impl::clone_type clone(abstract::image& ima) { - clone_type tmp(ima.exact()); + impl::clone_type 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& 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& 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& 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& 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& 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& 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& 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& 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; } };

19 years, 9 months

proto-1.0 92: Add test for morpho min and max

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * tests/morpho/tests/stat: New. Test morpho min and max. stat | 19 +++++++++++++++++++ 1 files changed, 19 insertions(+) Index: tests/morpho/tests/stat --- tests/morpho/tests/stat (revision 0) +++ tests/morpho/tests/stat (revision 0) @@ -0,0 +1,19 @@ +#include <ntg/all.hh> +#include <oln/basics2d.hh> +#include <oln/level/fill.hh> +#include <oln/fancy/iota.hh> +#include <oln/morpho/stat.hh> + +#include "check.hh" +#include "data.hh" + +bool check() +{ + oln::window2d w2 = oln::win_c8p(); + oln::image2d<ntg::int_u8> im(10, 10); + oln::fancy::iota(im); + if (oln::morpho::max(im, oln::point2d(5, 5), w2) != 67 || + oln::morpho::min(im, oln::point2d(5, 5), w2) != 45) + return true; + return false; +}

19 years, 9 months

proto-1.0 91: Add arith tests suite to configure.ac

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Add arith tests to olena tests suite. configure.ac | 1 + 1 files changed, 1 insertion(+) Index: configure.ac --- configure.ac (revision 90) +++ configure.ac (working copy) @@ -99,6 +99,7 @@ # OLN_TESTS defined in oln-local.m4 OLN_TESTS([sanity]) + OLN_TESTS([arith]) OLN_TESTS([convert]) OLN_TESTS([core]) OLN_TESTS([io])

19 years, 9 months

proto-1.0 90: Add arith::min and arith::max

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/arith: New. * tests/arith/tests: New. * tests/arith/tests/min: New. * tests/arith/tests/max: New. * tests/arith/Makefile.am: New. * oln/basics.hh: Include oln/core/abstract/op.hh. * oln/arith: New. * oln/arith/min.hh: Compute the pointwise minimum between two images. * oln/arith/max.hh: Compute the pointwise maximum between two images. oln/arith/max.hh | 104 ++++++++++++++++++++++++++++++++++++++++++++++++ oln/arith/min.hh | 104 ++++++++++++++++++++++++++++++++++++++++++++++++ oln/basics.hh | 1 oln/makefile.src | 2 tests/arith/Makefile.am | 5 ++ tests/arith/tests/max | 25 +++++++++++ tests/arith/tests/min | 27 ++++++++++++ 7 files changed, 268 insertions(+) Index: tests/arith/tests/min --- tests/arith/tests/min (revision 0) +++ tests/arith/tests/min (revision 0) @@ -0,0 +1,27 @@ +#include <oln/basics2d.hh> +#include <oln/arith/min.hh> +#include <oln/level/fill.hh> +#include <oln/level/compare.hh> +#include <ntg/int.hh> + + + +bool check() +{ + oln::image2d<ntg::int_u8> ima1(10, 10); + oln::image2d<ntg::int_u8> ima2(10, 10); + + oln::level::fill(ima1, 10); + oln::level::fill(ima2, 20); + + oln::image2d<ntg::int_u8> ima; + + ima = oln::arith::min(ima1, ima2); + + if (oln::level::is_equal(ima, ima1)) + return false; + return true; +} + + + Index: tests/arith/tests/max --- tests/arith/tests/max (revision 0) +++ tests/arith/tests/max (revision 0) @@ -0,0 +1,25 @@ +#include <oln/basics2d.hh> +#include <oln/arith/max.hh> +#include <oln/level/fill.hh> +#include <oln/level/compare.hh> +#include <ntg/int.hh> + + + +bool check() +{ + oln::image2d<ntg::int_u8> ima1(10, 10); + oln::image2d<ntg::int_u8> ima2(10, 10); + + oln::level::fill(ima1, 10); + oln::level::fill(ima2, 20); + + oln::image2d<ntg::int_u8> ima; + + ima = oln::arith::max(ima1, ima2); + + if (oln::level::is_equal(ima, ima2)) + return false; + return true; +} + Index: tests/arith/Makefile.am --- tests/arith/Makefile.am (revision 0) +++ tests/arith/Makefile.am (revision 0) @@ -0,0 +1,5 @@ +include ../check/Makefile.runtests +include ../check/Makefile.check + + +check-local: check-runtests Index: oln/basics.hh --- oln/basics.hh (revision 89) +++ oln/basics.hh (working copy) @@ -58,6 +58,7 @@ # include <oln/core/abstract/point.hh> # include <oln/core/abstract/images.hh> # include <oln/core/abstract/entry.hh> +# include <oln/core/abstract/op.hh> # include <oln/core/abstract/piter.hh> # include <oln/core/abstract/witer.hh> Index: oln/makefile.src --- oln/makefile.src (revision 89) +++ oln/makefile.src (working copy) @@ -5,6 +5,8 @@ OLN_DEP = \ all.hh \ + arith/max.hh \ + arith/min.hh \ basics.hh \ basics1d.hh \ basics2d.hh \ Index: oln/arith/min.hh --- oln/arith/min.hh (revision 0) +++ oln/arith/min.hh (revision 0) @@ -0,0 +1,104 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_ARITH_MIN_HH +# define OLENA_ARITH_MIN_HH + +# include <oln/basics.hh> +# include <ntg/all.hh> + +namespace oln { + + namespace arith { + // fwd decl + namespace impl { + template <typename I> struct min_type; + } + + } + + // category + template <typename I> + struct set_category< arith::impl::min_type > + { + typedef category::image ret; + }; + + // super_type + template <typename I> + struct set_super_type< arith::impl::min_type > + { + typedef abstract::op<I, arith::impl::min_type > ret; + }; + + namespace arith { + + namespace impl { + + template <class I> + struct min_type : abstract::op<I, min_type > + { + mlc::box<const I> input1_; + mlc::box<const I> input2_; + + min_type(const abstract::non_vectorial_image& input1, + const abstract::non_vectorial_image& input2) : + input1_(input1.exact()), + input2_(input2.exact()) + {} + + void impl_run() + { + precondition(input1_->size() == input2_->size()); + I output(input1_->size()); + oln_type_of(I, fwd_piter) p(input1_->size()); + + for_all(p) + output[p] = ntg::min((*input1_)[p].value(), (*input2_)[p].value()); + + *this->image_ = output; + } + + }; + + } + + template <typename I> + impl::min_type min(const abstract::non_vectorial_image& input1, + const abstract::non_vectorial_image& input2) + { + impl::min_type tmp(input1, input2); + tmp.run(); + return tmp; + } + + } + +} // end of namespace oln + + +#endif // ! OLENA_ARITH_MIN_HH Index: oln/arith/max.hh --- oln/arith/max.hh (revision 0) +++ oln/arith/max.hh (revision 0) @@ -0,0 +1,104 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLENA_ARITH_MAX_HH +# define OLENA_ARITH_MAX_HH + +# include <oln/basics.hh> +# include <ntg/all.hh> + +namespace oln { + + namespace arith { + // fwd decl + namespace impl { + template <typename I> struct max_type; + } + + } + + // category + template <typename I> + struct set_category< arith::impl::max_type > + { + typedef category::image ret; + }; + + // super_type + template <typename I> + struct set_super_type< arith::impl::max_type > + { + typedef abstract::op<I, arith::impl::max_type > ret; + }; + + namespace arith { + + namespace impl { + + template <class I> + struct max_type : abstract::op<I, max_type > + { + mlc::box<const I> input1_; + mlc::box<const I> input2_; + + max_type(const abstract::non_vectorial_image& input1, + const abstract::non_vectorial_image& input2) : + input1_(input1.exact()), + input2_(input2.exact()) + {} + + void impl_run() + { + precondition(input1_->size() == input2_->size()); + I output(input1_->size()); + oln_type_of(I, fwd_piter) p(input1_->size()); + + for_all(p) + output[p] = ntg::max((*input1_)[p].value(), (*input2_)[p].value()); + + *this->image_ = output; + } + + }; + + } + + template <typename I> + impl::max_type max(const abstract::non_vectorial_image& input1, + const abstract::non_vectorial_image& input2) + { + impl::max_type tmp(input1, input2); + tmp.run(); + return tmp; + } + + } + +} // end of namespace oln + + +#endif // ! OLENA_ARITH_MAX_HH

19 years, 9 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches