feat: add support for RtL (#94)

Signed-off-by: Peter Staar <[email protected]>

Author: PeterStaar-IBM

docling_parse/document.py

@@ -166,6 +166,7 @@ class PdfCell(PdfColoredElement):
     font_name: str
 
     widget: bool
+    left_to_right: bool
 
     def to_bottom_left_origin(self, page_height: float):
         self.rect = self.rect.to_bottom_left_origin(page_height=page_height)

docling_parse/pdf_parser.py

@@ -191,6 +191,7 @@ def _to_cells(self, cells: dict) -> List[PdfCell]:
                 font_key=row[header.index(f"font-key")],
                 font_name=row[header.index(f"font-name")],
                 widget=row[header.index(f"widget")],
+                left_to_right=row[header.index(f"left_to_right")],
                 ordering=ind,
                 rendering_mode="",
             )

src/v2.h

@@ -76,6 +76,7 @@
 #include <v2/pdf_resources/page_images.h>
 
 #include <v2/pdf_sanitator.h>
+#include <v2/pdf_sanitators/constants.h>
 #include <v2/pdf_sanitators/lines.h>
 #include <v2/pdf_sanitators/cells.h>
 #include <v2/pdf_sanitators/page_dimension.h>

src/v2/pdf_resources/page_cell.h

@@ -27,14 +27,17 @@ namespace pdflib
 
     bool is_adjacent_to(pdf_resource<PAGE_CELL>& other, double delta);
 
+    bool has_same_reading_orientation(pdf_resource<PAGE_CELL>& other);
+    
     bool merge_with(pdf_resource<PAGE_CELL>& other, double delta);
 
   public:
 
     static std::vector<std::string> header;
 
     bool active;
-
+    bool left_to_right;
+    
     double x0;
     double y0;
     double x1;
@@ -81,7 +84,8 @@ namespace pdflib
   };
 
   pdf_resource<PAGE_CELL>::pdf_resource():
-    active(true)
+    active(true),
+    left_to_right(true)
     {}
 
   pdf_resource<PAGE_CELL>::~pdf_resource()
@@ -128,7 +132,8 @@ namespace pdflib
     //"block-count",
     //"instr-count",
 
-    "widget"
+    "widget",
+    "left_to_right"
   };
 
   void pdf_resource<PAGE_CELL>::rotate(int angle, std::pair<double, double> delta)
@@ -180,7 +185,8 @@ namespace pdflib
       cell.push_back(font_key); // 17
       cell.push_back(font_name); // 18
 
-      cell.push_back(widget); //19
+      cell.push_back(widget); // 19
+      cell.push_back(left_to_right); // 20
     }
     assert(cell.size()==header.size());
 
@@ -219,6 +225,7 @@ namespace pdflib
         font_name = data.at(18).get<std::string>();
 
 	widget = data.at(19).get<bool>();
+	left_to_right = data.at(20).get<bool>();
 
         return true;
       }
@@ -255,26 +262,51 @@ namespace pdflib
 
   bool pdf_resource<PAGE_CELL>::is_adjacent_to(pdf_resource<PAGE_CELL>& other, double eps)
   {
-    //if(eps<0.0)
-    //{
-    //eps = average_char_width()/2.0;
-    //}
-    
     double d0 = std::sqrt((r_x1-other.r_x0)*(r_x1-other.r_x0) + (r_y1-other.r_y0)*(r_y1-other.r_y0));
     double d1 = std::sqrt((r_x2-other.r_x3)*(r_x2-other.r_x3) + (r_y2-other.r_y3)*(r_y2-other.r_y3));
 
     return ((d0<eps) and (d1<eps));
   }
 
+  bool pdf_resource<PAGE_CELL>::has_same_reading_orientation(pdf_resource<PAGE_CELL>& other)
+  {
+    // it might need is_punctuation function instead of just the space
+    bool is_punc = utils::string::is_punctuation_or_space(text);
+    bool other_is_punc = utils::string::is_punctuation_or_space(other.text);
+    
+    //return ((left_to_right==other.left_to_right) or (text==" " or other.text==" "));
+    return ((left_to_right==other.left_to_right) or (is_punc or other_is_punc)); 
+  }
+  
   bool pdf_resource<PAGE_CELL>::merge_with(pdf_resource<PAGE_CELL>& other, double delta)
   {
+    if(not has_same_reading_orientation(other))
+      {
+	LOG_S(ERROR) << "inconsistent merging of cells!";
+      }
+    
     double d0 = std::sqrt((r_x1-other.r_x0)*(r_x1-other.r_x0) + (r_y1-other.r_y0)*(r_y1-other.r_y0));
 
-    if(delta<d0)
+    if((not left_to_right) or (not other.left_to_right))
+      {
+	if(delta<d0)
+	  {
+	    text = " " + text;
+	  }    
+	text = other.text + text;
+
+	left_to_right = false;
+      }
+    else
       {
-	text += " ";
-      }    
-    text += other.text;
+	if(delta<d0)
+	  {
+	    text += " ";
+	  }    
+	text += other.text;
+
+	left_to_right = true;
+      }
 
     r_x1 = other.r_x1;
     r_y1 = other.r_y1;

src/v2/pdf_sanitators/cells.h

@@ -50,6 +50,7 @@ namespace pdflib
 
   private:
 
+    /*
     // FIXME: we might at some point move this into a file into the resources ...
     const static inline std::vector<std::pair<std::string, std::string> > replacements = {
       {R"(\f_f_i)", "ffi"},
@@ -106,7 +107,7 @@ namespace pdflib
       
       {"\u2212", "-"},
     };
-    
+    */
   };
 
   pdf_sanitator<PAGE_CELLS>::pdf_sanitator()
@@ -142,7 +143,12 @@ namespace pdflib
 		   utils::values::distance(cells[i].r_x2, cells[i].r_y2, cells[j].r_x2, cells[j].r_y2)<eps and
 		   utils::values::distance(cells[i].r_x3, cells[i].r_y3, cells[j].r_x3, cells[j].r_y3)<eps)
 		  {
-		    LOG_S(INFO) << "removing: " << cells[j].text << "(" << cells[i].r_x0 << ", " << cells[i].r_y0 << ") ";
+		    LOG_S(WARNING) << "removing duplicate char with text: '" << cells[j].text << "' "
+				   << "with r_0: (" << cells[i].r_x0 << ", " << cells[i].r_y0 << ") "
+				   << "with r_2: (" << cells[i].r_x2 << ", " << cells[i].r_y2 << ") "
+				   << "with r'_0: (" << cells[j].r_x0 << ", " << cells[j].r_y0 << ") "
+				   << "with r'_2: (" << cells[j].r_x2 << ", " << cells[j].r_y2 << ") ";
+
 
 		    cells[j].active = false;
 		    erased_cell = true;		    
@@ -174,11 +180,33 @@ namespace pdflib
       {
 	std::string& text = cells.at(i).text;
 
-	for(const std::pair<std::string, std::string>& pair:replacements)
+	for(const std::pair<std::string, std::string>& pair:text_constants::replacements)
 	  {
 	    utils::string::replace(text, pair.first, pair.second);
 	  }
       }
+
+    {
+      std::regex pattern(R"(^\/([A-Za-z])_([A-Za-z])(_([A-Za-z]))?$)");
+
+      for(int i=0; i<cells.size(); i++)
+	{
+	  std::string text = cells.at(i).text;
+	  
+	  std::smatch match;
+	  if(std::regex_match(text, match, pattern))
+	    {
+	      std::string replacement = match[1].str() + match[2].str();
+	      if(match[3].matched)
+		{
+		  replacement += match[4].str();
+		}
+	      
+	      LOG_S(WARNING) << "replacing `" << text << "` with `" << replacement << "`";	    
+	      cells.at(i).text = replacement;
+	    }
+	}      
+    }
   }
 
   void pdf_sanitator<PAGE_CELLS>::sanitize_bbox(pdf_resource<PAGE_CELLS>& cells,
@@ -356,6 +384,11 @@ namespace pdflib
 		    continue;
 		  }
 
+		if(not cells[i].has_same_reading_orientation(cells[j]))
+		  {
+		    continue;
+		  }
+		
 		double delta_0 = cells[i].average_char_width()*space_width_factor_for_merge;
 		double delta_1 = cells[i].average_char_width()*space_width_factor_for_merge_with_space;
 

src/v2/pdf_sanitators/constants.h

@@ -0,0 +1,81 @@
+//-*-C++-*-
+
+#ifndef PDF_CELLS_CONSTANTS_H
+#define PDF_CELLS_CONSTANTS_H
+
+namespace pdflib
+{
+
+  class text_constants
+  {
+
+  public:
+
+    // FIXME: we might at some point move this into a file into the resources ...
+    const static inline std::vector<std::pair<std::string, std::string> > replacements = {
+      {R"(\f_f_i)", "ffi"},
+      {R"(\f_f_l)", "ffl"},
+      {R"(\f_i)", "fi"},
+      {R"(\f_l)", "fl"},
+      {R"(\f_f)", "ff"},
+
+      {R"(/f_f_i)", "ffi"},
+      {R"(/f_f_l)", "ffl"},
+      {R"(/f_i)", "fi"},
+      {R"(/f_l)", "fl"},
+      {R"(/f_f)", "ff"},
+      
+      {R"(f_f_i)", "ffi"},
+      {R"(f_f_l)", "ffl"},
+      {R"(f_i)", "fi"},
+      {R"(f_l)", "fl"},
+      {R"(f_f)", "ff"},
+
+      {"\uFB00", "ff"},
+      {"\uFB01", "fi"},
+      {"\uFB02", "fl"},
+      {"\uFB03", "ffi"},
+      {"\uFB04", "ffl"},
+      
+      {"\u2000", " "},
+      {"\u2001", " "},
+      {"\u2002", " "},
+      {"\u2003", " "},
+      {"\u2004", " "},
+      {"\u2005", " "},
+      {"\u2006", " "},
+      {"\u2007", " "},
+      {"\u2008", " "},
+      {"\u2009", " "},      
+      {"\u200A", " "},
+
+      {"\u200B", ""},
+      {"\u200C", ""},
+      {"\u200D", ""},
+      {"\u200E", ""},
+      {"\u200F", ""},      
+      
+      {"\u2010", "-"},
+      {"\u2011", "-"},
+      {"\u2012", "-"},
+      {"\u2013", "-"},
+      {"\u2014", "-"},
+      {"\u2015", "-"},
+
+      {"\u2018", "'"},
+      {"\u2019", "'"},
+      {"\u201A", ","},
+      {"\u201B", "'"},
+      {"\u201C", "'"},
+      {"\u201D", "'"},
+      {"\u201E", "'"},
+      {"\u201F", "'"},
+      
+      {"\u2212", "-"},
+    };
+
+  };
+
+}
+
+#endif

src/v2/pdf_states/text.h

@@ -473,14 +473,28 @@ namespace pdflib
   {
     LOG_S(INFO) << __FUNCTION__ << " with text='" << text << "', width=" << width;
 
+    bool left_to_right = (not utils::string::is_right_to_left(text));
+    
     double font_descent = font.get_descent();
     double font_ascent  = font.get_ascent();
     double font_capheight  = font.get_capheight();
 
-    LOG_S(INFO) << "font_descent: " << font_descent << ", "
-		<< "font_ascent: " << font_ascent << ", "
-      		<< "font_capheight: " << font_capheight << ", "
-		<< "capheight/ascent: " << font_capheight/font_ascent << "";
+    if(left_to_right)
+      {
+	LOG_S(INFO) << "font_descent: " << font_descent << ", "
+		    << "font_ascent: " << font_ascent << ", "
+		    << "font_capheight: " << font_capheight << ", "
+		    << "capheight/ascent: " << font_capheight/font_ascent << ", "
+		    << "left_to_right: " << left_to_right << ", text: " << text;
+      }
+    else
+      {
+	LOG_S(WARNING) << "font_descent: " << font_descent << ", "
+		       << "font_ascent: " << font_ascent << ", "
+		       << "font_capheight: " << font_capheight << ", "
+		       << "capheight/ascent: " << font_capheight/font_ascent << ", "
+		       << "left_to_right: " << left_to_right << ", text: " << text;
+      }
 
     double space_width=0;
     {
@@ -498,6 +512,9 @@ namespace pdflib
     {
       pdf_resource<PAGE_CELL> cell;
 
+      cell.active = true;
+      cell.left_to_right = left_to_right;
+      
       cell.widget = false;
 
       double ratio = 1.0;
@@ -530,8 +547,6 @@ namespace pdflib
       cell.rendering_mode = rendering_mode;
 
       cell.space_width = space_width;
-      //cell.chars  = {};//chars;
-      //cell.widths = {};//widths;
 
       cell.enc_name = font.get_encoding_name();