- Olena-patches

4331: Add some experimental code.
by Thierry Geraud 27 Jul '09

27 Jul '09

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add some experimental code. * icdar/2009/pscomp: New directory. * icdar/2009/pscomp/iz.cc: New. Compute an IZ image along with distances between objects. * icdar/2009/pscomp/rect_filter.cc: New. Algebraic filtering with a combinaison of bounding box width and height. * theo/experimental/depeche: New directory. * theo/experimental/depeche/homogen.cc: New. * theo/experimental/depeche/col.cc: New. * theo/experimental/depeche/row_mm.cc: New. * theo/experimental/depeche/row.cc: New. icdar/2009/pscomp/iz.cc | 174 +++++++++++++++++++++ icdar/2009/pscomp/rect_filter.cc | 165 ++++++++++++++++++++ theo/experimental/depeche/col.cc | 286 +++++++++++++++++++++++++++++++++++ theo/experimental/depeche/homogen.cc | 43 +++++ theo/experimental/depeche/row.cc | 117 ++++++++++++++ theo/experimental/depeche/row_mm.cc | 96 +++++++++++ 6 files changed, 881 insertions(+) Index: icdar/2009/pscomp/iz.cc --- icdar/2009/pscomp/iz.cc (revision 0) +++ icdar/2009/pscomp/iz.cc (revision 0) @@ -0,0 +1,174 @@ + +// From mln/canvas/distance_geodesic.hh + +# include <mln/core/concept/image.hh> +# include <mln/core/concept/neighborhood.hh> +# include <mln/core/routine/duplicate.hh> +# include <mln/core/site_set/p_queue_fast.hh> +# include <queue> +# include <mln/data/fill.hh> +# include <mln/extension/adjust_fill.hh> + + +// Local. + +#include <map> +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/value/int_u8.hh> +#include <mln/io/pbm/load.hh> +#include <mln/io/pgm/save.hh> +#include <mln/debug/println.hh> +#include <mln/data/saturate.hh> + +#include <mln/labeling/blobs.hh> +#include <mln/labeling/value.hh> + + + + +namespace mln +{ + + + // From mln/canvas/distance_geodesic.hh + // and mln/transform/internal/influence_zone_functor.hh + // and mln/transform/influence_zone_geodesic.hh + + + template <typename I, typename N> + std::map< std::pair<mln_value(I),mln_value(I)>, unsigned > + distances(// in: + const I& input, const N& nbh, + // out: + mln_ch_value(I, unsigned)& dmap, + mln_concrete(I)& iz) + { + trace::entering("canvas::impl::generic::distance_geodesic"); + + typedef mln_value(I) L; + std::map< std::pair<L,L>, unsigned > dist; // NEW + + const unsigned max = mln_max(unsigned); + typedef mln_site(I) P; + p_queue_fast q; + + // Initialization. + { + iz = duplicate(input); // <-- init + + data::fill(dmap, max); + + mln_piter(I) p(input.domain()); + mln_niter(N) n(nbh, p); + for_all(p) + if (input(p) != 0) // <-- inqueue_p_wrt_input_p + { + ; // <-- init_p + dmap(p) = 0; + for_all(n) + if (input.domain().has(n) && + input(n) == 0) // <-- inqueue_p_wrt_input_n + { + q.push(p); + break; + } + } + } + + // Propagation. + { + P p; + mln_niter(N) n(nbh, p); + while (! q.is_empty()) + { + p = q.pop_front(); + if (dmap(p) == max) + { + // Saturation so stop. + q.clear(); + break; + } + for_all(n) + { + if (! input.domain().has(n)) + continue; + if (dmap(n) == max) + { + dmap(n) = dmap(p) + 1; + iz(n) = iz(p); // <- process + q.push(n); + } + else + { + if (iz(n) != iz(p)) + { + L l1 = iz(n), l2 = iz(p); + if (l1 > l2) + std::swap(l1, l2); + unsigned& d_ = dist[std::make_pair(l1,l2)]; + unsigned d12 = dmap(p) + dmap(n) + 1; + if (d_ == 0 || d12 < d_) + d_ = d12; + } + } + } + } + } + + return dist; + } + + +} // mln + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + + typedef unsigned L; + + image2d<bool> input; + io::pbm::load(input, argv[1]); + + L n_labels; + image2d<L> lab = labeling::value(input, true, c8(), n_labels); + std::cout << "n labels = " << n_labels << std::endl; + + + image2d<unsigned> dmap(input.domain()); + image2d<L> iz(input.domain()); + + typedef std::map< std::pair<L,L>, unsigned > map_t; + map_t d = distances(lab, c8(), dmap, iz); + + io::pgm::save(data::saturate(value::int_u8(), dmap), "dmap.pgm"); + + // debug::println("lab = ", lab); + std::cout << "map size = " << d.size() << std::endl; + + +// { +// // Compute statistics. +// std::map<unsigned, unsigned> h; +// for (map_t::const_iterator i = d.begin(); +// i != d.end(); ++i) +// ++h[i->second]; + +// for (std::map<unsigned, unsigned>::const_iterator i = h.begin(); +// i != h.end(); ++i) +// std::cout << i->first << " " << i->second << std::endl; +// } + + +// { +// // Print: d(label1, label2) = shortest distance +// for (map_t::const_iterator i = d.begin(); +// i != d.end(); ++i) +// std::cout << "d(" << i->first.first << ", " << i->first.second << ") = " +// << i->second << std::endl; +// } + +} Index: icdar/2009/pscomp/rect_filter.cc --- icdar/2009/pscomp/rect_filter.cc (revision 0) +++ icdar/2009/pscomp/rect_filter.cc (revision 0) @@ -0,0 +1,165 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/value/int_u8.hh> +#include <mln/io/pbm/load.hh> +#include <mln/io/pgm/save.hh> +#include <mln/debug/println.hh> + +#include <mln/transform/distance_geodesic.hh> +#include <mln/accu/shape/bbox.hh> +#include <mln/morpho/closing/algebraic.hh> +#include <mln/morpho/watershed/flooding.hh> +#include <mln/morpho/watershed/superpose.hh> + +#include <mln/core/routine/duplicate.hh> +#include <mln/data/convert.hh> +#include <mln/pw/all.hh> +#include <mln/io/pbm/save.hh> +#include <mln/io/ppm/save.hh> + + + + +namespace mln +{ + + struct pair_and + { + pair_and() + {} + pair_and(unsigned first, unsigned second) + : first(first), + second(second) + {} +// bool operator<(const pair_and& other) const +// { +// return first < other.first && second < other.second; +// } + unsigned first, second; + }; + + + bool operator<(const pair_and& lhs, const pair_and& rhs) + { + return lhs.first < rhs.first || lhs.second < rhs.second; + } + + + struct rectangle_and; + + + namespace trait + { + + template <> + struct accumulator_< rectangle_and > + { + typedef accumulator::has_untake::no has_untake; + typedef accumulator::has_set_value::no has_set_value; + typedef accumulator::has_stop::no has_stop; + typedef accumulator::when_pix::use_p when_pix; + }; + + } // end of namespace mln::trait + + + struct rectangle_and : public accu::internal::base< pair_and, rectangle_and > + { + typedef point2d argument; + + rectangle_and() + { + } + + void init() + { + bb_.init(); + } + void take_as_init_(const point2d& p) + { + bb_.take_as_init_(p); + } + void take(const point2d& p) + { + bb_.take(p); + } + void take(const rectangle_and& other) + { + bb_.take(other.bb_); + } + + pair_and to_result() const + { + pair_and tmp(bb_.to_result().len(0), + bb_.to_result().len(1)); + return tmp; + } + + bool is_valid() const + { + return true; + } + + protected: + accu::shape::bbox<point2d> bb_; + }; + + +} // mln + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm w h output.ppm" << std::endl; + std::abort(); +} + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + using value::rgb8; + + if (argc != 5) + usage(argv); + + image2d<bool> input; + io::pbm::load(input, argv[1]); + + typedef value::int_u8 D; + + image2d<D> dmap; + dmap = transform::distance_geodesic(input, + c8(), + mln_max(D)); + io::pgm::save(dmap, "temp_dmap.pgm"); + + int w = std::atoi(argv[2]), h = std::atoi(argv[3]); + + pair_and lambda(w, h); + image2d<D> clo = morpho::closing::algebraic(dmap, + c8(), + rectangle_and(), + lambda); + + io::pgm::save(clo, "temp_clo.pgm"); + + typedef unsigned L; + L n_basins; + image2d<L> ws = morpho::watershed::flooding(clo, c8(), n_basins); + std::cout << "n basins = " << n_basins<< std::endl; + + { + image2d<rgb8> out = data::convert(rgb8(), dmap); + out = morpho::watershed::superpose(out, ws, rgb8(255,0,0)); + io::ppm::save(out, argv[4]); + } + +// { +// image2d<bool> out(input.domain()); +// out = duplicate((pw::value(ws) == pw::cst(0)) | input.domain()); +// io::pbm::save(out, argv[2]); +// } + +} Index: theo/experimental/depeche/homogen.cc --- theo/experimental/depeche/homogen.cc (revision 0) +++ theo/experimental/depeche/homogen.cc (revision 0) @@ -0,0 +1,43 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/morpho/attribute/height.hh> +#include <mln/morpho/closing/leveling.hh> + +#include <mln/arith/minus.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] << " input.pgm h output.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + + if (argc != 4) + usage(argv); + + image2d<int_u8> input; + io::pgm::load(input, argv[1]); + + int i = std::atoi(argv[2]); + int_u8 h = i; + + morpho::attribute::height< image2d<int_u8> > acc; + image2d<int_u8> clo = morpho::closing::leveling(input, c4(), + acc, h); + io::pgm::save(clo, "tmp.pgm"); + arith::minus_inplace(clo, input); + + io::pgm::save(clo, argv[3]); +} Index: theo/experimental/depeche/col.cc --- theo/experimental/depeche/col.cc (revision 0) +++ theo/experimental/depeche/col.cc (revision 0) @@ -0,0 +1,286 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> + +#include <mln/core/image/image1d.hh> +#include <mln/core/alias/neighb1d.hh> + +#include <mln/fun/v2v/projection.hh> +#include <mln/core/image/dmorph/unproject_image.hh> +#include <mln/core/image/dmorph/image_if.hh> +#include <mln/pw/value.hh> + +#include <mln/accu/stat/mean.hh> +#include <mln/accu/image/init.hh> +#include <mln/accu/image/take.hh> +#include <mln/accu/image/to_result.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/plot/save.hh> + +#include <mln/linear/gaussian_1d.hh> +#include <mln/labeling/regional_maxima.hh> +#include <mln/data/convert.hh> +#include <mln/io/ppm/save.hh> + +#include <mln/data/fill.hh> +#include <mln/debug/println.hh> +#include <mln/accu/stat/median_h.hh> + +#include <mln/morpho/closing/volume.hh> + + + +namespace mln +{ + + + float get_approx_gap(const util::array<unsigned>& line, unsigned delta) + { + accu::stat::median_h< value::int_u<12> > med; + const unsigned n = line.nelements() - delta; + for (unsigned i = 0; i < n; ++i) + med.take(line[i + delta] - line[i]); + + std::cout << "delta = " << delta << std::endl; + std::cout << med.histo() << std::endl; + std::cout << "med = " << med.to_result() << std::endl; + + return float(med.to_result()) / delta; + } + + + void refine_gap(const util::array<unsigned>& line, unsigned delta, float& gap) + { + std::cout << "gap = " << gap << std::endl; + unsigned count = 0; + + accu::stat::mean<float> mean; + const unsigned n = line.nelements() - delta; + for (unsigned i = 0; i < n; ++i) + { + float g = line[i + delta] - line[i]; + if (g / delta > gap - .2 && g / delta < gap + .2) + { + mean.take(g); + ++count; + } + } + std::cout << "count = " << count << " total = " << n << std::endl; + + gap = mean.to_result() / delta; + std::cout << "gap = " << gap << std::endl; + } + + + util::array<unsigned> + select_lines(const util::array<unsigned>& line, float gap) + { + std::set<unsigned> s; + const unsigned n = line.nelements() - 1; + for (unsigned i = 0; i < n; ++i) + { + float g = line[i + 1] - line[i]; + if (g > gap - 2 && g < gap + 2) + { + s.insert(line[i]); + s.insert(line[i + 1]); + } + } + + std::vector<unsigned> v(s.begin(), s.end()); + util::array<unsigned> out; + out.hook_std_vector_() = v; + + return out; + } + + + util::array<unsigned> + image_2_line(const image1d<double>& input) + { + image1d<bool> is_max(input.domain()); + unsigned n; + data::fill(is_max, + pw::value(labeling::regional_maxima(input, c2(), n)) | input.domain()); + std::cout << "n = " << n << std::endl; + + util::array<unsigned> line; + { + mln_piter_(box1d) p(input.domain()); + for_all(p) + if (is_max(p)) + line.append(p.ind()); + } + + return line; + } + + + util::array<unsigned> + analyze(const util::array<unsigned>& line, float& gap, bool& ok) + { + // FIXME: The value of delta in 'get_approx_gap' and in + // 'refine_gap' should change w.r.t. to the nature of input data. + gap = get_approx_gap(line, 10); // FIXME: 10 / 3 + float rough_gap = gap; + refine_gap(line, 20, gap); // FIXME: 20 / 4 + float finer_gap = gap; + + ok = std::abs(finer_gap - rough_gap) < 1; + + return select_lines(line, gap); + } + + + void draw(const image2d<value::int_u8>& input, + const util::array<unsigned>& line, + value::rgb8 color, + const std::string& filename) + { + image2d<value::rgb8> output = data::convert(value::rgb8(), input); + const int nrows = input.nrows(); + + for (unsigned i = 0; i < line.nelements(); ++i) + { + int col = line[i]; + for (int row = 0; row < nrows; ++row) + output.at_(row, col) = color; + } + + io::ppm::save(output, filename); +} + + +} // mln + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm lambda h.txt output.ppm" << std::endl; + std::cerr << "hint: lambda = 50; delta = 10 / 20 otherwise 3 / 4" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + using value::rgb8; + + if (argc != 5) + usage(argv); + + image2d<int_u8> input; + io::pgm::load(input, argv[1]); + box2d b = input.domain(); + + + // h computing + + typedef accu::stat::mean<int_u8, unsigned, double> A; + + image1d<A> hmean(b.ncols()); + accu::image::init(hmean); + + fun::v2v::projection<point2d, 0> hproj; + accu::image::take(unproject(hmean, b, hproj).rw(), input); + + image1d<double> h = accu::image::to_result(hmean); + io::plot::save(h, argv[3]); + + + // h cleaning + + h = linear::gaussian_1d(h, 1.0, 255); + io::plot::save(h, "h_g.txt"); + + int lambda = std::atoi(argv[2]); + h = morpho::closing::volume(h, c2(), lambda); + io::plot::save(h, "h_gc.txt"); + + + + // analyzing + + util::array<unsigned> line = image_2_line(h); + draw(input, line, value::rgb8(255,0,0), "temp_h.ppm"); + + float gap; + bool ok; + line = analyze(line, gap, ok); + + draw(input, line, value::rgb8(255,0,0), "temp_h_sel.ppm"); + + if (! ok) + { + std::cerr << "analyze failed: abort!" << std::endl; + std::abort(); + } + + + + // getting a math model + float o; + + { + accu::stat::mean<float> me; + // col = r * gap where r = o + i (with offset o and integer i) + // col = gap * i + orig (orig = o * gap) + for (unsigned l = 0; l < line.nelements(); ++l) + { + float r = float(line[l]) / gap; + int i = int(r + 0.49999); + float o = r - float(i); + me.take(o); + std::cout << line[l] << " = " << (gap * o) << " + " < line_; + for (unsigned l = 0; l < line.nelements(); ++l) + { + int i = int(float(line[l]) / gap - o + 0.49999); + line_.append(int((o + i) * gap + 0.49999)); + } + + std::cout << std::endl; + + // over-display + draw(input, line, value::rgb8(255,0,0), "temp_h_found.ppm"); + + } + + + // drawing matrix + + { + image2d<rgb8> output = data::convert(rgb8(), input); + const int nrows = input.nrows(); + int ncols = input.ncols(); + + int n_max = int(float(ncols) / gap - o + 3); + for (int i = 0; i < n_max; ++i) + { + float col_ = (o + i) * gap; + int col = int(col_ + 0.49999); + if (col < 0) + continue; + if (col > ncols - 1) + break; + for (int row = 0; row < nrows; ++row) + output.at_(row, col) = rgb8(0,255,0); + } + + io::ppm::save(output, argv[4]); + } + + + +} Index: theo/experimental/depeche/row_mm.cc --- theo/experimental/depeche/row_mm.cc (revision 0) +++ theo/experimental/depeche/row_mm.cc (revision 0) @@ -0,0 +1,96 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> + +#include <mln/core/image/image1d.hh> +#include <mln/core/alias/neighb1d.hh> + +#include <mln/fun/v2v/projection.hh> +#include <mln/core/image/dmorph/unproject_image.hh> +#include <mln/core/image/dmorph/image_if.hh> +#include <mln/pw/value.hh> + +#include <mln/accu/stat/mean.hh> +#include <mln/accu/image/init.hh> +#include <mln/accu/image/take.hh> +#include <mln/accu/image/to_result.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/pgm/save.hh> +#include <mln/io/plot/save.hh> + +#include <mln/value/rgb8.hh> +#include <mln/io/ppm/save.hh> +// #include <mln/draw/line.hh> +// #include <mln/literal/colors.hh> + +#include <mln/morpho/closing/volume.hh> +#include <mln/morpho/opening/volume.hh> + +#include <mln/labeling/regional_minima.hh> +#include <mln/labeling/regional_maxima.hh> +#include <mln/data/convert.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm lambda output.pgm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + using value::rgb8; + + if (argc != 4) + usage(argv); + + image2d<int_u8> input; + io::pgm::load(input, argv[1]); + box2d b = input.domain(); + + int lambda = std::atoi(argv[2]); + + typedef accu::stat::mean<int_u8, unsigned, int_u8> A; + + image1d<A> hmean(b.nrows()); + accu::image::init(hmean); + + fun::v2v::projection<point2d, 1> hproj; + accu::image::take(unproject(hmean, b, hproj).rw(), input); + + image1d<int_u8> h = accu::image::to_result(hmean); + io::plot::save(h, "temp_h0.txt"); + + h = morpho::closing::volume(h, c2(), lambda); + io::plot::save(h, "temp_h1.txt"); + + h = morpho::opening::volume(h, c2(), lambda); + io::plot::save(h, "temp_h2.txt"); + + + { + int_u8 n; + image1d<int_u8> + lab_bg = labeling::regional_maxima(h, c2(), n), + lab_fg = labeling::regional_minima(h, c2(), n); + + image2d<rgb8> cool = data::convert(rgb8(), input); + mln_piter_(box2d) p(cool.domain()); + for_all(p) + { + if (lab_bg.at_(p.row()) != 0) + cool(p).red() = 255; + if (lab_fg.at_(p.row()) != 0) + cool(p).green() = 255; + } + io::ppm::save(cool, "temp_cool.ppm"); + } + + // io::pgm::save(output, argv[2]); +} Index: theo/experimental/depeche/row.cc --- theo/experimental/depeche/row.cc (revision 0) +++ theo/experimental/depeche/row.cc (revision 0) @@ -0,0 +1,117 @@ +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> + +#include <mln/core/image/image1d.hh> +#include <mln/core/alias/neighb1d.hh> + +#include <mln/fun/v2v/projection.hh> +#include <mln/core/image/dmorph/unproject_image.hh> +#include <mln/core/image/dmorph/image_if.hh> +#include <mln/pw/value.hh> + +#include <mln/accu/stat/mean.hh> +#include <mln/accu/image/init.hh> +#include <mln/accu/image/take.hh> +#include <mln/accu/image/to_result.hh> + +#include <mln/value/int_u8.hh> +#include <mln/io/pgm/load.hh> +#include <mln/io/pgm/save.hh> +#include <mln/io/plot/save.hh> + +#include <mln/value/rgb8.hh> +#include <mln/io/ppm/save.hh> + +#include <mln/linear/gaussian_1d.hh> +#include <mln/data/fill.hh> +#include <mln/data/convert.hh> + +#include <mln/labeling/regional_minima.hh> +#include <mln/draw/line.hh> +#include <mln/literal/colors.hh> + +#include <mln/accu/stat/median_h.hh> + + + +void usage(char* argv[]) +{ + std::cerr << "usage: " << argv[0] << " input.pgm output.ppm" << std::endl; + abort(); +} + + + +int main(int argc, char* argv[]) +{ + using namespace mln; + using value::int_u8; + using value::rgb8; + + if (argc != 3) + usage(argv); + + image2d<int_u8> input; + io::pgm::load(input, argv[1]); + box2d b = input.domain(); + + typedef accu::stat::mean<int_u8, unsigned, double> A; + + image1d<A> hmean(b.nrows()); + accu::image::init(hmean); + + fun::v2v::projection<point2d, 1> hproj; + accu::image::take(unproject(hmean, b, hproj).rw(), input); + + image1d<double> hmean_d = accu::image::to_result(hmean); + io::plot::save(hmean_d, "temp_h.txt"); + + hmean_d = linear::gaussian_1d(hmean_d, 5, 255); + io::plot::save(hmean_d, "temp_hg.txt"); + + io::plot::save(hmean, argv[2]); + + int_u8 n; + image1d<int_u8> lab = labeling::regional_minima(hmean_d, c2(), n); + // io::plot::save(lab, "temp_lab.txt"); + + + { + image2d<rgb8> cool = data::convert(rgb8(), input); + mln_piter_(box1d) p(lab.domain()); + for_all(p) + if (lab(p) != 0) + draw::line(cool, + point2d(p.ind(), 0), + point2d(p.ind(), b.ncols() -1), + literal::red); + io::ppm::save(cool, argv[2]); + } + +// accu::stat::median_h<int_u8> med; +// { +// double min = 255; +// unsigned row_min; +// int last = -1; +// mln_piter_(box1d) p(lab.domain()); +// for_all(p) +// { +// if (lab(p) == 0) +// continue; +// if (hmean_d(p) < min) +// { +// min = hmean_d(p); +// row_min = p.ind(); +// } +// if (last == -1) +// last = p.ind(); +// else +// { +// med.take(p.ind() - last); +// last = p.ind(); +// } +// } +// std::cout << med << ' ' << row_min << std::endl; +// } + +}

1 0

r4329: Fixes about IZ method
by Edwin Carlinet 24 Jul '09

24 Jul '09

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox ChangeLog: 2009-07-24 Edwin Carlinet <carlinet(a)lrde.epita.fr> Fixes about IZ method. * edwin/exec/zi.cc: Some tries... * edwin/exec/zi.hh: Real distance between components. --- zi.cc | 106 +++++++++++++++++++++++++++++++++++---------- zi.hh | 153 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 236 insertions(+), 23 deletions(-) Index: trunk/milena/sandbox/edwin/exec/zi.hh =================================================================== --- trunk/milena/sandbox/edwin/exec/zi.hh (revision 0) +++ trunk/milena/sandbox/edwin/exec/zi.hh (revision 4329) @@ -0,0 +1,153 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of Olena. +// +// Olena is free software: you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation, version 2 of the License. +// +// Olena 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 Olena. If not, see <http://www.gnu.org/licenses/>. +// +// As a special exception, you may use this file as part of a free +// software project 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 ZI_HH +# define ZI_HH + + +// From mln/canvas/distance_geodesic.hh + +# include <mln/core/concept/image.hh> +# include <mln/core/concept/neighborhood.hh> +# include <mln/core/routine/duplicate.hh> +# include <mln/core/site_set/p_queue_fast.hh> +# include <queue> +# include <mln/data/fill.hh> +# include <mln/extension/adjust_fill.hh> + + +// Local. + +#include <map> +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/value/int_u8.hh> +#include <mln/io/pbm/load.hh> +#include <mln/labeling/blobs.hh> +#include <mln/debug/println.hh> + + + + +namespace mln +{ + + // Theo's code + + // From mln/canvas/distance_geodesic.hh + // and mln/transform/internal/influence_zone_functor.hh + // and mln/transform/influence_zone_geodesic.hh + + + template <typename I, typename N> + std::map< std::pair<mln_value(I),mln_value(I)>, unsigned > + distances(// in: + const I& input, const N& nbh, + // out: + mln_ch_value(I, unsigned)& dmap, + mln_concrete(I)& iz) + { + trace::entering("canvas::impl::generic::distance_geodesic"); + + typedef mln_value(I) L; + std::map< std::pair<L,L>, unsigned > dist; // NEW + + const unsigned max = mln_max(unsigned); + typedef mln_site(I) P; + p_queue_fast q; + + // Initialization. + { + iz = duplicate(input); // <-- init + + data::fill(dmap, max); + + mln_piter(I) p(input.domain()); + mln_niter(N) n(nbh, p); + for_all(p) + if (input(p) != 0) // <-- inqueue_p_wrt_input_p + { + ; // <-- init_p + dmap(p) = 0; + for_all(n) + if (input.domain().has(n) && + input(n) == 0) // <-- inqueue_p_wrt_input_n + { + q.push(p); + break; + } + } + } + + // Propagation. + { + P p; + mln_niter(N) n(nbh, p); + while (! q.is_empty()) + { + p = q.pop_front(); + if (dmap(p) == max) + { + // Saturation so stop. + q.clear(); + break; + } + for_all(n) + { + if (! input.domain().has(n)) + continue; + if (dmap(n) == max) + { + dmap(n) = dmap(p) + 1; + iz(n) = iz(p); // <- process + q.push(n); + } + else + { + if (iz(n) != iz(p)) + { + L l1 = iz(n), l2 = iz(p); + if (l1 > l2) + std::swap(l1, l2); + unsigned& d_ = dist[std::make_pair(l1,l2)]; + unsigned d12 = dmap(p) + dmap(n) + 1; + if (d_ == 0 || d12 < d_) + d_ = d12; + } + } + } + } + } + + return dist; + } + +} // mln + +# ifndef MLN_INCLUDE_ONLY + +# endif // ! MLN_INCLUDE_ONLY + +#endif // ! ZI_HH Index: trunk/milena/sandbox/edwin/exec/zi.cc =================================================================== --- trunk/milena/sandbox/edwin/exec/zi.cc (revision 4328) +++ trunk/milena/sandbox/edwin/exec/zi.cc (revision 4329) @@ -33,6 +33,7 @@ #include <mln/value/int_u8.hh> #include <mln/value/label_16.hh> #include <mln/value/label_8.hh> +#include <mln/data/convert.hh> #include <mln/util/graph.hh> #include <mln/io/pbm/load.hh> @@ -50,10 +51,13 @@ #include <mln/make/edge_image.hh> #include <mln/make/vertex_image.hh> +#include <mln/morpho/closing/height.hh> + #include <mln/math/max.hh> #include <mln/norm/l1.hh> #include "color_distance.hh" +#include "zi.hh" #include <iostream> namespace mln @@ -94,6 +98,7 @@ } + // distance entre les centres de masses. template <typename P> inline value::int_u8 @@ -103,6 +108,7 @@ } + // distance entre les boites englobantes. inline value::int_u8 distance_box(const box<point2d>& b1, const box<point2d>& b2) @@ -125,6 +131,35 @@ return math::max(math::max(w_dist, h_dist), 0); } + + // distance geodesic entre les composantes. + template <typename G, typename L> + struct distance_t : Function_v2v< distance_t<G, L> > + { + typedef unsigned result; + typedef util::vertex_id_t V; + typedef util::edge_id_t E; + + distance_t(const std::map< std::pair<L, L>, unsigned >& d_, + const G& graph) + : d(d_), + g(graph) + { + } + + unsigned + operator () (const E& e_id) const + { + typename G::edge_t e = g.edge(e_id); + std::pair<L, L> p((value::label_8)e.v1(), (value::label_8)e.v2()); + return d.find(p)->second; + } + + private: + const std::map< std::pair<L, L>, unsigned >& d; + const G& g; + }; + } @@ -147,12 +182,13 @@ using namespace mln; using value::int_u8; - if (argc < 3) + if (argc < 4) usage(argv); const char* finput = argv[1]; const char* fsource = argv[2]; - const char* foutput = argc > 3 ? argv[3] : "zi.pgm"; + const unsigned lambda = atoi(argv[3]); + const char* foutput = argc > 4 ? argv[4] : "zi.pgm"; // Image loadin' image2d<bool> input; @@ -167,11 +203,17 @@ typedef image2d<L> I; I labels, iz, out; + image2d<unsigned> dmap; L nlabel; + typedef std::map< std::pair<L,L>, unsigned > map_t; labels = labeling::blobs(input, c4(), nlabel); - iz = transform::influence_zone_geodesic(labels, c4()); + initialize(iz, input); + initialize(dmap, input); + + map_t d = distances(labels, c4(), dmap, iz); + io::pgm::save(data::convert(int_u8(), dmap), "dmap.pgm"); io::pgm::save(iz, foutput); // I.Z Graph @@ -179,29 +221,33 @@ // Valuation of color distance - // util::array<value::rgb8> mean_colors; - // convert::from_to(labeling::compute(accu::stat::mean<value::rgb8>(), source, labels, nlabel), - // mean_colors); + /* + util::array<value::rgb8> mean_colors; + convert::from_to(labeling::compute(accu::stat::mean<value::rgb8>(), source, labels, nlabel), + mean_colors); - // typedef vertex_image<void, value::rgb8, util::graph> V; - // V v_ima = make::vertex_image(izg, mean_colors); - - // typedef edge_image<void, value::int_u8, util::graph> E; - // E e_ima = make::edge_image(v_ima, convert::tofun(dist_mean)); + typedef vertex_image<void, value::rgb8, util::graph> V; + V v_ima = make::vertex_image(izg, mean_colors); + typedef edge_image<void, value::int_u8, util::graph> E; + E e_ima = make::edge_image(v_ima, convert::tofun(dist_mean)); + */ // Valuation of geometric distance - // util::array<mln_psite_(I)> mass_centers; -// convert::from_to(labeling::compute(accu::center<mln_psite_(I)>(), labels, nlabel), -// mass_centers); + /* + util::array<mln_psite_(I)> mass_centers; + convert::from_to(labeling::compute(accu::center<mln_psite_(I)>(), labels, nlabel), + mass_centers); -// typedef vertex_image<void, mln_psite_(I), util::graph> V; -// V v_ima = make::vertex_image(izg, mass_centers); + typedef vertex_image<void, mln_psite_(I), util::graph> V; + V v_ima = make::vertex_image(izg, mass_centers); -// typedef edge_image<void, value::int_u8, util::graph> E; -// E e_ima = make::edge_image(v_ima, convert::tofun(distance<mln_psite_(I)>)); + typedef edge_image<void, value::int_u8, util::graph> E; + E e_ima = make::edge_image(v_ima, convert::tofun(distance<mln_psite_(I)>)); + */ // Valuation of distance between bounding boxes + /* util::array< box<mln_psite_(I)> > bboxes; convert::from_to(labeling::compute(accu::shape::bbox<mln_psite_(I)>(), labels, nlabel), bboxes); @@ -211,15 +257,23 @@ typedef edge_image<void, value::int_u8, util::graph> E; E e_ima = make::edge_image(v_ima, convert::tofun(distance_box)); + */ + + // Valuation of components geodesic distance. + typedef edge_image<void, unsigned, util::graph> E; + E e_ima = make::edge_image(izg, distance_t<util::graph, value::label_8>(d, izg)); + // Closing + e_ima = morpho::closing::height(e_ima, E::nbh_t (), lambda); + // WST. - typedef mln_ch_value_(V, L) v_ima_labels_t; - v_ima_labels_t v_ima_labels; - initialize(v_ima_labels, v_ima); + typedef vertex_image<void, L, util::graph> V; + p_vertices<util::graph> pv(izg); + V v_ima_labels(pv); - typedef mln_ch_value_(E, L) e_ima_wst_t; + typedef edge_image<void, L, util::graph> e_ima_wst_t; L nbasins; e_ima_wst_t e_ima_wst = morpho::watershed::flooding(e_ima, E::nbh_t (), nbasins); @@ -240,13 +294,19 @@ // Relabeling util::array<L> tr(nlabel); - mln_piter_(V) v(v_ima.domain()); + mln_piter_(V) v(v_ima_labels.domain()); for_all(v) { std::cout << v.id() << " : " << v_ima_labels(v) << std::endl; tr[v.id()] = v_ima_labels(v); } + //print distance + for (map_t::const_iterator it = d.begin(); it != d.end(); ++it) + std::cout << it->first.first << ", " + << it->first.second << " -> " + << it->second << std::endl; + labeling::relabel_inplace(iz, nlabel, tr); io::pgm::save(iz, "zi_wst.pgm");

1 0

milena r4328: Minor fixes linked to graph
by Edwin Carlinet 24 Jul '09

24 Jul '09

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena ChangeLog: 2009-07-24 Edwin Carlinet <carlinet(a)lrde.epita.fr> Minor fixes linked to graph. * core/site_set/p_vertices.hh: Fix bug in constructor. * make/edge_image.hh: Add overload to compute edge_image from function v2v. * util/internal/graph_base.hh: Make typedef visibility to public. --- core/site_set/p_vertices.hh | 1 - make/edge_image.hh | 31 +++++++++++++++++++++++++++++++ util/internal/graph_base.hh | 2 +- 3 files changed, 32 insertions(+), 2 deletions(-) Index: trunk/milena/mln/core/site_set/p_vertices.hh =================================================================== --- trunk/milena/mln/core/site_set/p_vertices.hh (revision 4327) +++ trunk/milena/mln/core/site_set/p_vertices.hh (revision 4328) @@ -218,7 +218,6 @@ template <typename G, typename F> inline p_vertices<G,F>::p_vertices() - : f_(0) { } Index: trunk/milena/mln/make/edge_image.hh =================================================================== --- trunk/milena/mln/make/edge_image.hh (revision 4327) +++ trunk/milena/mln/make/edge_image.hh (revision 4328) @@ -54,6 +54,16 @@ mln::edge_image<void,V,G> edge_image(const Graph<G>& g, const fun::i2v::array<V>& fv); + /// Construct an edge image. + /// + /// \param[in] g A graph + /// \param[in] fv A function mapping edge ids to values. + /// + /// \return an edge image. + // + template <typename FV, typename G> + mln::edge_image<void, mln_result(FV), G> + edge_image(const Graph<G>& g, const Function_v2v<FV>& fv); /// Construct an edge image. @@ -122,6 +132,27 @@ return ima; } + template <typename FV, typename G> + mln::edge_image<void,mln_result(FV),G> + edge_image(const Graph<G>& g_, + const Function_v2v<FV>& fv) + { + trace::entering("make::edge_image"); + const G& g = exact(g_); + const FV& f = exact(fv); + mln_precondition(g.is_valid()); + + p_edges<G> pe(g); + typedef mln::edge_image<void,mln_result(FV),G> ima_t; + ima_t ima(pe); + + mln_piter(ima_t) e(ima.domain()); + for_all(e) + ima(e) = f(e.id()); + + trace::exiting("make::edge_image"); + return ima; + } template <typename FP, typename FV, typename G> Index: trunk/milena/mln/util/internal/graph_base.hh =================================================================== --- trunk/milena/mln/util/internal/graph_base.hh (revision 4327) +++ trunk/milena/mln/util/internal/graph_base.hh (revision 4328) @@ -64,7 +64,7 @@ class graph_base : public Graph<E> { - protected: + public: /// The type of a vertex. typedef util::vertex<E> vertex_t; /// The type of an edge.

1 0

4327: doc/Doxyfile.in: Add new example patterns.
by Guillaume Lazzara 24 Jul '09

24 Jul '09

--- milena/ChangeLog | 4 ++++ milena/doc/Doxyfile.in | 3 ++- 2 files changed, 6 insertions(+), 1 deletions(-) diff --git a/milena/ChangeLog b/milena/ChangeLog index c1148cf..be74dc5 100644 --- a/milena/ChangeLog +++ b/milena/ChangeLog @@ -1,5 +1,9 @@ 2009-07-17 Guillaume Lazzara <lazzara(a)lrde.epita.fr> + * doc/Doxyfile.in: Add new example patterns. + +2009-07-17 Guillaume Lazzara <lazzara(a)lrde.epita.fr> + * doc/Doxyfile.in: Enable the Seach engine and set the example name patterns. diff --git a/milena/doc/Doxyfile.in b/milena/doc/Doxyfile.in index 00b1886..94c0c9b 100644 --- a/milena/doc/Doxyfile.in +++ b/milena/doc/Doxyfile.in @@ -111,7 +111,8 @@ EXAMPLE_PATH = @top_srcdir@/milena/doc/examples \ @top_srcdir@/milena/doc/outputs \ @top_srcdir@/milena/doc/examples/split \ @top_srcdir@/milena/doc/outputs/split -EXAMPLE_PATTERNS = *.cc +EXAMPLE_PATTERNS = *.cc \ + *.cc.raw EXAMPLE_RECURSIVE = NO IMAGE_PATH = @top_srcdir@/milena/doc/img \ @top_srcdir@/milena/doc/figures \ -- 1.5.6.5

1 0

4326: src/Makefile.am: Handle tesseract dependency.
by Guillaume Lazzara 24 Jul '09

24 Jul '09

--- scribo/ChangeLog | 12 ++++++++---- scribo/src/Makefile.am | 14 ++++++-------- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/scribo/ChangeLog b/scribo/ChangeLog index ba7f8c1..2e8acb0 100644 --- a/scribo/ChangeLog +++ b/scribo/ChangeLog @@ -1,3 +1,7 @@ +2009-07-24 Guillaume Lazzara <lazzara(a)lrde.epita.fr> + + * src/Makefile.am: Handle tesseract dependency. + 2009-07-13 Roland Levillain <roland(a)lrde.epita.fr> * src/preprocessing/Makefile.am: Remove a trailing blank line. @@ -8,7 +12,7 @@ * filter/thick_objects.hh: Fix. -2009-06-39 Guillaume Lazzara <lazzara(a)lrde.epita.fr> +2009-06-30 Guillaume Lazzara <lazzara(a)lrde.epita.fr> Update Scribo. @@ -21,15 +25,15 @@ * text/recognition.hh: may store the recognized text into a file. -2009-06-39 Guillaume Lazzara <lazzara(a)lrde.epita.fr> +2009-06-30 Guillaume Lazzara <lazzara(a)lrde.epita.fr> * tests/preprocessing/unskew.cc: fix test. -2009-06-39 Guillaume Lazzara <lazzara(a)lrde.epita.fr> +2009-06-30 Guillaume Lazzara <lazzara(a)lrde.epita.fr> * preprocessing/unskew.hh: Fix an ambiguity. -2009-06-39 Guillaume Lazzara <lazzara(a)lrde.epita.fr> +2009-06-30 Guillaume Lazzara <lazzara(a)lrde.epita.fr> Update calls to geom::rotate. diff --git a/scribo/src/Makefile.am b/scribo/src/Makefile.am index 381c567..a7b6289 100644 --- a/scribo/src/Makefile.am +++ b/scribo/src/Makefile.am @@ -62,11 +62,9 @@ table_rebuild_rank_SOURCES = table_rebuild_rank.cc text_in_photo_SOURCES = text_in_photo.cc thin_bboxes_SOURCES = thin_bboxes.cc -# FIXME: Should be enclosed in an Automake conditional like HAVE_TESSERACT. -#bin_PROGRAMS += recognition - -#recognition_SOURCES = recognition.cc -# FIXME: Do not use $(HOME). -#recognition_CXXFLAGS = -# -I$(HOME)/local/include $(HOME)/local/lib/libtesseract_full.a -#recognition_LDFLAGS = -lpthread +if HAVE_TESSERACT + bin_PROGRAMS += recognition + recognition_SOURCES = recognition.cc + recognition_CPPFLAGS = $(AM_CPPFLAGS) $(TESSERACT_CPPFLAGS) + recognition_LDFLAGS = $(AM_LDFLAGS) $(TESSERACT_LDFLAGS) -lpthread +endif HAVE_TESSERACT -- 1.5.6.5

1 0

4325: configure.ac: Look for tesseract during configure.
by Guillaume Lazzara 24 Jul '09

24 Jul '09

--- ChangeLog | 4 ++++ configure.ac | 4 ++++ 2 files changed, 8 insertions(+), 0 deletions(-) diff --git a/ChangeLog b/ChangeLog index f0b1eba..5ded2bf 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2009-07-24 Guillaume Lazzara <lazzara(a)lrde.epita.fr> + + * configure.ac: Look for tesseract during configure. + 2009-07-17 Guillaume Lazzara <lazzara(a)lrde.epita.fr> * lrde-upload.sh: Update directory names and paths. diff --git a/configure.ac b/configure.ac index ec6e79c..782ddbd 100644 --- a/configure.ac +++ b/configure.ac @@ -165,6 +165,10 @@ OLN_WITH_LIB([TIFF], [tiff.h], [tiff]) OLN_WITH_LIB([GDCM], [gdcm-2.0/gdcmReader.h], [gdcmCommon], [gdcm], [GDCM], [-lgdcmzlib]) +# Tesseract +OLN_WITH_LIB([TESSERACT], [tesseract/baseapi.h], [tesseract_full], [tesseract], [TESSERACT]) + + ## ---------------------------- ## ## (Bundled) trimesh2 library. ## -- 1.5.6.5

1 0

r4319: Minor improvments in IZ method
by Edwin Carlinet 23 Jul '09

23 Jul '09

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox ChangeLog: 2009-07-23 Edwin Carlinet <carlinet(a)lrde.epita.fr> Minor improvments in IZ method. * edwin/exec/zi.cc: Use distance between bbox instead of distance between mass centers. --- zi.cc | 55 ++++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 46 insertions(+), 9 deletions(-) Index: trunk/milena/sandbox/edwin/exec/zi.cc =================================================================== --- trunk/milena/sandbox/edwin/exec/zi.cc (revision 4318) +++ trunk/milena/sandbox/edwin/exec/zi.cc (revision 4319) @@ -97,11 +97,34 @@ template <typename P> inline value::int_u8 - doublelol(const P& p1, const P& p2) + distance(const P& p1, const P& p2) { return convert::to<value::int_u8>(norm::l1_distance(p1.to_vec(), p2.to_vec())); } + + inline + value::int_u8 + distance_box(const box<point2d>& b1, const box<point2d>& b2) + { + const box<point2d> *btop, *bdown, *bleft, *bright; + + btop = b1.pmin().row() < b2.pmin().row() ? &b1 : &b2; + bdown = b1.pmax().row() > b2.pmax().row() ? &b1 : &b2; + bleft = b1.pmin().col() < b2.pmin().col() ? &b1 : &b2; + bright = b1.pmax().col() > b2.pmax().col() ? &b1 : &b2; + + int w_dist = (bright->pmax().col() - bleft->pmin().col()) - + (bright->pmax().col() - bright->pmin().col()) - + (bleft->pmax().col() - bleft->pmin().col()); + + int h_dist = (bdown->pmax().row() - btop->pmin().row()) - + (bdown->pmax().row() - bdown->pmin().row()) - + (btop->pmax().row() - btop->pmin().row()); + + return math::max(math::max(w_dist, h_dist), 0); + } + } @@ -154,7 +177,8 @@ // I.Z Graph util::graph izg = make::influence_zone_adjacency_graph(iz, c4(), nlabel); - // -- Color distance + + // Valuation of color distance // util::array<value::rgb8> mean_colors; // convert::from_to(labeling::compute(accu::stat::mean<value::rgb8>(), source, labels, nlabel), // mean_colors); @@ -164,17 +188,30 @@ // typedef edge_image<void, value::int_u8, util::graph> E; // E e_ima = make::edge_image(v_ima, convert::tofun(dist_mean)); - // -- Color distance - util::array<mln_psite_(I)> mass_centers; - convert::from_to(labeling::compute(accu::center<mln_psite_(I)>(), labels, nlabel), - mass_centers); - typedef vertex_image<void, mln_psite_(I), util::graph> V; - V v_ima = make::vertex_image(izg, mass_centers); + // Valuation of geometric distance + // util::array<mln_psite_(I)> mass_centers; +// convert::from_to(labeling::compute(accu::center<mln_psite_(I)>(), labels, nlabel), +// mass_centers); + +// typedef vertex_image<void, mln_psite_(I), util::graph> V; +// V v_ima = make::vertex_image(izg, mass_centers); + +// typedef edge_image<void, value::int_u8, util::graph> E; +// E e_ima = make::edge_image(v_ima, convert::tofun(distance<mln_psite_(I)>)); + + // Valuation of distance between bounding boxes + util::array< box<mln_psite_(I)> > bboxes; + convert::from_to(labeling::compute(accu::shape::bbox<mln_psite_(I)>(), labels, nlabel), + bboxes); + + typedef vertex_image<void, box<mln_psite_(I)>, util::graph> V; + V v_ima = make::vertex_image(izg, bboxes); typedef edge_image<void, value::int_u8, util::graph> E; - E e_ima = make::edge_image(v_ima, convert::tofun(doublelol<mln_psite_(I)>)); + E e_ima = make::edge_image(v_ima, convert::tofun(distance_box)); + // WST.

1 0

r4316: Tries about segmentation based on distance between I.Z
by Edwin Carlinet 22 Jul '09

22 Jul '09

URL: https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox ChangeLog: 2009-07-22 Edwin Carlinet <carlinet(a)lrde.epita.fr> Tries about segmentation based on distance between I.Z. * edwin/exec/zi.cc: New. --- zi.cc | 217 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) Index: trunk/milena/sandbox/edwin/exec/zi.cc =================================================================== --- trunk/milena/sandbox/edwin/exec/zi.cc (revision 0) +++ trunk/milena/sandbox/edwin/exec/zi.cc (revision 4316) @@ -0,0 +1,217 @@ +// Copyright (C) 2009 EPITA Research and Development Laboratory (LRDE) +// +// This file is part of Olena. +// +// Olena is free software: you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation, version 2 of the License. +// +// Olena 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 Olena. If not, see <http://www.gnu.org/licenses/>. +// +// As a special exception, you may use this file as part of a free +// software project 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. + +#include <mln/core/image/image2d.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/core/var.hh> + +#include <mln/accu/stat/mean.hh> +#include <mln/accu/center.hh> + +#include <mln/value/int_u8.hh> +#include <mln/value/label_16.hh> +#include <mln/value/label_8.hh> +#include <mln/util/graph.hh> + +#include <mln/io/pbm/load.hh> +#include <mln/io/ppm/load.hh> +#include <mln/io/pgm/save.hh> + +#include <mln/labeling/blobs.hh> +#include <mln/labeling/compute.hh> +#include <mln/labeling/relabel.hh> + +#include <mln/transform/influence_zone_geodesic.hh> +#include <mln/morpho/watershed/flooding.hh> + +#include <mln/make/influence_zone_adjacency_graph.hh> +#include <mln/make/edge_image.hh> +#include <mln/make/vertex_image.hh> + +#include <mln/math/max.hh> +#include <mln/norm/l1.hh> + +#include "color_distance.hh" +#include <iostream> + +namespace mln +{ + + namespace convert + { + + // C-binary function to vv2v. (convert::to_fun...en binaire) + + template <typename R, typename V1, typename V2> + struct cfun_vv2v : Function_vv2v< cfun_vv2v<R, V1, V2> > + { + typedef R result; + + cfun_vv2v( R(*f_)(V1,V2) ) : + f (f_) + { + } + + R operator() (V1 arg1, V2 arg2) const + { + return f(arg1, arg2); + } + + R (*f) (V1, V2); + }; + + + template <typename R, typename V1, typename V2> + inline + cfun_vv2v<R, V1, V2> + tofun(R (*from) (V1, V2)) + { + cfun_vv2v<R, V1, V2> f(from); + return f; + } + + } + + template <typename P> + inline + value::int_u8 + doublelol(const P& p1, const P& p2) + { + return convert::to<value::int_u8>(norm::l1_distance(p1.to_vec(), p2.to_vec())); + } + +} + + + +void usage(char** argv) +{ + std::cout << "Usage: " << argv[0] << " in:mask.pbm in:source.ppm [out:zi.pgm]" + << "Compute the SKIZ from a binary image (saved in iz.pgm)." + << "" + << std::endl; + + + abort(); +} + + + +int main(int argc, char** argv) +{ + using namespace mln; + using value::int_u8; + + if (argc < 3) + usage(argv); + + const char* finput = argv[1]; + const char* fsource = argv[2]; + const char* foutput = argc > 3 ? argv[3] : "zi.pgm"; + + // Image loadin' + image2d<bool> input; + io::pbm::load(input, finput); + + image2d<value::rgb8> source; + io::ppm::load(source, fsource); + + + // I.Z + typedef value::label_8 L; + + typedef image2d<L> I; + I labels, iz, out; + L nlabel; + + labels = labeling::blobs(input, c4(), nlabel); + iz = transform::influence_zone_geodesic(labels, c4()); + + io::pgm::save(iz, foutput); + + // I.Z Graph + util::graph izg = make::influence_zone_adjacency_graph(iz, c4(), nlabel); + + // -- Color distance + // util::array<value::rgb8> mean_colors; + // convert::from_to(labeling::compute(accu::stat::mean<value::rgb8>(), source, labels, nlabel), + // mean_colors); + + // typedef vertex_image<void, value::rgb8, util::graph> V; + // V v_ima = make::vertex_image(izg, mean_colors); + + // typedef edge_image<void, value::int_u8, util::graph> E; + // E e_ima = make::edge_image(v_ima, convert::tofun(dist_mean)); + // -- Color distance + + util::array<mln_psite_(I)> mass_centers; + convert::from_to(labeling::compute(accu::center<mln_psite_(I)>(), labels, nlabel), + mass_centers); + + typedef vertex_image<void, mln_psite_(I), util::graph> V; + V v_ima = make::vertex_image(izg, mass_centers); + + typedef edge_image<void, value::int_u8, util::graph> E; + E e_ima = make::edge_image(v_ima, convert::tofun(doublelol<mln_psite_(I)>)); + + + // WST. + typedef mln_ch_value_(V, L) v_ima_labels_t; + v_ima_labels_t v_ima_labels; + initialize(v_ima_labels, v_ima); + + typedef mln_ch_value_(E, L) e_ima_wst_t; + L nbasins; + e_ima_wst_t e_ima_wst = + morpho::watershed::flooding(e_ima, E::nbh_t (), nbasins); + + { // Label nodes with edge wst labels. + mln_vertex_iter_(util::graph) v(izg); + mln_vertex_nbh_edge_iter_(util::graph) n(v); + for_all(v) + for_all(n) + { + if (e_ima_wst(n)) + { + v_ima_labels(v) = e_ima_wst(n); + break; + } + } + } + + // Relabeling + util::array<L> tr(nlabel); + mln_piter_(V) v(v_ima.domain()); + for_all(v) + { + std::cout << v.id() << " : " << v_ima_labels(v) << std::endl; + tr[v.id()] = v_ima_labels(v); + } + + labeling::relabel_inplace(iz, nlabel, tr); + + io::pgm::save(iz, "zi_wst.pgm"); +} +

1 0

4315: Augment ICDAR module code.
by Thierry Geraud 22 Jul '09

22 Jul '09

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Augment ICDAR module code. * modules/icdar/words.cc: Cosmetic change. * modules/icdar/lines.cc: Augment. lines.cc | 173 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++------- words.cc | 1 2 files changed, 155 insertions(+), 19 deletions(-) Index: modules/icdar/words.cc --- modules/icdar/words.cc (revision 4314) +++ modules/icdar/words.cc (working copy) @@ -222,4 +222,3 @@ io::ppm::save(labeling::colorize(output, n_words), "ws_large.ppm"); } - Index: modules/icdar/lines.cc --- modules/icdar/lines.cc (revision 4314) +++ modules/icdar/lines.cc (working copy) @@ -53,6 +53,7 @@ #include <mln/morpho/closing/structural.hh> #include <mln/core/alias/neighb2d.hh> #include <mln/morpho/watershed/flooding.hh> +#include <mln/labeling/wrap.hh> #include <mln/algebra/vec.hh> #include <mln/accu/stat/var.hh> @@ -60,6 +61,13 @@ #include <mln/make/vertex_image.hh> #include <mln/make/edge_image.hh> +#include <mln/morpho/elementary/dilation.hh> +#include <mln/data/transform.hh> +#include <mln/core/image/imorph/tr_image.hh> +#include <mln/core/routine/duplicate.hh> +#include <mln/labeling/colorize.hh> + + void usage(char* argv[]) { @@ -105,25 +113,120 @@ } - struct bloup : Function_vv2v<bloup> +// struct bloup : Function_vv2v<bloup> +// { +// typedef float result; + +// template <typename Var, typename V> +// float dist(const Var& var, const V& v) const +// { +// mln_precondition(var.is_valid()); +// V v_ = v - var.mean(); +// return v_.t() * var.variance()._1() * v_; +// } + +// template <typename Var> +// float operator()(const Var& var1, const Var& var2) const +// { +// return std::min(dist(var1, var2.mean()), dist(var2, var1.mean())); +// } +// }; + + + struct pass : Function_vv2v<pass> { - typedef float result; + typedef bool result; - template <typename Var, typename V> - float dist(const Var& var, const V& v) const + template <typename A> + bool operator()(const A& a1, const A& a2) const + { + if (! a1.is_valid() || ! a2.is_valid()) + return false; + A l, r; + if (a1.mean()[1] < a2.mean()[1]) + { + l = a1; + r = a2; + } + else { - mln_precondition(var.is_valid()); - V v_ = v - var.mean(); - return v_.t() * var.variance()._1() * v_; + l = a2; + r = a1; + } + float + // vertical std deviations + vs_l = std::sqrt(l.variance()(0, 0)), + vs_r = std::sqrt(r.variance()(0, 0)), + // vertical distance + vd = std::abs(l.mean()[0] - r.mean()[0]), + // horizontal std deviations + hs_l = std::sqrt(l.variance()(1, 1)), + hs_r = std::sqrt(r.variance()(1, 1)), + // horizontal means (column coordinates) + hm_l = l.mean()[1], + hm_r = r.mean()[1]; + + bool + v_criterion = (vd < 5 * std::sqrt(vs_l * vs_r)), // FIXME: say 4? + h_criterion = (hm_r - 1 * hs_r > hm_l + 1 * hs_l); // FIXME: say 1.5? + + return v_criterion && h_criterion; } + }; + - template <typename Var> - float operator()(const Var& var1, const Var& var2) const + template <typename L> + inline + L find_root_(util::array<L>& parent, L l) { - return std::min(dist(var1, var2.mean()), dist(var2, var1.mean())); + if (parent[l] == l) + return l; + return parent[l] = find_root_(parent, parent[l]); } + + + template <unsigned n> + struct over_; + + template <unsigned n> + struct sub_ : Function_v2v< sub_<n> > + { + typedef point2d result; + point2d operator()(const point2d& p) const + { + return point2d(p.row() / n, p.col() / n); + } + over_<n> inv() const; }; + template <unsigned n> + struct over_ : Function_v2v< over_<n> > + { + typedef point2d result; + point2d operator()(const point2d& p) const + { + return point2d(p.row() * n, p.col() * n); + } + sub_<n> inv() const + { + return sub_<n>(); + } + }; + + template <unsigned n> + over_<n> sub_<n>::inv() const + { + return over_<n>(); + } + + + template <typename S, typename I, typename F> + tr_image<S,I,F> + transform(const Site_Set<S>& s, const Image& ima, const Function_v2v<F>& t) + { + tr_image<S,I,F> tmp(exact(s), exact(ima), exact(t)); + return tmp; + } } // local @@ -184,6 +287,8 @@ L n_basins; image2d<L> ws = morpho::watershed::flooding(clo, c4(), n_basins); + io::pgm::save(labeling::wrap(ws), "temp_ws.pgm"); + std::cout << "n basins = " << n_basins << std::endl; local::superimpose_save(small, ws, "temp_small_ws.ppm"); @@ -197,25 +302,57 @@ n_basins, (pw::cst(255) - pw::value(small)) | small.domain()); - for (unsigned l = 1; l <= n_basins; ++l) - std::cout << l << ' ' << arr[l].n_items() << ' ' << arr[l].mean() << std::endl; + // for (unsigned l = 1; l <= n_basins; ++l) + // std::cout << l << ' ' << arr[l].n_items() << ' ' << arr[l].mean() << std::endl; typedef util::graph G; G gr = make::region_adjacency_graph(ws, c8(), n_basins); vertex_image<void,A,G> v_ima = make::vertex_image(gr, arr); - edge_image<void,float,G> e_ima = make::edge_image(v_ima, - local::bloup()); + edge_image<void,bool,G> e_ima = make::edge_image(v_ima, + local::pass()); - { - typedef edge_image<void,float,G> I; + + util::array<L> parent(n_basins.next()); + for (L l = 0; l <= n_basins; ++l) + parent[l] = l; + + typedef edge_image<void,bool,G> I; mln_piter_(I) e(e_ima.domain()); for_all(e) { - std::cout << e.element().v1() << '-' << e.element().v2() << " : " << e_ima(e) << std::endl; - } + if (! e_ima(e)) + continue; + + unsigned + l1 = e.element().v1(), + l2 = e.element().v2(); + if (l1 > l2) + std::swap(l1, l2); + parent[l1] = l2; + + // std::cout << e.element().v1() << '-' << e.element().v2() << " : " + // << (e_ima(e) ? "OK" : "ko") << std::endl; } + // for (L l = 1; l <= n_basins; ++l) + // { + // parent[l] = local::find_root_(parent, l); + // std::cout << l << " -> " << parent[l] << std::endl; + // } + + io::pgm::save(labeling::wrap(data::transform(ws, parent)), "temp_relab.pgm"); + + + ws = morpho::elementary::dilation(ws, c8()); + + image2d<L> ws_(input.domain()); + data::fill(ws_, local::transform(input.domain(), ws, local::over_<4>())); + + io::ppm::save(labeling::colorize(rgb8(), ws_), argv[2]); + + + trace::exiting("main"); }

1 0

4314: Add 2010 code for page segmentation.
by Thierry Geraud 22 Jul '09

22 Jul '09

https://svn.lrde.epita.fr/svn/oln/trunk/milena/sandbox Index: ChangeLog from Thierry Geraud <thierry.geraud(a)lrde.epita.fr> Add 2010 code for page segmentation. * inim/2010/page: New directory. * inim/2010/page/AUTHORS: New. * inim/2010/page/check_size_functor.hh: New. * inim/2010/page/white.hxx: New. * inim/2010/page/main.cc: New. * inim/2010/page/binarization: New. * inim/2010/page/binarization/binarization.hxx: New. * inim/2010/page/binarization/grayscale.hxx: New. * inim/2010/page/binarization/functors.hh: New. * inim/2010/page/binarization/integral-image.hh: New. * inim/2010/page/binarization/binarization.hh: New. * inim/2010/page/binarization/grayscale.hh: New. * inim/2010/page/binarization/functors.hxx: New. * inim/2010/page/binarization/integral-image.hxx: New. * inim/2010/page/README: New. * inim/2010/page/Makefile: New. * inim/2010/page/white.hh: New. AUTHORS | 3 Makefile | 43 +++++++ README | 51 ++++++++ binarization/binarization.hh | 36 ++++++ binarization/binarization.hxx | 72 ++++++++++++ binarization/functors.hh | 23 +++ binarization/functors.hxx | 33 +++++ binarization/grayscale.hh | 32 +++++ binarization/grayscale.hxx | 15 ++ binarization/integral-image.hh | 34 +++++ binarization/integral-image.hxx | 57 +++++++++ check_size_functor.hh | 30 +++++ main.cc | 89 +++++++++++++++ white.hh | 36 ++++++ white.hxx | 233 ++++++++++++++++++++++++++++++++++++++++ 15 files changed, 787 insertions(+) Index: inim/2010/page/AUTHORS --- inim/2010/page/AUTHORS (revision 0) +++ inim/2010/page/AUTHORS (revision 0) @@ -0,0 +1,3 @@ +hameli_a +denuzi_l +da-mot_s Index: inim/2010/page/check_size_functor.hh --- inim/2010/page/check_size_functor.hh (revision 0) +++ inim/2010/page/check_size_functor.hh (revision 0) @@ -0,0 +1,30 @@ +#ifndef CHECK_SIZE_FUNCTOR_HH_ +# define CHECK_SIZE_FUNCTOR_HH_ + +# include <mln/core/concept/function.hh> + +template <typename P, typename L> +class CheckBoxSize : public mln::Function_v2b< CheckBoxSize<P, L> > +{ +public: + + CheckBoxSize(mln::util::array< mln::box > boxes) + : boxes_ (boxes) + { + } + + bool operator() (L label) const + { + bool condition = + boxes_[label].len(1) >= 200 || + boxes_[label].len(0) >= 200; + return condition; + } + +private: + + mln::util::array< mln::box > boxes_; + +}; + +#endif /* !CHECK_SIZE_FUNCTOR_HH_ */ Index: inim/2010/page/white.hxx --- inim/2010/page/white.hxx (revision 0) +++ inim/2010/page/white.hxx (revision 0) @@ -0,0 +1,233 @@ +#ifndef WHITE_HXX +# define WHITE_HXX + +# include <white.hh> + +namespace whitespace +{ + + template <typename P> + bool is_box_ok (const box& box) + { + return (box.len(0) < 50 && box.len(1) < 30) + && (box.len(0) >= 5 || box.len(1) >= 5); + } + + template <typename I> + util::array< box<mln_psite(I)> > find_connected_components (I& ima) + { +// std::cout << "Computing connected components..." << std::endl; + typedef value::label_16 V; + V num_labels; + mln_ch_value(I, V) labels = labeling::blobs (ima, c8(), num_labels); + +// std::cout << "Computing connected components bounding boxes..." << std::endl; + typedef util::array< box<mln_psite(I)> > A; + A components = + labeling::compute (accu::shape::bbox<mln_psite(I)>(), + labels, num_labels); + +// std::cout << "Writing components image..." << std::endl; + I out (ima.domain()); + mln_fwd_eiter(A) it (components); + A final_components; + for_all (it) + if (is_box_ok (it.element())) + { + final_components.append (it.element()); + data::fill((out | it.element()).rw(), literal::one); + } +// io::pbm::save(out, "out.pbm"); + return final_components; + } + + template <typename P> + bool find_pivot (util::array< box > components, + box bound, + box& pivot) + { + bool found = false; + P bound_min = bound.pmin(); + P bound_max = bound.pmax(); + unsigned int best_dist = 0xffffffff; //bound_max[0] + bound_max[1]; + unsigned int bound_middle_x = (bound_max[0] + bound_min[0]) / 2; + unsigned int bound_middle_y = (bound_max[1] + bound_min[1]) / 2; + + mln_eiter(util::array< box >) it (components); + for_all (it) + { + P it_min = it.element().pmin(); + P it_max = it.element().pmax(); + + if (((bound.pmin()[0] <= it_max[0] && + it_max[0] <= bound.pmax()[0]) || + (bound.pmin()[0] <= it_min[0] && + it_min[0] <= bound.pmax()[0])) && + ((bound.pmin()[1] <= it_max[1] && + it_max[1] <= bound.pmax()[1]) || + (bound.pmin()[1] <= it_min[1] && + it_min[1] <= bound.pmax()[1]))) +// if (inter (it.element(), bound).nsites() != 0) + { + found = true; + unsigned int dist = abs(bound_middle_x - it_min[0]) + + abs(it_max[0] - bound_middle_x) + + abs(bound_middle_y - it_min[1]) + + abs(it_max[1] - bound_middle_y); + if (dist < best_dist) + { + best_dist = dist; + pivot = it.element(); + } + } + } + return found; + } + +// Determinate whether the given box must be considered to search for +// whitespace + template <typename P> + bool searchable_for_whitespace (box pbox, util::array< box > others) + { + if (pbox.nsites() < 4000) + return false; + + if (pbox.len (1) < 2 || pbox.len (0) < 10) + return false; + + typedef util::array< box > A; + mln_fwd_eiter(A) it (others); + + for_all(it) + { + unsigned int box_area = (pbox.pmax()[0] - pbox.pmin()[0]) * + (pbox.pmax()[1] - pbox.pmin()[1]); + + unsigned int left_inter_x = std::max(pbox.pmin()[0], it.element().pmin()[0]); + unsigned int right_inter_x = std::min(pbox.pmax()[0], it.element().pmax()[0]); + unsigned int top_inter_x = std::min(pbox.pmax()[1], it.element().pmax()[1]); + unsigned int bottom_inter_x = std::max(pbox.pmin()[1], it.element().pmin()[1]); + + if ((right_inter_x >= left_inter_x) && (top_inter_x >= bottom_inter_x)) + { + unsigned int inter_area = (right_inter_x - left_inter_x) * + (top_inter_x - bottom_inter_x); + + if (inter_area >= 0.8 * box_area) + return false; + } + } + return true; + } + +// Returns a lower value for high quality rectangles +// For use with a minimal heap + template <typename P> + value::int_u32 quality (box pbox) + { + // Not 0xffffffff because int_u32 constructor + // takes int instead of uint + return (0x7fffffff - pbox.nsites()); + } + + template <typename P> + util::array< box > + find_whitespaces (util::array< box > components, + box bound) + { + typedef util::fibonacci_heap<value::int_u32, box > H; + H h; + util::array< box > res; + h.push (quality(bound), bound); + box b; + box pivot; + while (h.is_valid()) + { + b = h.pop_front(); + if (find_pivot (components, b, pivot)) + { + P pmin = b.pmin(); + P pmax = b.pmax(); + box tmp_box; + for (int i = 0; i < P::dim; ++i) + { + if (pivot.pmax()[i] < b.pmax()[i]) + { + pmin[i] = pivot.pmax()[i] + 1; + tmp_box = box(pmin, pmax); + if (searchable_for_whitespace (tmp_box, res)) + h.push (quality(tmp_box), tmp_box); + pmin[i] = b.pmin()[i]; + } + if (pivot.pmin()[i] > b.pmin()[i]) + { + pmax[i] = pivot.pmin()[i] - 1; + tmp_box = box(pmin, pmax); + if (searchable_for_whitespace (tmp_box, res)) + h.push (quality(tmp_box), tmp_box); + pmax[i] = b.pmax()[i]; + } + } + } + else + // Found a white rectangle \o/ + { + res.append (b); + } + } + return res; + } + + void whitespace_compute (image2d<bool>& ima, + image2d<bool>& cleaned) + { + typedef mln_psite_(image2d<bool>) P; + +// image2d<bool> ima = io::pbm::load (argv[1]); + border::fill (ima, true); + + util::array< box > components = + whitespace::find_connected_components(ima); +// std::cout << "Computing whitespace zones..." << std::endl; + util::array< box > final_components = + whitespace::find_whitespaces (components,ima.domain()); + + +// std::cout << "Merging whitespace zones..." << std::endl; + image2d<bool> zones (ima.domain()); + data::fill (zones, literal::one); + mln_fwd_eiter_(util::array< box >) it (final_components); + for_all (it) + data::fill ((zones | it.element()).rw(), literal::zero); + border::fill (zones, false); + +// std::cout << "Writing whitespace image..." << std::endl; +// io::pbm::save(zones, "zones.pbm"); + +// std::cout << "Cleaning object zones..." << std::endl; + typedef value::label_16 V; + V num_labels; + image2d<V> labels = + labeling::blobs (zones, c8(), num_labels); +// io::pgm::save (labeling::wrap(labels), "labels.pgm"); + + util::array< box > boxes = + labeling::compute (accu::shape::bbox(), labels, num_labels); + + labeling::relabel_inplace (labels, num_labels, + CheckBoxSize<P, V>(boxes)); + labeling::pack_inplace (labels, num_labels); +// io::pgm::save (labeling::wrap(labels), "labels2.pgm"); + + image2d<value::int_u32> size_label = + labeling::compute_image (accu::math::sum<V, value::int_u32>(), + labels, labels, num_labels); + + cleaned = mln::binarization::threshold (size_label, 1); + +// std::cout << "Writing final image..." << std::endl; +// io::pbm::save (cleaned, "white.pbm"); + } +} // End of namespace whitespace + +#endif /* !WHITE_HXX */ Index: inim/2010/page/main.cc --- inim/2010/page/main.cc (revision 0) +++ inim/2010/page/main.cc (revision 0) @@ -0,0 +1,89 @@ +#include <string> +#include <iostream> + +#include <sys/types.h> +#include <sys/stat.h> + +#include <mln/io/ppm/load.hh> +#include <mln/io/pbm/save.hh> +#include <mln/io/pgm/save.hh> +#include <mln/value/int_u8.hh> +#include <mln/core/image/image2d.hh> + +#include <binarization.hh> +#include <grayscale.hh> +#include <white.hh> + +void usage (const std::string& name) +{ + std::cout << "Usage: " << name + << " [-w window_size] [-b] IN.ppm OUT.pbm" << std::endl; + exit (1); +} + +int +main (int argc, + char** argv) +{ + if (argc < 2) + usage(std::string(argv[0])); + + int i = 1; + unsigned int w_val = 51; + bool do_white = true; + + if (std::string(argv[i]) == "-w") + { + if (argc > w_val; + ++i; + } + + if (i >= argc) + usage(std::string(argv[0])); + + if (std::string(argv[i]) == "-b") + { + do_white = false; + ++i; + } + + if (i >= argc) + usage(std::string(argv[0])); + + std::string infile(argv[i++]); + + if (i >= argc) + usage(std::string(argv[0])); + + std::string outfile(argv[i]); + + // The original image + mln::image2d<mln::value::rgb8> initial; + mln::io::ppm::load(initial, infile); + const mln::image2d<mln::value::rgb8>& loaded = initial; + + // Grayscale + mln::image2d<mln::value::int_u8> grays(loaded.domain()); + binarization::grayscale(loaded, grays); + + // Binarization + mln::image2d<bool> binarized(loaded.domain()); + binarization::sauvola_threshold(grays, binarized, w_val); + + + if (do_white) + { + // Whitespace + mln::image2d<bool> final(loaded.domain()); + whitespace::whitespace_compute(binarized, final); + mln::io::pbm::save (final, outfile); + } + else + mln::io::pbm::save (binarized, outfile); +} Index: inim/2010/page/binarization/binarization.hxx --- inim/2010/page/binarization/binarization.hxx (revision 0) +++ inim/2010/page/binarization/binarization.hxx (revision 0) @@ -0,0 +1,72 @@ +#ifndef BINARIZATION_HXX +# define BINARIZATION_HXX + +# include <binarization.hh> + +namespace binarization +{ + template<typename T1, typename T2> + void + sauvola_threshold(const image2d<T1>& src, + image2d<T2>& dst, + unsigned int w) + { + // Control the threshold value in the local window + // The higher, the lower the threshold form the local + // mean m(x, y). Badekas et al. said 0.34 was best. + const double k = 0.34; + // Maximum value of the standard deviation (128 for + // grayscale documents). + const double R = 128; + + + // TODO: Merge both calculus into one to improve speed + // Compute the sum of all intensities of src + IntegralImage<T1> simple(src, Identity<T1>()); + // Compute the sum of all squared intensities of src + IntegralImage<T1> squared(src, Square<T1>()); + + int w_2 = w >> 1; + + // Savaula Algorithm with I.I. + for(def::coord row = 0; row < static_cast<def::coord>(dst.nrows()); ++row) + for(def::coord col = 0; col < static_cast<def::coord>(dst.ncols()); ++col) + { + int row_min = std::max(0, row - w_2); + int col_min = std::max(0, col - w_2); + int row_max = std::min(static_cast<int>(dst.nrows() - 1), + row + w_2); + int col_max = std::min(static_cast<int>(dst.ncols() - 1), + col + w_2); + + double wh = (row_max - row_min + 1) * (col_max - col_min + 1); + + // Mean + double m_x_y_tmp = (simple(row_max, col_max) + + simple(row_min, col_min) + - simple(row_max, col_min) + - simple(row_min, col_max)); + + double m_x_y = m_x_y_tmp / wh; + + // Standard deviation + double s_x_y_tmp = (squared(row_max, col_max) + + squared(row_min, col_min) + - squared(row_max, col_min) + - squared(row_min, col_max)); + + double s_x_y = sqrt((s_x_y_tmp - (m_x_y_tmp * m_x_y_tmp) / wh)/(wh-1.0f)); + + // Thresholding + double t_x_y = m_x_y * (1.0 + k * ((s_x_y / R) - 1.0)); + + if (t_x_y > src(point2d(row, col))) + dst(point2d(row, col)) = true; + else + dst(point2d(row, col)) = false; + } + + } +} + +#endif /* !BINARIZATION_HXX */ Index: inim/2010/page/binarization/grayscale.hxx --- inim/2010/page/binarization/grayscale.hxx (revision 0) +++ inim/2010/page/binarization/grayscale.hxx (revision 0) @@ -0,0 +1,15 @@ +#ifndef GRAYSCALE_HXX +# define GRAYSCALE_HXX + +# include <grayscale.hh> + +namespace binarization +{ + void grayscale(const image2d<value::rgb8>& src, + image2d<value::int_u8>& dst) + { + dst = data::transform(src, lum()); + } +} + +#endif /* !GRAYSCALE_HXX */ Index: inim/2010/page/binarization/functors.hh --- inim/2010/page/binarization/functors.hh (revision 0) +++ inim/2010/page/binarization/functors.hh (revision 0) @@ -0,0 +1,23 @@ +#ifndef FUNCTORS_HH +# define FUNCTORS_HH + +namespace binarization +{ + template<typename T> + struct Square + { + Square(); + unsigned long long operator()(T val) const; + }; + + template<typename T> + struct Identity + { + Identity(); + unsigned long long operator()(T val) const; + }; +} + +# include "functors.hxx" + +#endif /* !FUNCTORS_HH */ Index: inim/2010/page/binarization/integral-image.hh --- inim/2010/page/binarization/integral-image.hh (revision 0) +++ inim/2010/page/binarization/integral-image.hh (revision 0) @@ -0,0 +1,34 @@ +#ifndef INTEGRAL_IMAGE_HH +# define INTEGRAL_IMAGE_HH + +# include <mln/core/image/image2d.hh> +# include <mln/value/int_u8.hh> +# include <mln/value/int_u32.hh> +# include <functors.hh> + +namespace binarization +{ + using namespace mln; + + template< typename T > + class IntegralImage + { + public: + template<class F> + IntegralImage(const image2d<T>& i, F func); + ~IntegralImage(); + +// const unsigned long long& operator()(int row, int col) const; + + unsigned long long operator()(int row, int col) const; + + private: + unsigned long long **img_; + int nrows_; + int ncols_; + }; +} + +# include "integral-image.hxx" + +#endif /* !INTEGRAL_IMAGE_HH */ Index: inim/2010/page/binarization/binarization.hh --- inim/2010/page/binarization/binarization.hh (revision 0) +++ inim/2010/page/binarization/binarization.hh (revision 0) @@ -0,0 +1,36 @@ +#ifndef BINARIZATION_HH +# define BINARIZATION_HH + +# include <algorithm> +# include <cmath> + +# include <mln/core/image/image2d.hh> +# include <mln/value/int_u8.hh> +# include <mln/value/int_u32.hh> + +# include <integral-image.hh> +# include <functors.hh> + +namespace binarization +{ + using namespace mln; + + /** + * Sauvola thresholding binarization + * using Integral Images. + * + * \param[in] src The source image + * \param[out] dst The destination image + * \param[in] w Value of the window size + */ + + template<typename T1, typename T2> + void + sauvola_threshold(const image2d<T1>& src, + image2d<T2>& dst, + unsigned int w); +} + +# include <binarization.hxx> + +#endif /* !BINARIZATION_HH */ Index: inim/2010/page/binarization/grayscale.hh --- inim/2010/page/binarization/grayscale.hh (revision 0) +++ inim/2010/page/binarization/grayscale.hh (revision 0) @@ -0,0 +1,32 @@ +#ifndef GRAYSCALE_HH +# define GRAYSCALE_HH + +# include <mln/core/image/image2d.hh> +# include <mln/value/rgb8.hh> +# include <mln/value/int_u8.hh> +# include <mln/data/transform.hh> +# include <mln/literal/colors.hh> + +namespace mln +{ + struct lum : Function_v2v<lum> + { + typedef value::int_u8 result; + result operator()(const value::rgb8& c) const + { + return (c.red() + c.green() + c.blue()) / 3; + } + }; +} + +namespace binarization +{ + using namespace mln; + + void grayscale(const image2d<value::rgb8>& src, + image2d<value::int_u8>& dst); +} + +# include <grayscale.hxx> + +#endif /* !GRAYSCALE_HH */ Index: inim/2010/page/binarization/functors.hxx --- inim/2010/page/binarization/functors.hxx (revision 0) +++ inim/2010/page/binarization/functors.hxx (revision 0) @@ -0,0 +1,33 @@ +#ifndef FUNCTORS_HXX +# define FUNCTORS_HXX + +# include <functors.hxx> + +namespace binarization +{ + template<typename T> + Square<T>::Square() + { } + + template<typename T> + unsigned long long + Square<T>::operator()(T val) const + { + return static_cast<unsigned long long>(val) * static_cast<unsigned long long>(val); + } + + template<typename T> + Identity<T>::Identity() + { } + + template<typename T> + unsigned long long + Identity<T>::operator()(T val) const + { + return static_cast<unsigned long long>(val); + } + + +} + +#endif /* !FUNCTORS_HXX */ Index: inim/2010/page/binarization/integral-image.hxx --- inim/2010/page/binarization/integral-image.hxx (revision 0) +++ inim/2010/page/binarization/integral-image.hxx (revision 0) @@ -0,0 +1,57 @@ +#ifndef INTEGRAL_IMAGE_HXX +# define INTEGRAL_IMAGE_HXX + +# include "integral-image.hh" + +namespace binarization +{ + template<typename T> + template<class F> + IntegralImage<T>::IntegralImage(const image2d<T>& i, F func) + : img_ (NULL), + nrows_ (i.nrows()), + ncols_ (i.ncols()) + { + img_ = static_cast<unsigned long long**>(malloc(sizeof (unsigned long long*) * nrows_)); + for (int n = 0; n < nrows_; ++n) + img_[n] = static_cast<unsigned long long*>(malloc(sizeof (unsigned long long) * ncols_)); + + // FIXME Overflow when super big image? + // unsigned long long not cool for portability + // Look for I.I. in the litterature + img_[0][0] = func(i(point2d(0, 0))); + + for (def::coord row = 1; row < static_cast<def::coord>(i.nrows()); ++row) + img_[row][0] = (*this)(row - 1, 0) + + func(i(point2d(row, 0))); + + for (def::coord col = 1; col < static_cast<def::coord>(i.ncols()); ++col) + img_[0][col] = (*this)(0, col - 1) + + func(i(point2d(0, col))); + + for (def::coord row = 1; row < static_cast<def::coord>(i.nrows()); ++row) + for (def::coord col = 1; col < static_cast<def::coord>(i.ncols()); ++col) + img_[row][col] = (*this)(row - 1, col) + + (*this)(row, col - 1) + - (*this)(row - 1, col - 1) + + func(i(point2d(row, col))); + } + + template< typename T > + IntegralImage<T>::~IntegralImage() + { + for (int n = 0; n < nrows_; ++n) + free(img_[n]); + free(img_); + } + + template< typename T > + unsigned long long + IntegralImage<T>::operator()(int row, + int col) const + { + return img_[row][col]; + } + +} +#endif /* !INTEGRAL_IMAGE_HXX */ Index: inim/2010/page/README --- inim/2010/page/README (revision 0) +++ inim/2010/page/README (revision 0) @@ -0,0 +1,51 @@ +Donc ce que l'on a fait consiste en troix parties: + - Niveaux de gris. + - Binarisation. + - Detection des colonnes de texte. + +- Niveaux de gris: + Pas besoin de trop d'explications ici je pense. + + void binarization::grayscale(const image2d<rgb8>& src, + image2d<int_u8>& dst) + +- Binarisation: + On a effectue une binarisation de Sauvola qui est un algo de seuillage + local (vs global comme Otsu) en se servant d'"Integral Images" pour que + ca trace un peu plus que l'algo de base. Cet Algo retourne une image + de booleens avec en blanc les elements de l'image et en noir le reste. + Il n'a pas de problèmes particulier si ce n'est que si l'image est trop + grosse (vraiment très grosse) avec pleins d'aplat de blanc, on + va dépasser la capacité maximale des unsigned long long utilisés pour les + Integral Images. Un lien vers le papier de référence sur Sauvola: + http://pubs.iupr.org/DATA/2007-IUPR-11Sep_1129.pdf + + La fonction maintenant, avec `w` étant le parametre de taille + de la fenetre utilisée pour les calculs de seuillages locaux: + + void binarization::sauvola_threshold(const image2d<rgb8>& src, + image2d<bool>& dst, + unsigned int w); + + Pour info, Ocropus utilise le même algo sauf que pour déterminer les + parametres optimaux pour une image, ils font plusieurs binarisations + et segmentation jusqu'à ce qu'ils considérent que le résultat soit + bon. + + +- Whitespace: + + On procéde par la recherche des plus grandes zones blanches dans + l'image binarisées. C'est un algo itératif qui cherche à merger + des composantes connexes pour avoir les plus grands aplats de + couleur. Le résultat, c'est que à partir d'une image binarisée, + on va donner une autre image binarisée avec en blanc les colones + et paragraphe de texte et en noir le fond. + + void whitespace::whitespace_compute (image2d<bool>& src, + image2d<bool>& dst); + + +Hésitez pas à nous spammer pour toute forme de questions +la dessus! + Index: inim/2010/page/Makefile --- inim/2010/page/Makefile (revision 0) +++ inim/2010/page/Makefile (revision 0) @@ -0,0 +1,43 @@ +CXX=g++ +INCLUDES=-I. -I./binarization +CXX_FLAGS=-W -Wall -DNDEBUG -O3 -ffast-math +CXXFLAGS = -I. +OBJS= main.o +TARGET=hameli_a +DISTDIR=hameli_a +DISTFILE= Makefile README AUTHORS binarization \ + check_size_functor.hh main.cc \ + white.hh white.hxx + +all: $(TARGET) + +$(TARGET): $(OBJS) + $(CXX) $(DEBUG_FLAGS) $^ -o $@ + +clean: + rm -f *~ *.o + +distclean: clean + rm -rf $(TARGET) + rm -rf *_result + +dist: distclean + rm -rf $(DISTDIR) + mkdir $(DISTDIR) + chmod 755 $(DISTDIR) + cp -r -t $(DISTDIR) $(DISTFILE) + tar czf $(DISTDIR).tar.gz $(DISTDIR) + rm -rf $(DISTDIR) + +distcheck: dist + rm -rf _build + mkdir _build + cp $(DISTDIR).tar.gz _build + cd _build; tar xf $(DISTDIR).tar.gz + cd _build/$(DISTDIR) ; make + +%.o: %.cc + $(CXX) $(CXX_FLAGS) $(CXXFLAGS) $(INCLUDES) $(DEBUG_FLAGS) -c $< + +.PHONY: main.cc +# \ No newline at end of file Index: inim/2010/page/white.hh --- inim/2010/page/white.hh (revision 0) +++ inim/2010/page/white.hh (revision 0) @@ -0,0 +1,36 @@ +#ifndef WHITE_HH +# define WHITE_HH + +#include <cmath> +#include <iostream> +#include <mln/accu/math/sum.hh> +#include <mln/accu/shape/bbox.hh> +#include <mln/binarization/threshold.hh> +#include <mln/core/alias/neighb2d.hh> +#include <mln/core/image/image2d.hh> +#include <mln/data/fill.hh> +#include <mln/labeling/blobs.hh> +#include <mln/labeling/compute.hh> +#include <mln/labeling/compute_image.hh> +#include <mln/labeling/wrap.hh> +#include <mln/util/array.hh> +#include <mln/util/fibonacci_heap.hh> +#include <mln/value/int_u32.hh> +#include <mln/value/label_16.hh> +#include <mln/labeling/relabel.hh> +#include <mln/labeling/pack.hh> +#include <mln/border/fill.hh> +#include <mln/labeling/colorize.hh> +#include <check_size_functor.hh> + +namespace whitespace +{ + using namespace mln; + + void whitespace_compute (image2d<bool>& ima, + image2d<bool>& cleaned); +} + +# include <white.hxx> + +#endif /* !WHITE_HH */

1 0