--- scribo/scribo/core/line_info.hh | 18 +- scribo/scribo/core/stats.hh | 16 +- scribo/scribo/text/merging.hh | 16 +- scribo/scribo/text/paragraphs.hh | 462 ++++++++++++++++++++++++++++++------- 4 files changed, 402 insertions(+), 110 deletions(-) diff --git a/scribo/scribo/core/line_info.hh b/scribo/scribo/core/line_info.hh index a798e9b..fa4051d 100644 --- a/scribo/scribo/core/line_info.hh +++ b/scribo/scribo/core/line_info.hh @@ -1006,21 +1006,22 @@ namespace scribo const int dy = bb1.pmax().row() - bb2.pmax().row(); // The two characters must be distinct - if (space < 0) - return false; + // if (space < 0) + // return false; if (// Approximately the same width - ((std::max(w1, w2) / std::min(w1, w2)) > 1.1f || + ((std::max(w1, w2) / std::min(w1, w2)) > 1.3 || // One character must not be smaller than the space between // the two characters (w1 < space || w2 < space)) // If the two characters have a different width they must also // have a different height - && not (std::max(h1, h2) / std::min(h1, h2) <= 1.5f)) + && not (std::max(h1, h2) / std::min(h1, h2) <= 1.7f)) return false; // Approximately aligned on baseline - if (std::abs(dy) > 10) + if (std::abs(dy) > 10 && + not (std::max(h1, h2) / std::min(h1, h2) <= 1.7f)) return false; return true; @@ -1055,6 +1056,10 @@ namespace scribo float min_base = 0.0f; const unsigned clusters_b_nelements = clusters_b.nelements(); + if (clusters_b_nelements >= 3) + return data_->baseline_clusters_.mean(); + + for (unsigned i = 0; i < clusters_b_nelements; ++i) { const unsigned clusters_b_i_nelements = clusters_b[i].nelements(); @@ -1092,6 +1097,9 @@ namespace scribo float max_mean = 0.0f; const unsigned clusters_m_nelements = clusters_m.nelements(); + if (clusters_m_nelements >= 3) + return data_->meanline_clusters_.mean(); + for (unsigned i = 0; i < clusters_m_nelements; ++i) { const unsigned clusters_m_i_nelements = clusters_m[i].nelements(); diff --git a/scribo/scribo/core/stats.hh b/scribo/scribo/core/stats.hh index 43cc3d6..3801545 100644 --- a/scribo/scribo/core/stats.hh +++ b/scribo/scribo/core/stats.hh @@ -250,7 +250,7 @@ private: std::vector< unsigned > clusters; unsigned cluster_index = 1; - clusters.reserve(data_.nelements()); + clusters.resize(data_.nelements()); if (not data_sorted_) { @@ -261,7 +261,7 @@ private: unsigned i = 0; const unsigned nelements = data_.nelements(); - clusters.push_back(cluster_index); + clusters[0] = cluster_index; const T std = data_.standard_deviation(); for (i = 1; i < nelements - 1; ++i) @@ -273,16 +273,14 @@ private: && left_distance <= std)) ++cluster_index; - clusters.push_back(cluster_index); + clusters[i] = cluster_index; } - if (nelements > 1) - { - if (data_[i] - data_[i - 1] > std) - ++cluster_index; + if (nelements > 1 + && data_[i] - data_[i - 1] > std) + ++cluster_index; - clusters.push_back(cluster_index); - } + clusters[i] = cluster_index; clusters_.clear(); clusters_.reserve(cluster_index); diff --git a/scribo/scribo/text/merging.hh b/scribo/scribo/text/merging.hh index c94f9f5..9b4db56 100644 --- a/scribo/scribo/text/merging.hh +++ b/scribo/scribo/text/merging.hh @@ -460,8 +460,8 @@ namespace scribo if (l_cur_height < l_ted_x_height && l_cur_height > 0.05f * l_ted_x_height && float(l_cur_width) / float(l_cur.card()) < l_ted.char_width() - && dx < l_ted_cw - && l_cur_pmin.row() < l_ted_pmax.row()) + && dx < 2 * l_ted_cw + && l_cur_pmin.row() < l_ted.baseline()) { l_cur.update_type(line::Punctuation); return true; @@ -740,11 +740,12 @@ namespace scribo // vertically aligned // Obviously no separators between the two lines if ((l_info.card() <= 5 || - (std::abs(l_info.baseline() - mc_info.baseline()) < 5 - && std::abs(l_info.meanline() - mc_info.meanline()) < 5)) - && dx < l_ted_cw && dy < 0 - && not (l_info.holder().components().has_separators() - && between_separators(l_info, mc_info))) + (std::abs(l_info.baseline() - mc_info.baseline()) + < 5 && std::abs(l_info.meanline() - + mc_info.meanline()) < 5)) + && dx < l_ted_cw && dy < 0 + && not (l_info.holder().components().has_separators() + && between_separators(l_info, mc_info))) l = do_union(lines, l, mc, parent); // } @@ -1046,7 +1047,6 @@ namespace scribo // ts = t.stop(); // std::cout << "time " << ts << std::endl; - lines.force_stats_update(); return lines; diff --git a/scribo/scribo/text/paragraphs.hh b/scribo/scribo/text/paragraphs.hh index 5cb253e..beaea0c 100644 --- a/scribo/scribo/text/paragraphs.hh +++ b/scribo/scribo/text/paragraphs.hh @@ -47,11 +47,123 @@ namespace scribo return x; } + + template <typename T> + inline + void + set_root(util::array<T>& parent, unsigned x, const unsigned root) + { + while (parent(x) != x && parent(x) != root) + { + const unsigned tmp = parent(x); + x = parent(x); + parent(tmp) = root; + } + + parent(x) = root; + } } namespace filter { + template <typename L> + inline + bool + between_horizontal_separator(const scribo::line_info<L>& l1, + const scribo::line_info<L>& l2) + { + // No separators found in image. + mln_precondition(l1.holder().components().has_separators()); + + const box2d& l1_bbox = l1.bbox(); + const box2d& l2_bbox = l2.bbox(); + + unsigned + row1 = l1_bbox.pcenter().row(), + row2 = l2_bbox.pcenter().row(); + const mln_ch_value(L, bool)& + separators = l1.holder().components().separators(); + + unsigned row; + unsigned col_ptr; + unsigned left_col_ptr; + unsigned right_col_ptr; + unsigned end; + + if (row1 < row2) + { + row1 = l1_bbox.pmax().row(); + row2 = l2_bbox.pmin().row(); + + const unsigned quarter = + ((l1_bbox.pcenter().col() - l1_bbox.pmin().col()) >> 2); + + row = l1_bbox.pcenter().row(); + col_ptr = l1_bbox.pcenter().col(); + left_col_ptr = l1_bbox.pmin().col() + quarter; + right_col_ptr = l1_bbox.pmax().col() - quarter; + end = row2; + } + else + { + row2 = l2_bbox.pmax().row(); + row1 = l1_bbox.pmin().row(); + + const unsigned quarter = + ((l2_bbox.pcenter().col() - l2_bbox.pmin().col()) >> 2); + + row = l2_bbox.pcenter().row(); + col_ptr = l2_bbox.pcenter().col(); + left_col_ptr = l2_bbox.pmin().col() + quarter; + right_col_ptr = l2_bbox.pmax().col() - quarter; + end = row1; + } + + // If sep_ptr is true, then a separator is reached. + while (row < end) + { + ++row; + if (separators.at_(row, col_ptr) + || separators.at_(row, left_col_ptr) + || separators.at_(row, right_col_ptr)) + return true; + } + + return false; + } + + + template <typename L> + inline + bool may_have_another_left_link(const util::array<value::int_u16>& right, + const value::int_u16 index, + const value::int_u16 current_line, + const util::array< line_info<L> >& lines) + { + const line_info<L>& l = lines(current_line); + const point2d& pmin = l.bbox().pmin(); + const unsigned x1 = l.x_height(); + + for (unsigned i = 0; i < right.nelements(); ++i) + { + if (i != index && right(i) == index) + { + const line_info<L>& l_info = lines(i); + const unsigned x2 = l_info.x_height(); + + const float delta_max = 0.5f * std::min(x1, x2); + + if (l_info.bbox().pmin().col() < pmin.col() + && std::abs(l.baseline() - l_info.baseline()) < delta_max + ) + return true; + } + } + + return false; + } + //--------------------------------------------------------------------- // This method aims to cut the links between lines that do not fit the // different criteria @@ -60,7 +172,7 @@ namespace scribo template <typename L> inline void paragraph_links(const util::array<value::int_u16>& left, - const util::array<value::int_u16>& right, + util::array<value::int_u16>& right, util::array<value::int_u16>& output, const util::array< line_info<L> >& lines, const image2d<bool>& input) @@ -81,9 +193,28 @@ namespace scribo { // Neighbors - const value::int_u16 left_nbh = output(l); - const value::int_u16 right_nbh = right(l); - const value::int_u16 lol_nbh = output(left_nbh); + value::int_u16 left_nbh = output(l); + value::int_u16 right_nbh = right(l); + value::int_u16 lol_nbh = output(left_nbh); + + const line_info<L>& left_line = lines(left_nbh); + const line_info<L>& current_line = lines(l); + const line_info<L>& right_line = lines(right_nbh); + + if (right_line.holder().components().has_separators() && + between_horizontal_separator(right_line, current_line)) + { + output(right_nbh) = right_nbh; + right_nbh = l; + } + if (current_line.holder().components().has_separators() && + between_horizontal_separator(current_line, left_line)) + { + output(l) = l; + left_nbh = l; + lol_nbh = l; + } + // Line features const float x_height = lines(l).x_height(); @@ -110,6 +241,7 @@ namespace scribo // Maximal x variation to consider two lines vertically aligned const int delta_alignment = cline_cw; + // Checks the baseline distances of the two neighbors { // Current line baseline @@ -149,7 +281,7 @@ namespace scribo // and its right neighbor if (right_distance > 1.4f * ror_distance && std::max(ror_x_height, right_x_height) < - 1.2f * std::min(ror_x_height, right_x_height) + 1.4f * std::min(ror_x_height, right_x_height) && output(right_nbh) == l) { output(right_nbh) = right_nbh; @@ -182,7 +314,7 @@ namespace scribo // Condition to cut the link between the current line and // its right neighbor - if ((max_x_height > min_x_height * 1.2f) && + if ((max_x_height > min_x_height * 1.4f) && !(max_char_width <= 1.2f * min_char_width)) { if (output(right_nbh) == l) @@ -218,7 +350,7 @@ namespace scribo // and its left neighbor if (left_distance > 1.4f * lol_distance && std::max(lol_x_height, left_x_height) < - 1.2f * std::min(lol_x_height, left_x_height)) + 1.4f * std::min(lol_x_height, left_x_height)) { output(l) = l; continue; @@ -250,7 +382,7 @@ namespace scribo // Condition to cut the link between the current line and // its left neighbor - if ((max_x_height > min_x_height * 1.2f) && + if ((max_x_height > min_x_height * 1.4f) && !(max_char_width <= 1.2f * min_char_width)) { output(l) = l; @@ -262,27 +394,28 @@ namespace scribo continue; } // The current line has at least one left and one right neighbor - else // if (delta_baseline_max >= delta_baseline_min) + else // if (delta_baseline_max >= 1.1f * delta_baseline_min) { // Distance between the left and the current line const float left_distance = - lines(left_nbh).meanline() - lines(l).baseline(); + left_line_bbox.pcenter().row() - current_line_bbox.pcenter().row(); // Distance between the right and the current line const float right_distance = - lines(l).meanline() - lines(right_nbh).baseline(); + current_line_bbox.pcenter().row() - right_line_bbox.pcenter().row(); // If the left line is too far compared to the right one // we cut the link with it - if (left_distance > 1.2f * right_distance - && std::max(x_height, left_x_height) > 1.2f * std::min(x_height, left_x_height)) + if (left_distance > 1.5f * right_distance + && std::max(x_height, left_x_height) > 1.2f * std::min(x_height, left_x_height) + ) { output(l) = l; continue; } // If the right line is too far compared to the left one // we cut the link with it - else if (right_distance > 1.2f * left_distance - && std::max(x_height, right_x_height) > 1.2f * std::min(x_height, right_x_height) + else if (right_distance > 1.5f * left_distance + && std::max(x_height, right_x_height) >= 1.2f * std::min(x_height, right_x_height) && output(right_nbh) == l) { output(right_nbh) = right_nbh; @@ -301,7 +434,7 @@ namespace scribo const float min_x_height = std::min(x_height, left_x_height); const float max_x_height = std::max(x_height, left_x_height); - if ((max_x_height > min_x_height * 1.2f) && + if ((max_x_height > min_x_height * 1.4f) && !(cw_max <= 1.2f * cw_min)) { output(l) = l; @@ -314,7 +447,7 @@ namespace scribo const float cw_max = std::max(rline_cw, cline_cw); const float cw_min = std::min(rline_cw, cline_cw); - if ((max_x_height > min_x_height * 1.2f) + if ((max_x_height > min_x_height * 1.4f) && !(cw_max <= 1.2f * cw_min) && output(right_nbh) == l) { @@ -330,7 +463,7 @@ namespace scribo const float min_x_height = std::min(x_height, right_x_height); const float max_x_height = std::max(x_height, right_x_height); - if ((max_x_height > min_x_height * 1.2f) + if ((max_x_height > min_x_height * 1.4f) && !(cw_max <= 1.2f * cw_min) && output(right_nbh) == l) { @@ -344,7 +477,7 @@ namespace scribo const float cw_max = std::max(lline_cw, cline_cw); const float cw_min = std::min(lline_cw, cline_cw); - if ((max_x_height > min_x_height * 1.2f) + if ((max_x_height > min_x_height * 1.4f) && !(cw_max <= 1.2f * cw_min)) { output(l) = l; @@ -363,51 +496,6 @@ namespace scribo //----------------------------------------------------------------------------- // ___________________________ // |___________________________| -// ________________________ -// |________________________| -// ___________________________ -// |___________________________| -// ___________________________ -// |___________________________| -// -// Simple case : paragraphs are justified on the left. We try to find any -// indentation like above. -// -//----------------------------------------------------------------------------- - - { - // Check if the current line neighbors are aligned - bool left_right_aligned = false; - bool left_lol_aligned = false; - const int dx_lr = std::abs(lline_col_min - rline_col_min); - const int dx_llol = std::abs(lline_col_min - lolline_col_min); - - if (dx_lr < delta_alignment) - left_right_aligned = true; - - if (dx_llol < delta_alignment) - left_lol_aligned = true; - - if (left_right_aligned && left_lol_aligned) - { - const int left_right_col_min = std::min(lline_col_min, rline_col_min); - const int dx_lrc = std::abs(left_right_col_min - cline_col_min); - const float l_char_width = 1.5f * lines(l).char_width(); - - if (dx_lrc > l_char_width && - dx_lrc < 3.0f * l_char_width && - cline_col_min > rline_col_min && - cline_col_min > lline_col_min) - { - output(right_nbh) = right_nbh; - continue; - } - } - } - -//----------------------------------------------------------------------------- -// ___________________________ -// |___________________________| // ___________________ // |___________________| End of the paragraph - Current line // ________________________ @@ -443,8 +531,11 @@ namespace scribo { const int dx_lrc = std::abs(lline_col_max - cline_col_max); const int l_char_width = lines(l).char_width(); + const int dx_indent = std::abs(std::max(lline_col_min, + rline_col_min) - cline_col_min); if (dx_lrc > l_char_width && + dx_indent < 4 * delta_alignment && cline_col_max < lline_col_max && cline_col_min < lline_col_min && (lline_col_min > lolline_col_min || lol_is_left)) @@ -456,48 +547,216 @@ namespace scribo } + //----------------------------------------------------------------------------- // ___________________________ // |___________________________| -// ___________________________ -// |___________________________| // ________________________ // |________________________| +// ___________________________ +// |___________________________| +// ___________________________ +// |___________________________| // // Simple case : paragraphs are justified on the left. We try to find any -// indentation like above at the end of a column. +// indentation like above. // //----------------------------------------------------------------------------- - if (left_nbh == l) { - const value::int_u16 ror_nbh = right(right_nbh); - const box2d& ror_line_bbox = lines(ror_nbh).bbox(); - const int rorline_col_min = ror_line_bbox.pmin().col(); + // Check if the current line neighbors are aligned + bool left_right_aligned = false; + bool left_lol_aligned = false; + const int dx_lr = std::abs(lline_col_min - rline_col_min); + const int dx_llol = std::abs(lline_col_min - lolline_col_min); - bool right_ror_min_aligned = false; - const int dx_rror_min = std::abs(rline_col_min - rorline_col_min); + if (dx_lr < delta_alignment) + left_right_aligned = true; - if (dx_rror_min < delta_alignment) - right_ror_min_aligned = true; + if (dx_llol < delta_alignment) + left_lol_aligned = true; - if (right_ror_min_aligned) + if (left_right_aligned && left_lol_aligned) { - const int right_ror_col_min = std::min(rline_col_min, rorline_col_min); - const int dx_rrorc = std::abs(right_ror_col_min - cline_col_min); + const int left_right_col_min = std::min(lline_col_min, rline_col_min); + const int dx_lrc = std::abs(left_right_col_min - cline_col_min); const float l_char_width = 1.5f * lines(l).char_width(); - if (dx_rrorc > l_char_width && - dx_rrorc < 3.0f * l_char_width && + if (dx_lrc > l_char_width && + !may_have_another_left_link(right, right_nbh, l, lines) && + dx_lrc < 10.0f * l_char_width && cline_col_min > rline_col_min && - cline_col_max >= rline_col_max) + cline_col_min > lline_col_min) { - output(right_nbh) = right_nbh; + const value::int_u16 out_right_nbh = output(right_nbh); + + if (out_right_nbh != l) + right(l) = l; + else + output(right_nbh) = right_nbh; continue; } } } - } + +//----------------------------------------------------------------------------- +// ___________________________ +// |___________________________| +// ___________________________ +// |___________________________| +// ________________________ +// |________________________| +// ___________________________ +// |___________________________| +// +// Simple case : paragraphs are justified on the left. We try to find any +// indentation like above. +// +//----------------------------------------------------------------------------- + + { + const value::int_u16 ror_nbh = right(right_nbh); + const box2d& ror_line_bbox = lines(ror_nbh).bbox(); + const int rorline_col_min = ror_line_bbox.pmin().col(); + + bool right_ror_min_aligned = false; + bool left_right_aligned = false; + const int dx_lr = std::abs(lline_col_min - rline_col_min); + const int dx_rror_min = std::abs(rline_col_min - rorline_col_min); + + if (dx_rror_min < delta_alignment) + right_ror_min_aligned = true; + + if (dx_lr < delta_alignment) + left_right_aligned = true; + + if (right_ror_min_aligned && left_right_aligned && + ror_nbh != right_nbh) + { + const int left_right_col_min = std::min(lline_col_min, rline_col_min); + const int dx_lrc = std::abs(left_right_col_min - cline_col_min); + const float l_char_width = 1.5f * lines(l).char_width(); + + if (dx_lrc > l_char_width && + !may_have_another_left_link(right, right_nbh, l, lines) && + dx_lrc < 10.0f * l_char_width && + cline_col_min > rline_col_min && + cline_col_min > lline_col_min) + { + const value::int_u16 out_right_nbh = output(right_nbh); + + if (out_right_nbh != l) + right(l) = l; + else + output(right_nbh) = right_nbh; + continue; + } + } + } + +//----------------------------------------------------------------------------- +// ___________________________ +// |___________________________| +// ___________ +// |___________| +// ________________________ +// |________________________| +// ___________________________ +// |___________________________| +// +// Simple case : paragraphs are justified on the left. We try to find any +// indentation like above. +// +//----------------------------------------------------------------------------- + + { + const value::int_u16 ror_nbh = right(right_nbh); + const box2d& ror_line_bbox = lines(ror_nbh).bbox(); + const int rorline_col_min = ror_line_bbox.pmin().col(); + + bool left_ror_aligned = false; + const int dx_lror = std::abs(lline_col_min - rorline_col_min); + + if (dx_lror < delta_alignment) + left_ror_aligned = true; + + if (left_ror_aligned) + { + const int left_ror_col_min = std::min(lline_col_min, rorline_col_min); + const int dx_lrorc = std::abs(left_ror_col_min - cline_col_min); + const float l_char_width = 1.5f * lines(l).char_width(); + const int dx_lrorr = std::abs(left_ror_col_min - rline_col_min); + const int dx_crmax = std::abs(rline_col_max - cline_col_max); + + if (dx_lrorc > l_char_width && + dx_lrorr > 5 * l_char_width && + dx_lrorr > dx_lrorc && + dx_crmax > 5 * l_char_width && + !may_have_another_left_link(right, right_nbh, l, lines) && + dx_lrorc < 10.0f * l_char_width && + cline_col_min > rorline_col_min && + cline_col_min > lline_col_min) + { + right(right_nbh) = right_nbh; + continue; + } + } + } + + +// Strange case + { + if (rline_col_min > current_line_bbox.pcenter().col() + && !may_have_another_left_link(right, right_nbh, l, lines) + && cline_col_max < rline_col_max + && output(right_nbh) == l) + { + output(right_nbh) = right_nbh; + } + } + +//----------------------------------------------------------------------------- +// ___________________________ +// |___________________________| +// ___________________________ +// |___________________________| +// ________________________ +// |________________________| +// +// Simple case : paragraphs are justified on the left. We try to find any +// indentation like above at the end of a column. +// +//----------------------------------------------------------------------------- + + if (left_nbh == l) + { + const value::int_u16 ror_nbh = right(right_nbh); + const box2d& ror_line_bbox = lines(ror_nbh).bbox(); + const int rorline_col_min = ror_line_bbox.pmin().col(); + + bool right_ror_min_aligned = false; + const int dx_rror_min = std::abs(rline_col_min - rorline_col_min); + + if (dx_rror_min < delta_alignment) + right_ror_min_aligned = true; + + if (right_ror_min_aligned) + { + const int right_ror_col_min = std::min(rline_col_min, rorline_col_min); + const int dx_rrorc = std::abs(right_ror_col_min - cline_col_min); + const float l_char_width = 1.5f * lines(l).char_width(); + + if (dx_rrorc > l_char_width && + dx_rrorc < 10.0f * l_char_width && + cline_col_min > rline_col_min && + cline_col_max >= rline_col_max) + { + output(right_nbh) = right_nbh; + continue; + } + } + } + } // Only debug @@ -505,8 +764,21 @@ namespace scribo { image2d<value::rgb8> debug = data::convert(value::rgb8(), input); + const util::array<value::int_u16> backup = output; for (unsigned i = 0; i < output.nelements(); ++i) - output(i) = internal::find_root(output, i); + { + const value::int_u16 current_neighbor = backup(i); + output(i) = internal::find_root(output, i); + const value::int_u16 root_index = output(i); + + for (unsigned j = 0; j < right.nelements(); ++j) + { + if (i != j && + current_neighbor != i && + right(j) == i) + internal::set_root(output, j, root_index); + } + } mln::util::array<accu::shape::bbox<point2d> > nbbox(output.nelements()); for (unsigned i = 0; i < nlines; ++i) @@ -690,7 +962,7 @@ namespace scribo int dmax = 1.5f * lines(i).x_height(); // Starting points in the current line box - point2d c = rbbox(i).pcenter(); + point2d c(rbbox(i).pcenter()); point2d q(rbbox(i).pmin().row() + ((c.row() - rbbox(i).pmin().row()) / 4), c.col()); int @@ -830,7 +1102,7 @@ namespace scribo int dmax = 1.5f * lines(i).x_height(); // Starting points in the current line box - point2d c = rbbox(i).pcenter(); + point2d c(rbbox(i).pcenter()); point2d q(rbbox(i).pmax().row() - ((rbbox(i).pmax().row() - c.row()) / 4), c.col()); int @@ -952,7 +1224,9 @@ namespace scribo inline void finalize_links(util::array<value::int_u16>& left, util::array<value::int_u16>& right, - const util::array< line_info<L> >& lines) + const util::array< line_info<L> >& lines// , + // const image2d<bool>& input + ) { const unsigned nlines = lines.nelements(); @@ -979,6 +1253,17 @@ namespace scribo v = i; } } + + // image2d<value::rgb8> left_links = data::convert(value::rgb8(), input); + // image2d<value::rgb8> right_links = data::convert(value::rgb8(), input); + + // for (unsigned l = 0; l < nlines; ++l) + // { + // mln::draw::line(left_links, lines(l).bbox().pcenter(), lines(left(l)).bbox().pcenter(), literal::red); + // mln::draw::line(right_links, lines(l).bbox().pcenter(), lines(right(l)).bbox().pcenter(), literal::red); + // } + // mln::io::ppm::save(left_links, "out_left_links.ppm"); + // mln::io::ppm::save(right_links, "out_right_links.ppm"); } template <typename L> @@ -1016,7 +1301,8 @@ namespace scribo std::cout << "Linking right" << std::endl; process_right_link(blocks, rbbox, lines_info, right); std::cout << "Finalizing links" << std::endl; - finalize_links(left, right, lines_info); + finalize_links(left, right, lines_info// , input + ); // std::cout << "Finalizing merging" << std::endl; // finalize_line_merging(left, right, lines); std::cout << "Extracting paragraphs" << std::endl; -- 1.5.6.5