Index: ChangeLog from Damien Thivolle <damien@lrde.epita.fr> * tests/utils: New. * tests/utils/tests: New. * tests/utils/tests/clone: New. * tests/utils/Makefile.am: New. * oln/utils: New. * oln/utils/clone.hh: New. Clone images. * oln/makefile.src: Add new file. * oln/core/value_box.hh: Add operators for value_box<I> because it does not match template <typename II> value_box<II>. * oln/core/abstract/op.hh: Add missing initialization. * oln/core/1d/image1d.hh: Add constructor for size1d. * oln/core/2d/image2d.hh: Add constructor for size2d. * oln/core/3d/image3d.hh: Add constructor for size3d. oln/core/1d/image1d.hh | 9 +++- oln/core/2d/image2d.hh | 5 ++ oln/core/3d/image3d.hh | 9 +++- oln/core/abstract/op.hh | 8 +++- oln/core/value_box.hh | 28 +++++++++++++- oln/makefile.src | 3 + oln/utils/clone.hh | 95 ++++++++++++++++++++++++++++++++++++++++++++++++ tests/utils/Makefile.am | 5 ++ tests/utils/tests/clone | 35 +++++++++++++++++ 9 files changed, 189 insertions(+), 8 deletions(-) Index: tests/utils/tests/clone --- tests/utils/tests/clone (revision 0) +++ tests/utils/tests/clone (revision 0) @@ -0,0 +1,35 @@ +#include "data.hh" + +#include <ntg/all.hh> + +#include <oln/basics2d.hh> +#include <oln/utils/clone.hh> +#include <oln/io/read_image.hh> +#include <oln/level/compare.hh> +#include <oln/level/fill.hh> + + +bool check() +{ + oln::image2d<ntg::int_u8> ima1; + oln::image2d<ntg::int_u8> ima2; + oln::image2d<ntg::int_u8> ima_copy; + + ima1 = oln::io::read(rdata("lena.pgm")); + ima2 = oln::io::read(rdata("lena.pgm")); + ima_copy = oln::utils::clone(ima1); + + oln::level::fill(ima1, 0); + if (oln::level::is_equal(ima2, ima_copy)) + { + std::cout << "OK" << std::endl; + return false; + } + else + { + std::cout << "FAIL" << std::endl; + return true; + } +} + + Index: tests/utils/Makefile.am --- tests/utils/Makefile.am (revision 0) +++ tests/utils/Makefile.am (revision 0) @@ -0,0 +1,5 @@ +include ../check/Makefile.runtests +include ../check/Makefile.check + + +check-local: check-runtests Index: oln/utils/clone.hh --- oln/utils/clone.hh (revision 0) +++ oln/utils/clone.hh (revision 0) @@ -0,0 +1,95 @@ +// Copyright (C) 2005 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +// MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef OLN_UTILS_CLONE_HH +# define OLN_UTILS_CLONE_HH + +# include <oln/core/abstract/op.hh> +# include <oln/core/abstract/piter.hh> + +namespace oln { + + // fwd decl + namespace utils { + template <typename I> struct clone_type; + } + + // category + template <typename I> + struct set_category < utils::clone_type<I> > + { + typedef category::image ret; + }; + + // super_type + template <typename I> + struct set_super_type < utils::clone_type<I> > + { + typedef abstract::op<I, utils::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; + + mlc::box<I> input_; + + clone_type(I& input) : input_(input) + {} + + void impl_run() + { + I ima(input_->size()); + oln_type_of(I, fwd_piter) it(input_->size()); + + for_all(it) + { + ima[it] = (*input_)[it]; + } + + *this->image_ = ima; + } + }; + + + template <typename I> + clone_type<I> clone(abstract::image<I>& ima) + { + clone_type<I> tmp(ima.exact()); + tmp.run(); + return tmp; + } + } +} + + +#endif // ! OLN_UTILS_CLONE_HH Index: oln/makefile.src --- oln/makefile.src (revision 80) +++ oln/makefile.src (working copy) @@ -61,4 +61,5 @@ io/write_image.hh \ io/write_image_2d_pnm.hh \ level/compare.hh \ - level/fill.hh + level/fill.hh \ + utils/clone.hh Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 80) +++ oln/core/value_box.hh (working copy) @@ -98,6 +98,12 @@ return ! this->operator==(rhs); } + /*! \brief operator < + ** + ** Define the main comparison operator for value_box. <= >= and > + ** are computed using integre operators \see ntg/core/global_ops.hh:138. + */ + template <typename V> bool operator<(const V& rhs) const { @@ -110,6 +116,15 @@ return this->value() < value.value(); } + /*! \brief specialized version for value_box<I> + ** + ** FIXME: why do we need this class ??? + */ + bool operator<(const value_box<I>& rhs) const + { + return this->value() < value.value(); + } + /*! \brief op= ** FIXME:... ** \return (*this) @@ -138,7 +153,13 @@ return *this; } + value_box& operator=(const value_box<I>& rhs) + { + ima_->set(p_, rhs.value()); // automatic conversion from rhs to value_type + return *this; + } + /*! \brief Set ** ** NEW code @@ -275,11 +296,16 @@ } template <typename II> - bool operator<(const value_box<II>& rhs) const + bool operator<(const value_box<const II>& rhs) const { return this->value() < rhs.value(); } + bool operator<(const value_box<const I>& rhs) const + { + return this->value() < rhs.value(); + } + /*! \brief Assignment (op=) is declared but undefined. */ Index: oln/core/abstract/op.hh --- oln/core/abstract/op.hh (revision 80) +++ oln/core/abstract/op.hh (working copy) @@ -58,7 +58,10 @@ this->exact_ptr = (E*)(void*)(this); } - op() {} + op() + { + this->exact_ptr = (E*)(void*)(this); + } void run() { @@ -74,7 +77,8 @@ template <typename E> struct void_op : public mlc::any<E> { - void_op() {} + void_op() + {} void run() { Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 80) +++ oln/core/1d/image1d.hh (working copy) @@ -120,12 +120,17 @@ this->exact_ptr = this; } - image1d(coord_t nindices) : - super_type(size1d(nindices)) + image1d(const size1d& size) : super_type(size) { this->exact_ptr = this; } + image1d(coord_t nindices, size_t border = 2) : + super_type(size1d(nindices, border)) + { + this->exact_ptr = this; + } + image1d(image1d& rhs) : super_type(rhs) { Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 80) +++ oln/core/2d/image2d.hh (working copy) @@ -129,6 +129,11 @@ this->exact_ptr = this; } + image2d(const size2d& size) : super_type(size) + { + this->exact_ptr = this; + } + image2d(coord_t nrows, coord_t ncols, size_t border = 2) : super_type(size2d(nrows, ncols, border)) { Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 80) +++ oln/core/3d/image3d.hh (working copy) @@ -115,12 +115,17 @@ this->exact_ptr = this; } - image3d(coord_t nslices, coord_t nrows, coord_t ncols) : - super_type(size3d(nslices, nrows, ncols)) + image3d(const size3d& size) : super_type(size) { this->exact_ptr = this; } + image3d(coord_t nslices, coord_t nrows, coord_t ncols, size_t border = 2) : + super_type(size3d(nslices, nrows, ncols, border)) + { + this->exact_ptr = this; + } + image3d(image3d& rhs) : super_type(rhs) {