Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

3227: Better display anat segmentation results.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Better display anat segmentation results. * theo/igr/irm_anat_segm.cc (main): Ensure that no basin mean is 0-valued. irm_anat_segm.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) Index: theo/igr/irm_anat_segm.cc --- theo/igr/irm_anat_segm.cc (revision 3226) +++ theo/igr/irm_anat_segm.cc (working copy) @@ -49,7 +49,9 @@ accu::mean<int_u8, float, int_u8> a_; util::array<int_u8> a = labeling::compute(a_, vol, wst, n_basins); - std::cout << a << std::endl; + for (L l = 1; l <= n_basins; ++l) + if (a[l] == 0) + a[l] = 1; a[0] = 0; fun::i2v::array<int_u8> f;

16 years

3226: Prepare to fastest the morpho canvas of algebraic union find.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Prepare to fastest the morpho canvas of algebraic union find. * mln/canvas/morpho/algebraic_union_find.hh (opening_attribute_functor_base): Remove; useless. (impl): New sub-namespace. (find_root, algebraic_union_find): Move into impl. (dispatch): New sub-namespace. (algebraic_union_find_dispatch): New. (algebraic_union_find): New facade. * mln/morpho/closing_attribute.hh (closing_attribute_t_f, closing_attribute_f): Remove dead code. (closing_attribute): Update. * mln/morpho/opening_attribute.hh (opening_attribute_t_f, opening_attribute_f): Remove dead code. (opening_attribute): Update. * tests/convert/impl/Makefile.am: New. * tests/convert/Makefile.am: Update. mln/canvas/morpho/algebraic_union_find.hh | 199 +++++------------------------- mln/morpho/closing_attribute.hh | 94 -------------- mln/morpho/opening_attribute.hh | 91 ------------- tests/convert/Makefile.am | 2 tests/convert/impl/Makefile.am | 10 + 5 files changed, 58 insertions(+), 338 deletions(-) Index: mln/morpho/closing_attribute.hh --- mln/morpho/closing_attribute.hh (revision 3225) +++ mln/morpho/closing_attribute.hh (working copy) @@ -100,6 +100,9 @@ } // end of namespace mln::morpho::impl + + // Facade. + template <typename A, typename I, typename N> inline mln_concrete(I) @@ -110,12 +113,9 @@ mln_precondition(exact(input).is_valid()); - mln_concrete(I) output; - initialize(output, input); - typedef impl::closing_attribute_t<I, A> F; F f(input, lambda); - canvas::morpho::algebraic_union_find(input, nbh, f, output); + mln_concrete(I) output = canvas::morpho::algebraic_union_find(input, nbh, f); mln_postcondition(output >= input); @@ -124,92 +124,6 @@ } - /* ----------------------------------------------------------- - - Old code below. - - namespace impl - { - - template <typename A_, - typename I_, typename N_, typename O_> - struct closing_attribute_t_f - { - typedef mln_psite(I_) P; - - // requirements from mln::canvas::morpho::algebraic_union_find - - typedef A_ A; - typedef I_ I; - typedef N_ N; - typedef O_ O; - typedef p_array S; - typedef util::pix pix_t; - - const I& input; - const N& nbh; - mln_result(A) lambda; - O& output; - - const S s; - - inline - void init() - { - // FIXME: border::fill(input, mln_max(mln_value(I))); - // FIXME: Shouldn't it be - // border::fill(input, mln_max(mln_value(I))) - // instead? - } - - inline - bool is_active(const A& attr) const - { - return attr.to_result() < lambda; - } - - inline - void inactivate(A& attr) - { - attr.set_value(lambda); - } - - // end of requirements - - inline - closing_attribute_t_f(const I_& input, const N_& nbh, - mln_result(A) lambda, O_& output) - : input(input), nbh(nbh), lambda(lambda), output(output), - s(level::sort_psites_increasing(input)) - { - } - - }; - - } // end of namespace mln::morpho::impl - - - template <typename A, - typename I, typename N, typename O> - inline - void closing_attribute_f(const Image& input_, - const Neighborhood<N>& nbh_, mln_result(A) lambda, - Image<O>& output_) - { - const I& input = exact(input_); - const N& nbh = exact(nbh_); - O& output = exact(output_); - mln_precondition(output.domain() == input.domain()); - - typedef impl::closing_attribute_t_f<A,I,N,O> F; - F f(input, nbh, lambda, output); - canvas::morpho::algebraic_union_find_f<F> run(f); - - mln_postcondition(output >= input); - } - - */ - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::morpho Index: mln/morpho/opening_attribute.hh --- mln/morpho/opening_attribute.hh (revision 3225) +++ mln/morpho/opening_attribute.hh (working copy) @@ -102,6 +102,8 @@ } // end of namespace mln::morpho::impl + // Facade. + template <typename A, typename I, typename N> inline mln_concrete(I) @@ -112,101 +114,16 @@ mln_precondition(exact(input).is_valid()); - mln_concrete(I) output; - initialize(output, input); - typedef impl::opening_attribute_t<I, A> F; F f(input, lambda); - canvas::morpho::algebraic_union_find(input, nbh, f, output); + mln_concrete(I) output = canvas::morpho::algebraic_union_find(input, nbh, f); mln_postcondition(output <= input); + trace::exiting("morpho::opening_attribute"); return output; } - - // ----------------------------------------------------------- - // Old code below. - - - namespace impl - { - - template <typename A_, - typename I_, typename N_, typename O_> - struct opening_attribute_t_f - { - typedef mln_psite(I_) P; - - // requirements from mln::canvas::morpho::algebraic_union_find - - typedef A_ A; - typedef I_ I; - typedef N_ N; - typedef O_ O; - typedef p_array S; - typedef util::pix pix_t; - - const I& input; - const N& nbh; - mln_result(A) lambda; - O& output; - - const S s; - - inline - void init() - { - // FIXME: border::fill(input, mln_max(mln_value(I))); - } - - inline - bool is_active(const A& attr) const - { - return attr.to_result() < lambda; - } - - inline - void inactivate(A& attr) - { - attr.set_value(lambda); - } - - // end of requirements - - inline - opening_attribute_t_f(const I_& input, const N_& nbh, - mln_result(A) lambda, O_& output) - : input(input), nbh(nbh), lambda(lambda), output(output), - s(level::sort_psites_decreasing(input)) - { - } - - }; - - } // end of namespace mln::morpho::impl - - - template <typename A, - typename I, typename N, typename O> - inline - void opening_attribute_f(const Image& input_, - const Neighborhood<N>& nbh_, mln_result(A) lambda, - Image<O>& output_) - { - const I& input = exact(input_); - const N& nbh = exact(nbh_); - O& output = exact(output_); - mln_precondition(output.domain() == input.domain()); - - typedef impl::opening_attribute_t_f<A,I,N,O> F; - F f(input, nbh, lambda, output); - canvas::morpho::algebraic_union_find_f<F> run(f); - - mln_postcondition(output <= input); - } - - # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::morpho Index: mln/canvas/morpho/algebraic_union_find.hh --- mln/canvas/morpho/algebraic_union_find.hh (revision 3225) +++ mln/canvas/morpho/algebraic_union_find.hh (working copy) @@ -48,24 +48,13 @@ namespace morpho { - // FIXME: Is it really needed? - struct opening_attribute_functor_base + namespace impl { - inline void init() {} - - template <typename A> - inline bool is_active(const A&) const { return false; } - - template <typename A> - inline void inactivate(A&) {} - }; - template <typename I> - static inline + inline mln_psite(I) - find_root(I& parent, - const mln_psite(I)& x) + find_root(I& parent, const mln_psite(I)& x) { if (parent(x) == x) return x; @@ -73,12 +62,12 @@ return parent(x) = find_root(parent, parent(x)); } - template <typename I, typename N, typename F, typename O> - void + template <typename I, typename N, typename F> + inline + mln_concrete(I) algebraic_union_find(const Image& input_, const Neighborhood<N>& nbh_, - F& f, - Image<O>& output_) + F& f) { trace::entering("canvas::morpho::algebraic_union_find"); @@ -89,20 +78,20 @@ const I& input = exact(input_); const N& nbh = exact(nbh_); - O& output = exact(output_); - mln_precondition(output.domain() == input.domain()); + mln_concrete(I) output; + initialize(output, input); // Local type. typedef mln_psite(I) P; // Auxiliary data. - mln_ch_value(O, bool) deja_vu; + mln_ch_value(I, bool) deja_vu; mln_ch_value(I, bool) activity; - mln_ch_value(O, P) parent; - mln_ch_value(O, A) data; + mln_ch_value(I, P) parent; + mln_ch_value(I, A) data; - // init + // Initialization. { initialize(deja_vu, input); mln::data::fill(deja_vu, false); @@ -113,7 +102,7 @@ f.init(); // init required. } - // first pass + // First pass. { mln_fwd_piter(S) p(f.s); // s required. mln_niter(N) n(nbh, p); @@ -185,7 +174,7 @@ } } - // second pass + // Second pass. { mln_bkd_piter(S) p(f.s); for_all(p) @@ -202,159 +191,47 @@ mln::data::fill(output, input); */ trace::exiting("canvas::morpho::algebraic_union_find"); - } - - - // ----------------------------------------------------------- - // Old code below. - - // General version. - - template <typename F> - struct algebraic_union_find_f - { - F& f; - - typedef typename F::I I; - typedef typename F::N N; - typedef typename F::O O; - typedef typename F::S S; - typedef typename F::A A; - typedef mln_psite(I) psite; - // aux: - mln_ch_value(O, bool) deja_vu; - mln_ch_value(O, psite) parent; - mln_ch_value(O, A) data; - - algebraic_union_find_f(F& f) - : f(f) - { - run(); + return output; } - void run() - { - // init - { - initialize(deja_vu, f.input); - mln::data::fill(deja_vu, false); - initialize(parent, f.input); - initialize(data, f.input); - f.init(); - } - - // first pass - { - mln_fwd_piter(S) p(f.s); - mln_niter(N) n(f.nbh, p); - for_all(p) - { - make_set(p); - for_all(n) - if (f.input.domain().has(n) && deja_vu(n)) - do_union(n, p); - deja_vu(p) = true; - } - } - - // second pass - { - mln_bkd_piter(S) p(f.s); - for_all(p) - if (is_root(p)) - f.output(p) = f.input(p); - else - f.output(p) = f.output(parent(p)); - } - - /* - Change 2nd pass into: - for_all(p) if (not is_root(p)) f.output(p) = f.output(parent(p)); - and add in init: - mln::data::fill(f.output, f.input); - */ - - } // end of run() - - void make_set(const psite& p) - { - parent(p) = p; - /* FIXME: What if the value_type of DATA (i.e., A) were not - based on a accu::count<mln::pix>? Currently, nothing - enforces this, but the code below expects this line to be - valid: - - data(p).take_as_init(make::pix(f.input, p)) - - which probably restricts the kind of input images. + } // end of namespace mln::canvas::morpho::impl - If we want to be more generic, the initialization should - read something like: - init_data(p); - i.e., the functor for the initialization of data should - be passed as an argument to the canvas' ctor. + // Dispatch. - Of course, we might want to restrict attributes to the - accumulator accu::count<mln::pix> (which is perfectly - acceptable), but then this class should statically check - the conformance of the template parameter A to this - constraint. */ - data(p).take_as_init(make::pix(f.input, p)); // FIXME: algebraic so p! - } - - bool is_root(const psite& p) const + namespace internal { - return parent(p) == p; - } - psite find_root(const psite& x) + template <typename I, typename N, typename F> + inline + mln_concrete(I) + algebraic_union_find_dispatch(trait::image::speed::any, + const Image& input, + const Neighborhood<N>& nbh, + F& f) { - if (parent(x) == x) - return x; - else - return parent(x) = find_root(parent(x)); + return impl::algebraic_union_find(input, nbh, f); } - bool equiv(const psite& r, const psite& p) - { - // Either a flat zone or the component of r is still growing. - return f.input(r) == f.input(p) || f.is_active(data(r)); - } + } // end of namespace mln::canvas::morpho::internal - void do_union(const psite& n, const psite& p) - { - psite r = find_root(n); - if (r != p) - { - if (equiv(r, p)) - { - /* FIXME: Same remark as above concerning the - initialization of data(p); instead of - data(p).take(data(r)); - we should (or could) have + // Facade. - unite_data(p, r); - - so as to keep the generic aspect of this canvas - (as long as the set of acceptable types for the - template parameter A is not bound). */ - data(p).take(data(r)); - parent(r) = p; - } - else - f.inactivate(data(p)); - } + template <typename I, typename N, typename F> + inline + mln_concrete(I) + algebraic_union_find(const Image& input, + const Neighborhood<N>& nbh, + F& f) + { + return internal::algebraic_union_find_dispatch(mln_trait_image_speed(I)(), + input, nbh, f); } - }; - - // FIXME: Fast version. - } // end of namespace mln::canvas::morpho Index: tests/convert/impl/Makefile.am --- tests/convert/impl/Makefile.am (revision 0) +++ tests/convert/impl/Makefile.am (revision 0) @@ -0,0 +1,10 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include $(top_srcdir)/milena/tests/tests.mk + +check_PROGRAMS = \ + from_site_set_to_image + +from_site_set_to_image_SOURCES = from_site_set_to_image.cc + +TESTS = $(check_PROGRAMS) Index: tests/convert/Makefile.am --- tests/convert/Makefile.am (revision 3225) +++ tests/convert/Makefile.am (working copy) @@ -2,6 +2,8 @@ include $(top_srcdir)/milena/tests/tests.mk +SUBDIRS = impl + ##FIXME: re-enable all tests check_PROGRAMS = \ to_hsl \

16 years

3225: Fix stuff for registration.

by Ugo Jardonnet

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Ugo Jardonnet <ugo.jardonnet(a)lrde.epita.fr> Fix stuff for registration. * mln/core/image/lazy_image.hh: Fix box type. * mln/fun/x2x/rotation.hh: Fix matrix creation. * mln/registration/get_rot.hh: Assert 3d. * mln/registration/registration.hh: p_array convertion. * mln/registration/icp.hh: Remove debug print. * sandbox/lazzara/igr.cc: Add useless things. mln/core/image/lazy_image.hh | 4 ++-- mln/fun/x2x/rotation.hh | 2 +- mln/registration/get_rot.hh | 28 ++++++++++++++++++++-------- mln/registration/icp.hh | 14 ++------------ mln/registration/registration.hh | 6 +++--- sandbox/lazzara/igr.cc | 34 ++++++++++++++++++++++++++++++++-- 6 files changed, 60 insertions(+), 28 deletions(-) Index: mln/core/image/lazy_image.hh --- mln/core/image/lazy_image.hh (revision 3224) +++ mln/core/image/lazy_image.hh (working copy) @@ -120,7 +120,7 @@ void init_(const F& fun, const B& box); /// Return domain of lazyd_image. - const box2d& domain() const; + const box<mln_psite(I)>& domain() const; /// Test if a pixel value is accessible at \p p. bool has(const mln_psite(I)&) const; @@ -223,7 +223,7 @@ template <typename I, typename F, typename B> inline - const box2d& + const box<mln_psite(I)>& lazy_image<I,F,B>::domain() const { return this->data_->bb_; Index: mln/fun/x2x/rotation.hh --- mln/fun/x2x/rotation.hh (revision 3224) +++ mln/fun/x2x/rotation.hh (working copy) @@ -192,7 +192,7 @@ xy + zw, 1.f - x2 - z2, yz - xw, 0, xz - yw, yz + xw, 1.f - x2 - y2, 0, 0, 0, 0, 1}; - this->m_(make::mat<4,4>(t)); + this->m_ = make::mat<4,4>(t); } template <unsigned n, typename C> Index: mln/registration/get_rot.hh --- mln/registration/get_rot.hh (revision 3224) +++ mln/registration/get_rot.hh (working copy) @@ -61,12 +61,22 @@ const M& map, const algebra::vec<2u,float>& mu_xk) { - (void) c; - (void) mu_c; - (void) ck; - (void) map; - (void) mu_xk; - //FIXME: Write 2d version of rotation computation betwenn two p_array + assert(0 && "TODO"); + + //////SLOW VERSION + + //// V1 + // M1 := c covariance + // V1 := greatest eigen vector of M1 + + //// V2 + // M2 := c covariance + // V2 := greatest eigen vector of M2 + + //// alpha + // cos(alpha) = (V1.V2) / (|V1|.|V2|) + + //FIXME: Write 2d version of rotation computation between two p_arrays return fun::x2x::rotation<2u, float>(); } @@ -85,8 +95,8 @@ algebra::mat<3u,3u,float> Mk(literal::zero); for (unsigned i = 0; i < c.nsites(); ++i) { - algebra::vec<3u,float> ci = c[i]; - algebra::vec<3u,float> xki = map(ck[i]); + algebra::vec<3u,float> ci = convert::to< algebra::vec<3u,float> >(c[i]); + algebra::vec<3u,float> xki = convert::to< algebra::vec<3u,float> >(map(ck[i])); Mk += make::mat(ci - mu_c) * trans(make::mat(xki - mu_xk)); } Mk /= c.nsites(); @@ -121,6 +131,8 @@ algebra::quat qR(literal::zero); qR = math::jacobi(Qk); + std::cout << qR << std::endl; + return fun::x2x::rotation<3u, float>(qR); } Index: mln/registration/registration.hh --- mln/registration/registration.hh (revision 3224) +++ mln/registration/registration.hh (working copy) @@ -66,8 +66,8 @@ const J& surface) { //FIXME: Use convert::to< p_array<mln_psite(I)> >() - p_array<mln_psite(I)> c = convert::to_p_array(cloud); - p_array<mln_psite(J)> x = convert::to_p_array(surface); + p_array<mln_psite(I)> c = convert::to< p_array<mln_psite(I)> >(cloud); + p_array<mln_psite(J)> x = convert::to< p_array<mln_psite(J)> >(surface); //init rigid transform qk composed< rotation<I::psite::dim, float>, translation<I::psite::dim, float> > qk; @@ -78,7 +78,7 @@ //make a lazy_image map via function closest_point fun::x2p::closest_point<mln_psite(I)> fun(x, working_box); - lazy_image<I, fun::x2p::closest_point<mln_psite(I)>, box2d> + lazy_image< I, fun::x2p::closest_point<mln_psite(I)>, box<mln_psite(I)> > map(fun, fun.domain()); //run registration Index: mln/registration/icp.hh --- mln/registration/icp.hh (revision 3224) +++ mln/registration/icp.hh (working copy) @@ -169,18 +169,10 @@ //work on a reduced version of c_ p_array c = c_; - - std::cout << "c_length" << c_length << std::endl; - std::cout << "-nsites" << c_.nsites() << std::endl; - - std::cout << "bad point" << c[9100] << std::endl; - //FIXME: Use c_ and specify c_length to function using c_ c.hook_std_vector_().resize(c_length); - std::cout << "+nsites" << c.nsites() << std::endl; - std::cout << "bad point" << c[9100] << std::endl; - + //FIXME: avoid use of ck p_array ck(c); algebra::vec<P::dim,float> mu_c = center(c); @@ -188,7 +180,6 @@ apply(qk, c, ck); - unsigned int k = 0; do { std::cout << "*------" << std::endl; buf_dk.store(d_k); @@ -204,13 +195,12 @@ // = d(closest(qk-1(P)), qk(P)) d_k = internal::rms(c, map, buf_qk[1], qk); - k++; //FIXME: Add matrix norm //} while ((qk - buf_qk[1]).sqr_norm() / qk.sqr_norm() > epsilon); std::cout << d_k << std::endl; - } while (d_k > 9.2); + } while (d_k > 9.2 + epsilon); trace::exiting("registration::impl::icp_"); } Index: sandbox/lazzara/igr.cc --- sandbox/lazzara/igr.cc (revision 3224) +++ sandbox/lazzara/igr.cc (working copy) @@ -1,4 +1,5 @@ #include <mln/essential/2d.hh> +#include <mln/core/image/image3d.hh> #include <mln/binarization/binarization.hh> #include <mln/labeling/background.hh> @@ -21,7 +22,38 @@ }; +template <typename T> +inline +mln::image3d<T> +to_image3d(const mln::image2d<T>& img) +{ + mln::point3d pmin(img.domain().pmin()[0], img.domain().pmin()[1], 0); + mln::point3d pmax(img.domain().pmax()[0], img.domain().pmax()[1], 0); + mln::image3d<T> img3d(mln::box3d(pmin,pmax)); + mln_piter(mln::image3d<T>) p(img3d.domain()); + for_all(p) + img3d(p) = exact(img)(mln::point2d(p[0],p[1])); + + return img3d; +} + +template <typename T> +inline +mln::point<mln::grid::square, T> +to_point2d(const mln::point<mln::grid::cube, T>& p) +{ + return mln::point<mln::grid::square, T>(p[0], p[1]); +} + +//point2d -> point3d +template <typename T> +inline +mln::point<mln::grid::cube, T> +to_point3d(const mln::point<mln::grid::square, T>& p) +{ + return mln::point<mln::grid::cube, T>(p[0], p[1], 0); +} template <typename I> mln_concrete(I) @@ -132,7 +164,5 @@ for_all(p) res(qk(p.to_site().to_vec())) = true; - io::pbm::save(slice(res,0), "04_registered.pbm"); - }

16 years

3224: sandbox/lazzara/igr.cc: use image3d for registration.

by Guillaume Lazzara

--- milena/ChangeLog | 4 ++ milena/sandbox/lazzara/igr.cc | 69 ++++++++++++++++++++++++++-------------- 2 files changed, 49 insertions(+), 24 deletions(-) diff --git a/milena/ChangeLog b/milena/ChangeLog index 3924430..9ed1258 100644 --- a/milena/ChangeLog +++ b/milena/ChangeLog @@ -1,3 +1,7 @@ +2009-01-28 Guillaume Lazzara <z(a)lrde.epita.fr> + + * sandbox/lazzara/igr.cc: use image3d for registration. + 2009-01-29 Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add conversion from site set to image. diff --git a/milena/sandbox/lazzara/igr.cc b/milena/sandbox/lazzara/igr.cc index 5714f74..984137c 100644 --- a/milena/sandbox/lazzara/igr.cc +++ b/milena/sandbox/lazzara/igr.cc @@ -4,8 +4,12 @@ #include <mln/debug/colorize.hh> -#include <mln/registration/registration.hh> -#include <mln/registration/multiscale.hh> +//#include <mln/registration/registration.hh> +//#include <mln/registration/multiscale.hh> + +#include <mln/essential/3d.hh> +#include <mln/registration/icp2.hh> +#include <mln/core/image/slice_image.hh> struct threshold : mln::Function_p2b<threshold> { @@ -62,18 +66,13 @@ keep_largest_component(const mln::Image& ima) return in_bw_cleaned_full; } -int main(int, char* argv[]) +template <typename I> +mln_ch_value(I,bool) +get_main_object_shape(const mln::Image& in) { using namespace mln; - using value::rgb8; - using value::int_u8; - using value::label_16; - //Load image - typedef image2d<rgb8> I; typedef image2d<bool> J; - I in; - io::ppm::load(in, argv[1]); threshold f; J in_bw = binarization::binarization(in, f); @@ -86,32 +85,54 @@ int main(int, char* argv[]) J ima_grad = morpho::gradient(ima, win_c4p()); io::pbm::save(ima_grad, "03_ima_grad.pbm"); + return ima_grad; +} + + +int main(int, char* argv[]) +{ + using namespace mln; + using namespace fun::x2x; + using value::rgb8; + using value::int_u8; + using value::label_16; + + //Load image + typedef image2d<rgb8> I; + typedef image2d<bool> J; + + I in; + io::ppm::load(in, argv[1]); + J in_grad = get_main_object_shape(in); + I ref; io::ppm::load(ref, argv[2]); - J ref_bw = binarization::binarization(ref, f); + J ref_grad = get_main_object_shape(ref); - io::pbm::save(ref_bw, "ref_bw.pbm"); + std::cout << "Computing registration..." << std::endl; + J cloud = in_grad | pw::value(in_grad) == true; //FIXME: cannot use pw::image with registration. + // mln_VAR(surface, (ref_grad | pw::value(ref_grad) == true)); - J surf = keep_largest_component(ref_bw); - J surf_grad = morpho::gradient(surf, win_c4p()); - std::cout << "Computing registration..." << std::endl; - J cloud = ima_grad | pw::value(ima_grad) == true; //FIXME: cannot use pw::image with registration. - // mln_VAR(surface, (surf_grad | pw::value(surf_grad) == true)); - mln_VAR(registration, registration::multiscale(cloud, surf_grad, 5, 3)); + //mln_VAR(registration, registration::multiscale(cloud, ref_grad, 5, 3)); + typedef image3d<bool> K; + K in_3d = make::image3d(in_grad); + K ref_3d = make::image3d(ref_grad); + composed< rotation<K::psite::dim, float>, translation<K::psite::dim, float> > qk; + registration::icp(in_3d, ref_3d, qk); - std::cout << "Build result image" << std::endl; - J res; - initialize(res, ima_grad); + std::cout << "Build result image" << std::endl; + K res; + initialize(res, in_3d); data::fill(res, false); - mln_VAR(ig, (ima_grad | pw::value(ima_grad) == true)); + mln_VAR(ig, (in_3d | pw::value(in_3d) == true)); mln_piter_(ig_t) p(ig.domain()); for_all(p) - res(registration(p.to_site().to_vec())) = true; + res(qk(p.to_site().to_vec())) = true; - io::pbm::save(res, "04_registered.pbm"); + io::pbm::save(slice(res,0), "04_registered.pbm"); } -- 1.5.6.5

16 years

3223: Add conversion from site set to image.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add conversion from site set to image. * mln/convert/impl/from_image_to_site_set.hh: Fix file doc. * mln/convert/impl/from_site_set_to_image.hh: New. * mln/convert/impl/all.hh: Update. * mln/convert/from_to.hh (from_to_dispatch): New overload. * mln/convert/from_to.hxx (from_to_): New fwd declaration. * tests/convert/impl: New directory. * tests/convert/impl/from_site_set_to_image.cc: New. mln/convert/from_to.hh | 12 +++ mln/convert/from_to.hxx | 6 + mln/convert/impl/all.hh | 1 mln/convert/impl/from_image_to_site_set.hh | 2 mln/convert/impl/from_site_set_to_image.hh | 92 +++++++++++++++++++++++++++ tests/convert/impl/from_site_set_to_image.cc | 54 +++++++++++++++ 6 files changed, 166 insertions(+), 1 deletion(-) Index: mln/convert/impl/from_image_to_site_set.hh --- mln/convert/impl/from_image_to_site_set.hh (revision 3222) +++ mln/convert/impl/from_image_to_site_set.hh (working copy) @@ -28,7 +28,7 @@ #ifndef MLN_CONVERT_IMPL_FROM_IMAGE_TO_SITE_SET_HH # define MLN_CONVERT_IMPL_FROM_IMAGE_TO_SITE_SET_HH -/// \file mln/convert/from_to.hh +/// \file mln/convert/impl/from_image_to_site_set.hh /// /// General conversion procedure from an image to a site_set. /// Index: mln/convert/impl/from_site_set_to_image.hh --- mln/convert/impl/from_site_set_to_image.hh (revision 0) +++ mln/convert/impl/from_site_set_to_image.hh (revision 0) @@ -0,0 +1,92 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_CONVERT_IMPL_FROM_SITE_SET_TO_IMAGE_HH +# define MLN_CONVERT_IMPL_FROM_SITE_SET_TO_IMAGE_HH + +/// \file mln/convert/impl/from_site_set_to_image.hh +/// +/// General conversion procedure from a site_set to an image. + +# include <mln/core/image/sub_image.hh> +# include <mln/geom/bbox.hh> +# include <mln/trait/image_from_grid.hh> +# include <mln/data/fill.hh> + + +namespace mln +{ + + // Forward declarations. + template <typename E> struct Site_Set; + template <typename E> struct Image; + + + namespace convert + { + + namespace impl + { + + /// Conversion of an image \p from towards a site set \p to. + template <typename S, typename I> + void + from_site_set_to_image(const Site_Set<S>& from, Image& to); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename S, typename I> + inline + void + from_site_set_to_image(const Site_Set<S>& from_, Image& to_) + { + const S& from = exact(from_); + I& to = exact(to_); + + box<mln_site(S)> b = geom::bbox(from); + + typedef mln_deduce(I, site, grid) G; + typedef mln_value(I) V; + mln_image_from_grid(G, V) ima(b); + data::fill(ima, false); + data::fill((ima | from).rw(), true); + + to = ima; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::convert::impl + + } // end of namespace mln::convert + +} // end of namespace mln + + +#endif // ! MLN_CONVERT_IMPL_FROM_SITE_SET_TO_IMAGE_HH Index: mln/convert/impl/all.hh --- mln/convert/impl/all.hh (revision 3222) +++ mln/convert/impl/all.hh (working copy) @@ -37,6 +37,7 @@ # include <mln/convert/impl/from_float_to_value.hh> # include <mln/convert/impl/from_image_to_site_set.hh> # include <mln/convert/impl/from_int_to_value.hh> +# include <mln/convert/impl/from_site_set_to_image.hh> # include <mln/convert/impl/from_value_to_value.hh> Index: mln/convert/from_to.hh --- mln/convert/from_to.hh (revision 3222) +++ mln/convert/from_to.hh (working copy) @@ -82,6 +82,18 @@ } + // Site_Set -> Image. + template <typename S, typename I> + inline + void + from_to_dispatch(const Site_Set<S>& from, Image& to) + { + mlc_converts_to(mln_site(S), mln_site(I))::check(); // FIXME: Is it too restrictive? + mln_precondition(exact(from).is_valid()); + mln::convert::impl::from_site_set_to_image(from, to); + } + + // Value -> Value template <typename F, typename T> inline Index: mln/convert/from_to.hxx --- mln/convert/from_to.hxx (revision 3222) +++ mln/convert/from_to.hxx (working copy) @@ -341,6 +341,12 @@ from_to_(const Accumulator<A>& from, mln_result(A)& to); + + // Site_Set -> Image. + template <typename S, typename I> + void + from_to_(const Site_Set<S>& from, Image& to); + // Site_Set -> std::set template <typename S, typename P, typename _C> void Index: tests/convert/impl/from_site_set_to_image.cc --- tests/convert/impl/from_site_set_to_image.cc (revision 0) +++ tests/convert/impl/from_site_set_to_image.cc (revision 0) @@ -0,0 +1,54 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/convert/impl/from_site_set_to_image.cc +/// +/// Tests on mln::convert::impl::from_site_set_to_image. + +#include <mln/core/image/image2d.hh> +#include <mln/core/site_set/p_array.hh> +#include <mln/convert/from_to.hh> + +#include <mln/debug/println.hh> + + +int main() +{ + using namespace mln; + + p_array<point2d> arr; + point2d p(1,1); + arr.append(p); + dpoint2d dp[] = { right, right, down, down, left, left, up }; + for (unsigned i = 0; i < 7; ++i) + p += dp[i], arr.append(p); + + image2d<bool> ima; + convert::impl::from_site_set_to_image(arr, ima); + + // debug::println(ima); +}

16 years

3222: Add morpho elementary gradient fastest impl for functions.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add morpho elementary gradient fastest impl for functions. * mln/morpho/elementary/gradient.hh (todo): New. (gradient_on_function_fastest): New impl. (gradient_dispatch): New overload. gradient.hh | 47 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 45 insertions(+), 2 deletions(-) Index: mln/morpho/elementary/gradient.hh --- mln/morpho/elementary/gradient.hh (revision 3221) +++ mln/morpho/elementary/gradient.hh (working copy) @@ -31,7 +31,9 @@ /// \file mln/morpho/elementary/gradient.hh /// -/// \todo Add fastest versions (be careful about extension values...) +/// \todo Add fastest version for sets. +/// +/// \todo Replace .domain().has() by .has()! # include <mln/morpho/includes.hh> # include <mln/accu/min_max.hh> @@ -92,7 +94,7 @@ mln_niter(N) n(nbh, p); for_all(p) { - a.init(); + a.take_as_init(input(p)); for_all(n) if (input.domain().has(n)) a.take(input(n)); output(p) = a.second() - a.first(); @@ -142,6 +144,38 @@ return output; } + + template <typename I, typename N> + mln_concrete(I) + gradient_on_function_fastest(const Image& input_, const Neighborhood<N>& nbh_) + { + trace::entering("morpho::elementary::impl::gradient_on_function_fastest"); + + const I& input = exact(input_); + const N& nbh = exact(nbh_); + internal::gradient_tests(input, nbh); + + accu::min_max<mln_value(I)> a; + extension::adjust_duplicate(input, nbh); + + mln_concrete(I) output; + initialize(output, input); + + mln_pixter(const I) p_in(input); + mln_pixter(I) p_out(output); + mln_nixter(const I, N) n(p_in, nbh); + for_all_2(p_in, p_out) + { + a.take_as_init(p_in.val()); + for_all(n) + a.take(n.val()); + p_out.val() = a.second() - a.first(); + } + + trace::exiting("morpho::elementary::impl::gradient_on_function_fastest"); + return output; + } + } // end of namespace mln::morpho::elementary::impl @@ -161,6 +195,15 @@ template <typename I, typename N> mln_concrete(I) + gradient_dispatch(trait::image::kind::any, + trait::image::speed::fastest, + const Image& input, const Neighborhood<N>& nbh) + { + return impl::gradient_on_function_fastest(input, nbh); + } + + template <typename I, typename N> + mln_concrete(I) gradient_dispatch(trait::image::kind::logic, trait::image::speed::any, const Image& input, const Neighborhood<N>& nbh)

16 years

3221: Fix timer in trace entering/exiting.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Fix timer in trace entering/exiting. * mln/trace/quiet.hh: Layout. * mln/trace/exiting.hh: Rely on clock. * mln/trace/entering.hh (start_times, scopes): New. (entering): Use clock instead of gettimeofday. entering.hh | 15 ++++++++++++++- exiting.hh | 38 ++++++++++++++++++++++++++++++++++---- quiet.hh | 1 + 3 files changed, 49 insertions(+), 5 deletions(-) Index: mln/trace/quiet.hh --- mln/trace/quiet.hh (revision 3220) +++ mln/trace/quiet.hh (working copy) @@ -56,6 +56,7 @@ } // end of namespace mln::trace::internal + # ifndef MLN_INCLUDE_ONLY bool quiet = true; Index: mln/trace/exiting.hh --- mln/trace/exiting.hh (revision 3220) +++ mln/trace/exiting.hh (working copy) @@ -47,6 +47,8 @@ void exiting(const std::string& scope); + + # ifndef MLN_INCLUDE_ONLY inline @@ -55,8 +57,22 @@ if (quiet) return; - timeval after_time; - gettimeofday(&after_time, 0); + if (scopes.empty()) + { + std::cerr << "error: missing 'entering' scope (exiting is '" << scope << "')" << std::endl; + quiet = true; + } + else + { + if (scopes.top() != scope) + { + std::cerr << "error: bad matching scope (entering is '" << scopes.top() + << "' v. exiting is '" << scope << "')" << std::endl; + quiet = true; + } + scopes.pop(); + } + bool has_inner_trace = (internal::max_tab == tab); --tab; @@ -69,9 +85,23 @@ if (!has_inner_trace) std::cout << scope << " "; + mln_assertion(! start_times.empty()); + std::clock_t now = std::clock(); + + if (start_times.top() > now) + { + std::cerr << "warning: bad timer in trace handling" << std::endl; + // FIXME: So what? + } + + if (start_times.top() < now) + { std::cout << "- " - << (after_time.tv_usec - internal::start_time.tv_usec) / 1000. - << "ms "; + << ((float(now) - float(start_times.top())) / CLOCKS_PER_SEC) + << "s "; + } + + start_times.pop(); if (has_inner_trace || (internal::max_tab - tab > 1)) std::cout << std::endl; Index: mln/trace/entering.hh --- mln/trace/entering.hh (revision 3220) +++ mln/trace/entering.hh (working copy) @@ -35,6 +35,8 @@ # include <string> # include <iostream> +# include <stack> +# include <ctime> # include <mln/trace/quiet.hh> @@ -47,14 +49,26 @@ void entering(const std::string& scope); + extern std::stack<std::clock_t> start_times; + extern std::stack<std::string> scopes; // For testing purpose + // (entering/exiting scope matching). + + # ifndef MLN_INCLUDE_ONLY + std::stack<std::clock_t> start_times; + std::stack<std::string> scopes; + + inline void entering(const std::string& scope) { if (quiet) return; + start_times.push(std::clock()); + scopes.push(scope); + if ((tab != 0) && (internal::max_tab == tab)) std::cout << std::endl; @@ -63,7 +77,6 @@ std::cout << scope << " {"; internal::max_tab = ++tab; - gettimeofday(&internal::start_time, 0); } # endif // ! MLN_INCLUDE_ONLY

16 years

3220: Add segmentation scheme for volumes.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add segmentation scheme for volumes. * theo/igr: New directory. * theo/igr/pgms2pgm.cc: New. * theo/igr/raw2pgm.cc: New. * theo/igr/pgms2raw.cc: New. * theo/igr/irm_anat_segm.cc: New. * theo/igr/irm_anat_segm__2D_ONLY.cc: New. irm_anat_segm.cc | 60 ++++++++++++++++++++++++++++++++++++++++++++++ irm_anat_segm__2D_ONLY.cc | 59 +++++++++++++++++++++++++++++++++++++++++++++ pgms2pgm.cc | 41 +++++++++++++++++++++++++++++++ pgms2raw.cc | 38 +++++++++++++++++++++++++++++ raw2pgm.cc | 34 ++++++++++++++++++++++++++ 5 files changed, 232 insertions(+) Index: theo/igr/pgms2pgm.cc --- theo/igr/pgms2pgm.cc (revision 0) +++ theo/igr/pgms2pgm.cc (revision 0) @@ -0,0 +1,41 @@ +#include <mln/core/image/image2d.hh> +#include <mln/make/image3d.hh> +#include <mln/debug/slices_2d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/pgm/save.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " output.pgm input1.pgm .. inputn.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + typedef image2d<int_u8> I; + + if (argc < 3) + usage(argv); + + + util::array arr; + for (int i = 2; i < argc; ++i) + { + I ima; + io::pgm::load(ima, argv[i]); + arr.append(ima); + } + image3d<int_u8> vol = make::image3d(arr); + + int_u8 bg = 0; + I out = debug::slices_2d(vol, 1.f, bg); + io::pgm::save(out, argv[1]); +} Index: theo/igr/raw2pgm.cc --- theo/igr/raw2pgm.cc (revision 0) +++ theo/igr/raw2pgm.cc (revision 0) @@ -0,0 +1,34 @@ + +#include <mln/core/image/image2d.hh> +#include <mln/make/image3d.hh> +#include <mln/debug/slices_2d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/raw/load.hh> +#include <mln/io/pgm/save.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.raw output.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + + if (argc != 3) + usage(argv); + + image3d<int_u8> vol; + io::raw::load(vol, argv[1]); + + int_u8 bg = 0; + image2d<int_u8> ima = debug::slices_2d(vol, 1.f, bg); + io::pgm::save(ima, argv[2]); +} Index: theo/igr/pgms2raw.cc --- theo/igr/pgms2raw.cc (revision 0) +++ theo/igr/pgms2raw.cc (revision 0) @@ -0,0 +1,38 @@ + +#include <mln/core/image/image2d.hh> +#include <mln/make/image3d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/raw/save.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " output.raw input1.pgm .. inputn.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + typedef image2d<int_u8> I; + + if (argc < 3) + usage(argv); + + + util::array arr; + for (int i = 2; i < argc; ++i) + { + I ima; + io::pgm::load(ima, argv[i]); + arr.append(ima); + } + image3d<int_u8> vol = make::image3d(arr); + io::raw::save(vol, argv[1]); +} Index: theo/igr/irm_anat_segm.cc --- theo/igr/irm_anat_segm.cc (revision 0) +++ theo/igr/irm_anat_segm.cc (revision 0) @@ -0,0 +1,60 @@ + +#include <mln/core/image/image3d.hh> +#include <mln/core/alias/neighb3d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/raw/load.hh> +#include <mln/io/raw/save.hh> + +#include <mln/morpho/elementary/gradient.hh> +#include <mln/morpho/closing_volume.hh> +#include <mln/morpho/meyer_wst.hh> + +#include <mln/accu/mean.hh> +#include <mln/labeling/compute.hh> +#include <mln/fun/i2v/array.hh> +#include <mln/level/transform.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.raw output.raw" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + + if (argc != 3) + usage(argv); + + trace::quiet = false; + + image3d<int_u8> vol, grad, clo; + io::raw::load(vol, argv[1]); + + grad = morpho::elementary::gradient(vol, c6()); + clo = morpho::closing_volume(grad, c6(), 666); + + typedef value::label_16 L; + L n_basins; + image3d<L> wst = morpho::meyer_wst(clo, c6(), n_basins); + + std::cout << n_basins << std::endl; + + accu::mean<int_u8, float, int_u8> a_; + util::array<int_u8> a = labeling::compute(a_, vol, wst, n_basins); + std::cout << a << std::endl; + a[0] = 0; + + fun::i2v::array<int_u8> f; + convert::from_to(a, f); + image3d<int_u8> out = level::transform(wst, f); + + io::raw::save(out, argv[2]); +} Index: theo/igr/irm_anat_segm__2D_ONLY.cc --- theo/igr/irm_anat_segm__2D_ONLY.cc (revision 0) +++ theo/igr/irm_anat_segm__2D_ONLY.cc (revision 0) @@ -0,0 +1,59 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/pgm/save.hh> + +#include <mln/morpho/elementary/gradient.hh> +#include <mln/morpho/closing_volume.hh> +#include <mln/morpho/meyer_wst.hh> + +#include <mln/accu/mean.hh> +#include <mln/labeling/compute.hh> +#include <mln/fun/i2v/array.hh> +#include <mln/level/transform.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm output.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + + if (argc != 3) + usage(argv); + + trace::quiet = false; + + image2d<int_u8> vol, grad, clo; + io::pgm::load(vol, argv[1]); + + grad = morpho::elementary::gradient(vol, c4()); + clo = morpho::closing_volume(grad, c4(), 666); + + typedef value::label_16 L; + L n_basins; + image2d<L> wst = morpho::meyer_wst(clo, c4(), n_basins); + + std::cout << n_basins << std::endl; + + accu::mean<int_u8, float, int_u8> a_; + util::array<int_u8> a = labeling::compute(a_, vol, wst, n_basins); + std::cout << a << std::endl; + a[0] = 0; + + fun::i2v::array<int_u8> f; + convert::from_to(a, f); + image2d<int_u8> out = level::transform(wst, f); + + io::pgm::save(out, argv[2]); +}

16 years

3219: New overload for debug slices_2d with a h/v ratio.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> New overload for debug slices_2d with a h/v ratio. * mln/debug/slices_2d.hh: New overload. * tests/debug/slices_2d.cc: Augment. mln/debug/slices_2d.hh | 93 +++++++++++++++++++++++++++++++++++++++++++---- tests/debug/slices_2d.cc | 36 ++++++++++++++++-- 2 files changed, 119 insertions(+), 10 deletions(-) Index: mln/debug/slices_2d.hh --- mln/debug/slices_2d.hh (revision 3218) +++ mln/debug/slices_2d.hh (working copy) @@ -32,6 +32,8 @@ /// /// Create a 2D image of the slices of the 3D image \p input. +# include <cmath> + # include <mln/core/image/image2d.hh> # include <mln/core/image/image3d.hh> @@ -60,6 +62,15 @@ const mln_value(I)& bg); + /// Create a 2D image of the slices of the 3D image \p input. + /// + template <typename I> + image2d<mln_value(I)> + slices_2d(const Image& input, + float ratio_hv, // horizontal / vertical + const mln_value(I)& bg); + + # ifndef MLN_INCLUDE_ONLY @@ -84,26 +95,96 @@ if (input.nslices() != n_horizontal * n_vertical) data::fill(output, bg); + const point3d& p_min = input.domain().pmin(); + def::coord + sli = p_min.sli(), + last_sli = input.domain().pmax().sli(); for (unsigned i = 0; i < n_vertical; ++i) for (unsigned j = 0; j < n_horizontal; ++j) { - unsigned sli = i * n_horizontal + j; - if (sli == input.nslices()) + dpoint2d dp(i * input.nrows() - p_min.row(), + j * input.ncols() - p_min.col()); + data::paste(apply_p2p(slice(input, sli), + fun::p2p::translation(dp)), + output); + if (++sli > last_sli) { + // Go out of loops. i = n_vertical; j = n_horizontal; break; } - dpoint2d dp(i * input.nrows(), j * input.ncols()); - data::paste(apply_p2p(slice(input, sli), - fun::p2p::translation(dp)), - output); } trace::exiting("debug::slices_2d"); return output; } + + namespace internal + { + + unsigned round_up(float f) + { + unsigned n = static_cast<unsigned>(f + 0.499999f); + int i; + if (n == 0u) + ++n; + if (float(n) < f) + ++n; + return n; + } + + void slices2d_helper(float nslis, float nrows, float ncols, + float ratio_hv, + unsigned& n_horizontal, + unsigned& n_vertical) + { + if (ratio_hv > 1.f) + { + float n_v = std::sqrt(nslis * ncols / ratio_hv / nrows); + n_vertical = internal::round_up(n_v); + float n_h = nslis / float(n_vertical); + n_horizontal = internal::round_up(n_h); + } + else + { + float n_h = std::sqrt(nrows * nslis * ratio_hv / ncols); + n_horizontal = internal::round_up(n_h); + float n_v = nslis / float(n_horizontal); + n_vertical = internal::round_up(n_v); + } + } + + } // end of namespace mln::debug::internal + + + template <typename I> + image2d<mln_value(I)> + slices_2d(const Image& input_, + float ratio_hv, // horizontal / vertical + const mln_value(I)& bg) + { + trace::entering("debug::slices_2d"); + mlc_equal(mln_pset(I), box3d)::check(); + + const I& input = exact(input_); + mln_precondition(input.is_valid()); + mln_precondition(ratio_hv > 0.f); + + unsigned n_horizontal, n_vertical; + internal::slices2d_helper(input.nslices(), input.nrows(), input.ncols(), + ratio_hv, + n_horizontal, n_vertical); + mln_assertion(n_horizontal * n_vertical >= input.nslices()); + + image2d<mln_value(I)> output = slices_2d(input, n_horizontal, n_vertical, bg); + + trace::exiting("debug::slices_2d"); + return output; + } + + # endif // ! MLN_INCLUDE_ONLY } // end of namespace mln::debug Index: tests/debug/slices_2d.cc --- tests/debug/slices_2d.cc (revision 3218) +++ tests/debug/slices_2d.cc (working copy) @@ -28,6 +28,8 @@ /// \file tests/debug/slices_2d.cc /// /// Tests on mln::debug::slices_2d. +/// +/// \todo Add extra tests... #include <mln/debug/slices_2d.hh> #include <mln/debug/iota.hh> @@ -37,7 +39,10 @@ { using namespace mln; - image3d<int> vol(5, 2, 3); + { + point3d p_orig(-1, -2, -3); + box3d b(p_orig, p_orig + dpoint3d(4, 1, 2)); + image3d<int> vol(b); // 5 x 2 x 3 debug::iota(vol); // 1 2 3 @@ -65,8 +70,31 @@ // 25 26 27 -1 -1 -1 // 28 29 30 -1 -1 -1 - mln_assertion(ima.at_(0,0) == 1); - mln_assertion(ima.at_(5,2) == 30); - mln_assertion(ima.at_(5,5) == -1); + mln_assertion(ima(ima.domain().pmin()) == 1); + mln_assertion(ima(ima.domain().pmax()) == -1); + + } + + + // Tests with ratio. + + { + int bg = 0; + image3d<int> vol(1, 1, 1); + image2d<int> ima; + float ratio; + + ratio = 1.f; + ima = debug::slices_2d(vol, ratio, bg); + mln_assertion(ima.nrows() == 1 && ima.ncols() == 1); + + ratio = 0.00001f; + ima = debug::slices_2d(vol, ratio, bg); + mln_assertion(ima.nrows() == 1 && ima.ncols() == 1); + + ratio = 100000.f; + ima = debug::slices_2d(vol, ratio, bg); + mln_assertion(ima.nrows() == 1 && ima.ncols() == 1); + } }

16 years

3218: Add debug conversion from 3D image to 2D mozaic image.

by Thierry Geraud

https://svn.lrde.epita.fr/svn/oln/trunk/milena Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add debug conversion from 3D image to 2D mozaic image. * mln/debug/slices_2d.hh: New. * mln/debug/all.hh: Update. * mln/core/image/slice_image.hh (operator): New conversion. * mln/core/image/image3d.hh (nslices, nrows, ncols): New methods. * tests/debug/slices_2d.cc: New. * tests/debug/Makefile.am: Update. mln/core/image/image3d.hh | 37 +++++++++++++ mln/core/image/slice_image.hh | 18 +++++- mln/debug/all.hh | 3 + mln/debug/slices_2d.hh | 114 ++++++++++++++++++++++++++++++++++++++++++ tests/debug/Makefile.am | 4 + tests/debug/slices_2d.cc | 72 ++++++++++++++++++++++++++ 6 files changed, 245 insertions(+), 3 deletions(-) Index: mln/debug/slices_2d.hh --- mln/debug/slices_2d.hh (revision 0) +++ mln/debug/slices_2d.hh (revision 0) @@ -0,0 +1,114 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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 MLN_DEBUG_SLICES_2D_HH +# define MLN_DEBUG_SLICES_2D_HH + +/// \file mln/debug/slices_2d.hh +/// +/// Create a 2D image of the slices of the 3D image \p input. + +# include <mln/core/image/image2d.hh> + +# include <mln/core/image/image3d.hh> +# include <mln/core/image/slice_image.hh> + +# include <mln/core/image/p2p_image.hh> +# include <mln/fun/p2p/translation.hh> + +# include <mln/data/paste.hh> +# include <mln/data/fill.hh> + + + +namespace mln +{ + + namespace debug + { + + /// Create a 2D image of the slices of the 3D image \p input. + /// + template <typename I> + image2d<mln_value(I)> + slices_2d(const Image& input, + unsigned n_horizontal, unsigned n_vertical, + const mln_value(I)& bg); + + + +# ifndef MLN_INCLUDE_ONLY + + template <typename I> + inline + image2d<mln_value(I)> + slices_2d(const Image& input_, + unsigned n_horizontal, unsigned n_vertical, + const mln_value(I)& bg) + { + trace::entering("debug::slices_2d"); + mlc_equal(mln_pset(I), box3d)::check(); + + const I& input = exact(input_); + + mln_precondition(input.is_valid()); + mln_precondition(n_horizontal > 0 && n_vertical > 0); + mln_precondition(input.nslices() <= n_horizontal * n_vertical); + + image2d<mln_value(I)> output(input.nrows() * n_vertical, + input.ncols() * n_horizontal); + if (input.nslices() != n_horizontal * n_vertical) + data::fill(output, bg); + + for (unsigned i = 0; i < n_vertical; ++i) + for (unsigned j = 0; j < n_horizontal; ++j) + { + unsigned sli = i * n_horizontal + j; + if (sli == input.nslices()) + { + i = n_vertical; + j = n_horizontal; + break; + } + dpoint2d dp(i * input.nrows(), j * input.ncols()); + data::paste(apply_p2p(slice(input, sli), + fun::p2p::translation(dp)), + output); + } + + trace::exiting("debug::slices_2d"); + return output; + } + +# endif // ! MLN_INCLUDE_ONLY + + } // end of namespace mln::debug + +} // end of namespace mln + + +#endif // ! MLN_DEBUG_SLICES_2D_HH Index: mln/debug/all.hh --- mln/debug/all.hh (revision 3217) +++ mln/debug/all.hh (working copy) @@ -46,6 +46,7 @@ } + # include <mln/debug/colorize.hh> # include <mln/debug/format.hh> # include <mln/debug/draw_graph.hh> @@ -54,5 +55,7 @@ # include <mln/debug/println_with_border.hh> # include <mln/debug/put_word.hh> # include <mln/debug/quiet.hh> +# include <mln/debug/slices_2d.hh> + #endif // ! MLN_DEBUG_ALL_HH Index: mln/core/image/slice_image.hh --- mln/core/image/slice_image.hh (revision 3217) +++ mln/core/image/slice_image.hh (working copy) @@ -118,6 +118,10 @@ /// Read-write access to the image value located at point \p p. mln_morpher_lvalue(I) operator()(const point2d& p); + + + /// Const promotion via conversion. + operator slice_image<const I>() const; }; @@ -245,6 +249,16 @@ return this->data_->ima_(p_); } + template <typename I> + inline + slice_image::operator slice_image<const I>() const + { + mln_precondition(this->is_valid()); + slice_image<const I> tmp(this->data_->ima_, + this->data_->sli_); + return tmp; + } + // Routines. @@ -271,12 +285,12 @@ { mlc_equal(mln_pset(I), box3d)::check(); - I& ima = exact(ima_); + const I& ima = exact(ima_); mln_precondition(ima.is_valid()); mln_precondition(sli >= ima.domain().pmin().sli() && sli <= ima.domain().pmax().sli()); - slice_image tmp(ima, sli); + slice_image<const I> tmp(ima, sli); return tmp; } Index: mln/core/image/image3d.hh --- mln/core/image/image3d.hh (revision 3217) +++ mln/core/image/image3d.hh (working copy) @@ -208,6 +208,16 @@ T& at_(def::coord sli, def::coord row, def::coord col); + /// Give the number of slices. + unsigned nslices() const; + + /// Give the number of rows. + unsigned nrows() const; + + /// Give the number of columns. + unsigned ncols() const; + + /// Fast Image method /// Give the offset corresponding to the delta-point \p dp. @@ -501,6 +511,33 @@ template <typename T> inline + unsigned + image3d<T>::nslices() const + { + mln_precondition(this->is_valid()); + return this->data_->b_.len(0); + } + + template <typename T> + inline + unsigned + image3d<T>::nrows() const + { + mln_precondition(this->is_valid()); + return this->data_->b_.len(1); + } + + template <typename T> + inline + unsigned + image3d<T>::ncols() const + { + mln_precondition(this->is_valid()); + return this->data_->b_.len(2); + } + + template <typename T> + inline const T* image3d<T>::buffer() const { Index: tests/debug/Makefile.am --- tests/debug/Makefile.am (revision 3217) +++ tests/debug/Makefile.am (working copy) @@ -5,10 +5,12 @@ check_PROGRAMS = \ println \ println_with_border \ - iota + iota \ + slices_2d println_SOURCES = println.cc println_with_border_SOURCES = println_with_border.cc iota_SOURCES = iota.cc +slices_2d_SOURCES = slices_2d.cc TESTS = $(check_PROGRAMS) Index: tests/debug/slices_2d.cc --- tests/debug/slices_2d.cc (revision 0) +++ tests/debug/slices_2d.cc (revision 0) @@ -0,0 +1,72 @@ +// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE) +// +// 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, 51 Franklin Street, Fifth Floor, +// 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. + +/// \file tests/debug/slices_2d.cc +/// +/// Tests on mln::debug::slices_2d. + +#include <mln/debug/slices_2d.hh> +#include <mln/debug/iota.hh> + + +int main() +{ + using namespace mln; + + image3d<int> vol(5, 2, 3); + debug::iota(vol); + + // 1 2 3 + // 4 5 6 + // + // 7 8 9 + // 10 11 12 + // + // 13 14 15 + // 16 17 18 + // + // 19 20 21 + // 22 23 24 + // + // 25 26 27 + // 28 29 30 + + image2d<int> ima = debug::slices_2d(vol, 2, 3, + -1); + + // 1 2 3 7 8 9 + // 4 5 6 10 11 12 + // 13 14 15 19 20 21 + // 16 17 18 22 23 24 + // 25 26 27 -1 -1 -1 + // 28 29 30 -1 -1 -1 + + mln_assertion(ima.at_(0,0) == 1); + mln_assertion(ima.at_(5,2) == 30); + mln_assertion(ima.at_(5,5) == -1); + +}

16 years

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