[Olena] oln 10.60: Add static hierarchy. Add tests

Index: olena/ChangeLog from Niels Van Vliet &lt;niels(a)lrde.epita.fr&gt; * oln/utils/histogram.hh: Inherit from mlc_hierarchy::any. * value_to_point.hh: Inherit from conversion_from_type_to_type. * tests/utils/tests/histogram: Add namespace. * tests/morpho/tests/area: Add file. Index: olena/oln/utils/histogram.hh --- olena/oln/utils/histogram.hh Mon, 02 Feb 2004 15:36:12 +0100 van-vl_n (oln/10_histogram. 1.6.1.14.1.2 644) +++ olena/oln/utils/histogram.hh Fri, 06 Feb 2004 15:03:47 +0100 van-vl_n (oln/10_histogram. 1.6.1.14.1.2 644) @@ -28,60 +28,134 @@ #ifndef OLENA_UTILS_HISTOGRAM_HH # define OLENA_UTILS_HISTOGRAM_HH -# include <ntg/basics.hh> -# include <oln/basics.hh> + +# include <oln/core/image1d.hh> +# include <oln/core/image3d.hh> + # include <oln/convert/value_to_point.hh> + +# include <oln/core/abstract/image.hh> + # include <vector> namespace oln { namespace utils { - template< typename T, typename CPT, class V2P> - class histogram; + namespace internal { + //! Return the size of the space needed to explore the type T + template <typename T> + struct img_max_size + { + private: + typedef typename ntg_is_a(T, ntg::non_vectorial)::ensure_type ensure_type; + public: + typedef image1d_size size_type; + typedef T comp_type; + + image1d_size + operator()() + { + size_type s(ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, + 1); + return s; + } + }; - template< typename T, typename CPT, class V2P > - T - min(const histogram<T, CPT, V2P>& hist); - template< typename T, typename CPT, class V2P > - T - max(const histogram<T, CPT, V2P>& hist); + template <unsigned Qbits, template <unsigned> class S> + struct img_max_size<ntg::color<3, Qbits, S> > + { + public: + typedef image3d_size size_type; + typedef typename ntg::color<3, Qbits, S>::comp_type comp_type; + + image3d_size + operator()() + { + size_type s(ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, + ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, + ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, + 1); + return s; + } + }; + } + + namespace abstract + { + template<class T, + typename CPT, + class Exact = mlc::final> + class histogram: public mlc_hierarchy::any<Exact> + { + public: + typedef histogram<T, CPT, Exact> self_type; + typedef Exact exact_type; + typedef CPT cpt_type; + + void + clear() + { + this->exact().clear_impl(); + } + + const CPT& + operator[](const T &v)const + { + return this->exact().at(v); + } + + CPT& + operator[](const T &v) + { + return this->exact().at(v); + } + + template <class I> + void + init(const oln::abstract::image<I> &img) + { + return this->exact().init_impl(img.exact()); + } + }; + } template<typename T, typename CPT = unsigned, - class V2P = value_to_point<T> > - class histogram + class V2P = oln::convert::value_to_point<T>, + class Exact = mlc::final> + class histogram: public abstract::histogram + <T, CPT, typename mlc::exact_vt<histogram<T, CPT, V2P, Exact>, Exact>::ret> { public: + typedef histogram<T, CPT, V2P, Exact> self_type; + typedef Exact exact_type; typedef T input_type; typedef V2P value_to_point_type; typedef CPT cpt_type; - typedef histogram<T, CPT, V2P> self_type; typedef typename value_to_point_type::result_type point_type; enum {dim = value_to_point_type::result_type::dim}; + typedef abstract::histogram<T, CPT, self_type> upper_type; typedef typename dim_traits<dim, CPT>::img_type img_type; - friend T min<T, CPT, V2P>(const histogram<T, CPT, V2P>& hist); - friend T max<T, CPT, V2P>(const histogram<T, CPT, V2P>& hist); - histogram(const value_to_point_type & c2p = value_to_point_type()): - v2p_(c2p), img_(v2p_.size()) + v2p_(c2p), img_(internal::img_max_size<input_type>()()) { clear(); } template <class I> - histogram(const abstract::image<I> & input, + histogram(const oln::abstract::image<I> & input, const value_to_point_type & v2p = value_to_point_type()): - v2p_(v2p), img_(v2p_.size()) + v2p_(v2p), img_(internal::img_max_size<input_type>()()) { clear(); init(input); } void - clear() + clear_impl() { typename img_type::iter_type it(img_ ); for_all(it) @@ -89,20 +163,20 @@ } const CPT& - operator[](const T &v)const + at(const T &v)const { return img_[v2p_(v)]; } CPT& - operator[](const T &v) + at(const T &v) { return img_[v2p_(v)]; } template <class I> void - init(const abstract::image<I> &img) + init_impl(const oln::abstract::image<I> &img) { oln_iter_type(I) it_img(img); @@ -122,9 +196,9 @@ }; //Note: If there is no min an assertion will fail at the end of the loop. - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class Exact> inline T - min(const histogram<T, CPT, V2P>& hist) + min(const abstract::histogram<T, CPT, Exact>& hist) { typedef typename ntg_is_a(T, ntg::non_vectorial)::ensure_type ensure_type; @@ -134,11 +208,10 @@ break; return i; } - //Note: If there is no max an assertion will fail at the end of the loop. - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class Exact> inline T - max(const histogram<T, CPT, V2P>& hist) + max(const abstract::histogram<T, CPT, Exact>& hist) { typedef typename ntg_is_a(T, ntg::non_vectorial)::ensure_type ensure_type; @@ -169,8 +242,13 @@ value are accessed, and delay the _real_ min and max compuation until min() or max() is called. */ - template< typename T, typename CPT = unsigned, class V2P = value_to_point<T> > - class histogram_minmax : public histogram<T, CPT, V2P> + template< typename T, + typename CPT = unsigned, + class V2P = convert::value_to_point<T>, + class Exact = mlc::final> + class histogram_minmax : public histogram + <T, CPT, V2P, + typename mlc::exact_vt<histogram_minmax<T, CPT, V2P, Exact>, Exact>::ret> { private: typedef typename ntg_is_a(T, ntg::non_vectorial)::ensure_type ensure_type; @@ -183,31 +261,32 @@ if (idx < min_) min_ = idx; } - public: - + typedef histogram_minmax<T, CPT, V2P, Exact> self_type; + typedef Exact exact_type; + typedef histogram<T, CPT, V2P, histogram_minmax<T, CPT, V2P, Exact> typedef V2P value_to_point_type; histogram_minmax(const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(v2p), + upper_type(v2p), min_(ntg_min_val(T)), max_(ntg_max_val(T)) {} template <class I> - histogram_minmax(const abstract::image<I> & input, + histogram_minmax(const oln::abstract::image<I> & input, const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(input, v2p), + upper_type(input, v2p), min_(ntg_min_val(T)), max_(ntg_max_val(T)) {} const CPT& - operator[](const T& i) const + at(const T& i) const { adjust(i); return img_[v2p_(i)]; } CPT& - operator[](const T& i) + at(const T& i) { adjust(i); return img_[v2p_(i)]; @@ -235,8 +314,13 @@ T min_, max_; // indices of min and max elements }; - template< typename T, typename CPT = unsigned, class V2P = value_to_point<T> > - class histogram_min : public histogram<T, CPT, V2P> + template< typename T, + typename CPT = unsigned, + class V2P = convert::value_to_point<T>, + class Exact = mlc::final> + class histogram_min : public histogram<T, CPT, V2P, + typename mlc::exact_vt<histogram_min<T, CPT, V2P, Exact>, + Exact>::ret> { private: typedef typename ntg_is_a(T, ntg::non_vectorial)::ensure_type ensure_type; @@ -248,26 +332,29 @@ min_ = idx; } public: + typedef histogram_min<T, CPT, V2P, Exact> self_type; + typedef Exact exact_type; typedef V2P value_to_point_type; + typedef histogram<T, CPT, V2P, histogram_min<T, CPT, V2P, Exact> + histogram_min(const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(v2p), min_(ntg_min_val(T)) {} + upper_type(v2p), min_(ntg_min_val(T)) {} template <class I> - histogram_min(const abstract::image<I> & input, + histogram_min(const oln::abstract::image<I> & input, const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(input, v2p), min_(ntg_min_val(T)) {} + upper_type(input, v2p), min_(ntg_min_val(T)) {} const CPT& - operator[](const T& i) const + at(const T& i) const { - adjust(i); return img_[v2p_(i)]; } CPT& - operator[](const T& i) + at(const T& i) { adjust(i); return img_[v2p_(i)]; @@ -292,8 +379,13 @@ T min_; // index of min element }; - template< typename T, typename CPT = unsigned, class V2P = value_to_point<T> > - class histogram_max : public histogram<T, CPT, V2P> + template< typename T, + typename CPT = unsigned, + class V2P = convert::value_to_point<T> , + class Exact = mlc::final> + class histogram_max : public histogram<T, CPT, V2P, + typename mlc::exact_vt<histogram_max<T, CPT, V2P, Exact>, + Exact>::ret> { protected: void @@ -304,25 +396,27 @@ } public: + typedef histogram_max<T, CPT, V2P, Exact> self_type; + typedef Exact exact_type; typedef V2P value_to_point_type; + typedef histogram<T, CPT, V2P, histogram_max<T, CPT, V2P, Exact> histogram_max(const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(v2p),max_(ntg_max_val(T)) {} + upper_type(v2p),max_(ntg_max_val(T)) {} template <class I> - histogram_max(const abstract::image<I> & input, + histogram_max(const oln::abstract::image<I> & input, const value_to_point_type & v2p = value_to_point_type()) : - histogram<T, CPT, V2P>(input, v2p),max_(ntg_max_val(T)) {} + upper_type(input, v2p),max_(ntg_max_val(T)) {} const CPT& - operator[](const T& i) const + at(const T& i) const { - adjust(i); return img_[v2p_(i)]; } CPT& - operator[](const T& i) + at(const T& i) { adjust(i); return img_[v2p_(i)]; @@ -347,34 +441,34 @@ T max_; // index of max element }; - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class V2P, class Exact > inline T - min(histogram_minmax<T, CPT, V2P>& hist) + min(histogram_minmax<T, CPT, V2P, Exact>& hist) { return hist.min(); } - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class V2P, class Exact > inline T - min(histogram_min<T, CPT, V2P>& hist) + min(histogram_min<T, CPT, V2P, Exact>& hist) { return hist.min(); } - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class V2P, class Exact > inline T - max(histogram_minmax<T, CPT, V2P>& hist) + max(histogram_minmax<T, CPT, V2P, Exact>& hist) { return hist.max(); } - template< typename T, typename CPT, class V2P > + template< typename T, typename CPT, class V2P, class Exact > inline T - max(histogram_max<T, CPT, V2P>& hist) + max(histogram_max<T, CPT, V2P, Exact>& hist) { return hist.max(); } template<class I> void - distrib_sort(const abstract::image<I>& im, + distrib_sort(const oln::abstract::image<I>& im, std::vector<oln_point_type(I)> &v) { typedef oln_value_type(I) val; @@ -406,7 +500,7 @@ template<class I> void - distrib_sort_inv(const abstract::image<I>& im, + distrib_sort_inv(const oln::abstract::image<I>& im, std::vector<oln_point_type(I)> &v) { typedef oln_value_type(I) val; Index: olena/tests/utils/tests/histogram --- olena/tests/utils/tests/histogram Mon, 02 Feb 2004 15:36:12 +0100 van-vl_n (oln/u/27_histogram. 1.2.1.2 604) +++ olena/tests/utils/tests/histogram Wed, 04 Feb 2004 18:24:49 +0100 van-vl_n (oln/u/27_histogram. 1.2.1.2 604) @@ -92,9 +92,9 @@ histogram<int_s<4> > his4(is4); res = res && - min(his4) == -4 + utils::min(his4) == -4 && - max(his4) == 3; + utils::max(his4) == 3; histogram_min<int_s<4> > his4_min(is4); histogram_max<int_s<4> > his4_max(is4); @@ -106,14 +106,14 @@ his4_minmax[2] = his4_min[2] = his4_max[2] = his4[2] = 42; res = res && - min(his4) == -5 && - max(his4) == 2 && - min(his4) == min(his4_min) && - min(his4) == min(his4_max) && - min(his4) == min(his4_minmax) && - max(his4) == max(his4_min) && - max(his4) == max(his4_max) && - max(his4) == max(his4_minmax); + utils::min(his4) == -5 && + utils::max(his4) == 2 && + utils::min(his4) == utils::min(his4_min) && + utils::min(his4) == utils::min(his4_max) && + utils::min(his4) == utils::min(his4_minmax) && + utils::max(his4) == utils::max(his4_min) && + utils::max(his4) == utils::max(his4_max) && + utils::max(his4) == utils::max(his4_minmax); return res; }; Index: olena/oln/convert/value_to_point.hh --- olena/oln/convert/value_to_point.hh Mon, 02 Feb 2004 10:57:28 +0100 van-vl_n (oln/j/43_value_to_p 1.1 644) +++ olena/oln/convert/value_to_point.hh Fri, 06 Feb 2004 15:14:05 +0100 van-vl_n (oln/j/43_value_to_p 1.1 644) @@ -27,66 +27,62 @@ #ifndef OLENA_VALUE_TO_POINT # define OLENA_VALUE_TO_POINT -# include <oln/core/image1d.hh> -# include <oln/core/image2d.hh> -# include <oln/core/image3d.hh> +# include <oln/core/point1d.hh> +# include <oln/core/point3d.hh> # include <ntg/int.hh> # include <ntg/color/color.hh> +# include <oln/convert/conversion.hh> namespace oln { - template <typename T> - struct value_to_point - { + namespace convert { + + template <typename Argument_type, + class Exact = mlc::final> + struct value_to_point: + public abstract::conversion_from_type_to_type + <Argument_type, + point1d, + typename mlc::exact_vt<value_to_point<Argument_type, + Exact>, + Exact>::ret> + { + private: + typedef typename ntg_is_a(Argument_type, ntg::non_vectorial)::ensure_type ensure_type; + public: typedef point1d result_type; - typedef T input_type; - typedef image1d_size size_type; + typedef Argument_type argument_type; + template <class input_type> result_type - operator()(const input_type &input) const + doit(const input_type &input) const { result_type r(input - ntg_min_val(input_type)); return r; } - - size_type - size() const - { - return size_type(ntg_max_val(input_type) - ntg_min_val(input_type) + 1, - 1); - } - protected: - typedef typename ntg_is_a(input_type, ntg::non_vectorial)::ensure_type ensure_type; }; - //FIXME: the number of components is not a parameter (due to size_type) - template <unsigned Qbits,template <unsigned> class S> - struct value_to_point<typename ntg::color<3, Qbits, S> > + template <unsigned Qbits, template <unsigned> class S, class Exact> + struct value_to_point<ntg::color<3, Qbits, S>, Exact>: + public abstract::conversion_from_type_to_type + <typename ntg::color<3, Qbits, S>, + point3d, + typename mlc::exact_vt<value_to_point<typename ntg::color<3, Qbits, S>, + Exact>, + Exact>::ret> { - enum {nbcomps = 3, qbits = Qbits}; - - typedef ntg::color<nbcomps, qbits, S> input_type; - typedef typename dim_traits<nbcomps, unsigned>::img_type::size_type - size_type; - typedef typename input_type::comp_type comp_type; + public: typedef point3d result_type; + typedef typename ntg::color<3, Qbits, S> argument_type; result_type - operator()(const input_type &input) const + operator()(const argument_type &input) const { result_type r; - for (unsigned i = 0; i < nbcomps; ++i) + for (unsigned i = 0; i < 3; ++i) r.nth(i) = input[i]; return r; } - - size_type - size() const - { - return size_type(ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, - ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, - ntg_max_val(comp_type) - ntg_min_val(comp_type) + 1, - 1); - } }; } +} #endif Index: olena/tests/morpho/tests/area --- olena/tests/morpho/tests/area Fri, 06 Feb 2004 15:24:17 +0100 van-vl_n () +++ olena/tests/morpho/tests/area Fri, 06 Feb 2004 10:30:34 +0100 van-vl_n (oln/j/44_area 644) @@ -0,0 +1,197 @@ +// -*- c++ -*- + +#include <oln/basics2d.hh> +#include <oln/basics1d.hh> +#include <oln/morpho/attribute_closing_opening.hh> +#include <ntg/all.hh> + +#include "check.hh" +#include "data.hh" + +using namespace oln; +using namespace ntg; + +#define OK_OR_FAIL \ + std::cout << "OK" << std::endl; \ + else \ + { \ + std::cout << "FAIL" << std::endl; \ + fail = true; \ + } + +bool +check_opening1d() +{ + bool fail(false); + + image1d<int_u8> im(11); + image1d<int_u8>::iter_type it(im); + for_all(it) + im[it] = ntg_min_val(int_u8); + im(0) = 0; + im(1) = 1 ; + im(2) = 1 ; + im(3) = 0; + im(4) = 1 ; + im(5) = 2 ; + im(6) = 3 ; + im(7) = 3 ; + im(8) = 5 ; + im(9) = 1 ; + im(10) = 0; + + image1d<int_u8> im2 = + morpho::tarjan::area_opening(im, neighb_c2(), 2); + + fail = fail || + im2(0) != 0 || + im2(1) != 1 || + im2(2) != 1 || + im2(3) != 0 || + im2(4) != 1 || + im2(5) != 2 || + im2(6) != 3 || + im2(7) != 3 || + im2(8) != 3 || + im2(9) != 1 || + im2(10)!= 0; + + image1d<int_u8> im3 = + morpho::tarjan::area_opening(im, neighb_c2(), 3); + fail = fail || + im3(0) != 0 || + im3(1) != 0 || + im3(2) != 0 || + im3(3) != 0 || + im3(4) != 1 || + im3(5) != 2 || + im3(6) != 3 || + im3(7) != 3 || + im3(8) != 3 || + im3(9) != 1 || + im3(10)!= 0; + + image1d<int_u8> im4 = + morpho::tarjan::area_opening(im, neighb_c2(), 4); + fail = fail || + im4(0) != 0 || + im4(1) != 0 || + im4(2) != 0 || + im4(3) != 0 || + im4(4) != 1 || + im4(5) != 2 || + im4(6) != 2 || + im4(7) != 2 || + im4(8) != 2 || + im4(9) != 1 || + im4(10)!= 0; + return fail; +} + + +bool +check_opening1d_s() +{ + bool fail(false); + + image1d<int_s<3> > im(11); + image1d<int_s<3> >::iter_type it(im); + for_all(it) + im[it] = ntg_min_val(int_s<3> ); + im(0) = -4; + im(1) = -2 ; + im(2) = -2 ; + im(3) = -4; + im(4) = -2 ; + im(5) = 0 ; + im(6) = 2 ; + im(7) = 2 ; + im(8) = 3 ; + im(9) = -2 ; + im(10) = -4; + + image1d<int_s<3> > im2 = + morpho::tarjan::area_opening(im, neighb_c2(), 2); + + fail = fail || + im2(0) != -4 || + im2(1) != -2 || + im2(2) != -2 || + im2(3) != -4 || + im2(4) != -2 || + im2(5) != 0 || + im2(6) != 2 || + im2(7) != 2 || + im2(8) != 2 || + im2(9) != -2 || + im2(10)!= -4; + + image1d<int_s<3> > im3 = + morpho::tarjan::area_opening(im, neighb_c2(), 3); + fail = fail || + im3(0) != -4 || + im3(1) != -4 || + im3(2) != -4 || + im3(3) != -4 || + im3(4) != -2 || + im3(5) != 0 || + im3(6) != 2 || + im3(7) != 2 || + im3(8) != 2 || + im3(9) != -2 || + im3(10)!= -4; + + image1d<int_s<3> > im4 = + morpho::tarjan::area_opening(im, neighb_c2(), 4); + fail = fail || + im4(0) != -4 || + im4(1) != -4 || + im4(2) != -4 || + im4(3) != -4 || + im4(4) != -2 || + im4(5) != 0 || + im4(6) != 0 || + im4(7) != 0 || + im4(8) != 0 || + im4(9) != -2 || + im4(10)!= -4; + + return fail; +} + +bool +check_lena() +{ + bool fail(false); + + image2d<int_u8> lena = load(rdata("lena.pgm")); + image2d<int_u8> lena5 = morpho::tarjan::area_closing(lena, neighb_c8(), 100); + + unsigned l = 0; + image2d<int_u8>::iter_type it_l(lena5); + for_all(it_l) + l += lena5[it_l]; + fail = fail || + l != 31472398; + return fail; +} + +bool +check() +{ + bool fail = false; + + std::cout << "area opening 1d ... " << std::flush; + if (check_opening1d() == false) + OK_OR_FAIL; + + std::cout << "area opening with int_s<3> ... " << std::flush; + if (check_opening1d_s() == false) + OK_OR_FAIL; + + std::cout << "area closing 2d on lena.pgm ... " << std::flush; + if (check_lena() == false) + OK_OR_FAIL; + + return fail; +}