tabula-extractor 0.6.6-java → 0.7.0-java

data/ext/lsd.h

@@ -135,10 +135,10 @@
                        line segment number 'n+1' are obtained with
                        'out[7*n+0]' to 'out[7*n+6]'.
  */
-double * LineSegmentDetection( int * n_out,
-                               double * img, int X, int Y,
-                               double scale, double sigma_scale, double quant,
-                               double ang_th, double log_eps, double density_th,
+float * LineSegmentDetection( int * n_out,
+                               float * img, int X, int Y,
+                               float scale, float sigma_scale, float quant,
+                               float ang_th, float log_eps, float density_th,
                                int n_bins,
                                int ** reg_img, int * reg_x, int * reg_y );
 
@@ -203,8 +203,8 @@ double * LineSegmentDetection( int * n_out,
                        line segment number 'n+1' are obtained with
                        'out[7*n+0]' to 'out[7*n+6]'.
  */
-double * lsd_scale_region( int * n_out,
-                           double * img, int X, int Y, double scale,
+float * lsd_scale_region( int * n_out,
+                           float * img, int X, int Y, float scale,
                            int ** reg_img, int * reg_x, int * reg_y );
 
 /*----------------------------------------------------------------------------*/
@@ -244,7 +244,7 @@ double * lsd_scale_region( int * n_out,
                        line segment number 'n+1' are obtained with
                        'out[7*n+0]' to 'out[7*n+6]'.
  */
-double * lsd_scale(int * n_out, double * img, int X, int Y, double scale);
+float * lsd_scale(int * n_out, float * img, int X, int Y, float scale);
 
 /*----------------------------------------------------------------------------*/
 /** LSD Simple Interface
@@ -275,9 +275,9 @@ double * lsd_scale(int * n_out, double * img, int X, int Y, double scale);
                        line segment number 'n+1' are obtained with
                        'out[7*n+0]' to 'out[7*n+6]'.
  */
-double * lsd(int * n_out, double * img, int X, int Y);
+float * lsd(int * n_out, float * img, int X, int Y);
 
-void free_values(double * p);
+void free_values(float * p);
 
 #endif /* !LSD_HEADER */
 /*----------------------------------------------------------------------------*/

data/lib/tabula.rb

@@ -1,13 +1,30 @@
 module Tabula
   PDFBOX = 'pdfbox-app-2.0.0-SNAPSHOT.jar'
+  ONLY_SPACES_RE = Regexp.new('^\s+$')
 end
 
+require File.join(File.dirname(__FILE__), '../target/', Tabula::PDFBOX)
+
+import 'java.util.logging.LogManager'
+import 'java.util.logging.Level'
+
+lm = LogManager.log_manager
+lm.logger_names.each do |name|
+  if name == "" #rootlogger is apparently the logger PDFBox is talking to.
+    l = lm.get_logger(name)
+    l.level = Level::OFF
+    l.handlers.each do |h|
+      h.level = Level::OFF
+    end
+  end
+end
+
+
 require_relative './tabula/version'
+require_relative './tabula/core_ext'
 require_relative './tabula/entities'
-require_relative './tabula/pdf_dump'
+require_relative './tabula/extraction'
 require_relative './tabula/table_extractor'
 require_relative './tabula/writers'
-require_relative './tabula/table_guesser'
 require_relative './tabula/line_segment_detector'
 require_relative './tabula/pdf_render'
-#require_relative './tabula/whitespace'

data/lib/tabula/core_ext.rb

@@ -1,3 +1,19 @@
+java_import java.awt.geom.Point2D
+java_import java.awt.geom.Line2D
+java_import java.awt.geom.Rectangle2D
+java_import java.awt.Rectangle
+
+class Array
+  def rpad(padding, target_size)
+    if self.size < target_size
+      self + [padding] * (target_size - self.size)
+    else
+      self
+    end
+  end
+end
+
+
 module Enumerable
 
   def sum
@@ -23,3 +39,248 @@ module Enumerable
   end
 
 end
+
+class Point2D::Float
+  def inspect
+    toString
+  end
+
+  def to_json(*args)
+    [self.getX, self.getY].to_json(*args)
+  end
+
+  def hash
+    "#{self.getX},#{self.getY}".hash
+  end
+
+  def <=>(other)
+    return  1 if self.y > other.y
+    return -1 if self.y < other.y
+    return  1 if self.x  > other.x
+    return -1 if self.x  < other.x
+    return  0
+  end
+
+  def x_first_cmp(other)
+    return  1 if self.x  > other.x
+    return -1 if self.x  < other.x
+    return  1 if self.y > other.y
+    return -1 if self.y < other.y
+    return  0
+  end
+
+  def ==(other)
+    return self.x == other.x && self.y == other.y
+  end
+
+end
+
+class Line2D::Float
+  def to_json(*args)
+    [self.getX1, self.getY1, self.getX2, self.getY2].to_json(*args)
+  end
+
+  def inspect
+    "<Line2D::Float[(#{self.getX1},#{self.getY1}),(#{self.getX2},#{self.getY2})]>"
+  end
+
+  def rotate!(pointX, pointY, amount)
+    px1 = self.getX1 - pointX; px2 = self.getX2 - pointX
+    py1 = self.getY1 - pointY; py2 = self.getY2 - pointY
+
+    if amount == 90 || amount == -270
+      self.java_send :setLine, [Java::float, Java::float, Java::float, Java::float,], pointX - py2, pointY + px1, pointX - py1, pointY + px2
+    elsif amount == 270 || amount == -90
+      self.java_send :setLine, [Java::float, Java::float, Java::float, Java::float,], pointX + py1, pointY - px2, pointX + py2, pointY - px1
+    end
+
+  end
+
+  def transform!(affine_transform)
+    newP1, newP2 = Point2D::Float.new, Point2D::Float.new
+    affine_transform.transform(self.getP1, newP1)
+    affine_transform.transform(self.getP2, newP2)
+    setLine(newP1, newP2)
+    self
+  end
+
+  def snap!(cell_size)
+    newP1, newP2 = Point2D::Float.new, Point2D::Float.new
+    newP1.java_send :setLocation, [Java::float, Java::float], (self.getX1 / cell_size).round * cell_size, (self.getY1 / cell_size).round * cell_size
+    newP2.java_send :setLocation, [Java::float, Java::float], (self.getX2 / cell_size).round * cell_size, (self.getY2 / cell_size).round * cell_size
+    setLine(newP1, newP2)
+  end
+
+  def horizontal?(threshold=0.00001)
+    (self.getY2 - self.getY1).abs < threshold
+  end
+
+  def vertical?(threshold=0.00001)
+    (self.getX2 - self.getX1).abs < threshold
+  end
+
+end
+
+class Rectangle2D::Float
+  SIMILARITY_DIVISOR = 20
+
+  alias_method :top, :minY
+  alias_method :right, :maxX
+  alias_method :left, :minX
+  alias_method :bottom, :maxY
+
+
+  # Implement geometry stuff
+  #-------------------------
+
+  def dims(*format)
+    if format
+      format.map{|method| self.send(method)}
+    else
+      [self.x, self.y, self.width, self.height]
+    end
+  end
+
+  def top=(new_y)
+    delta_height = new_y - self.y
+    self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], self.x, new_y, self.width, (self.height - delta_height)
+
+    #used to be: (fixes test_vertical_rulings_splitting_words)
+    # self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], self.x, new_y, self.width, self.height
+  end
+
+  def bottom=(new_y2)
+    self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], self.x, self.y, self.width, new_y2 - self.y
+  end
+
+  def left=(new_x)
+    delta_width = new_x - self.x
+    self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], new_x, self.y, (self.width - delta_width), self.height
+    #used to be: (fixes test_vertical_rulings_splitting_words)
+    # self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], new_x, self.y, self.width, self.height
+  end
+
+  def right=(new_x2)
+    self.java_send :setRect, [Java::float, Java::float, Java::float, Java::float,], self.x, self.y, new_x2 - self.x, self.height
+  end
+
+  def area
+    self.width * self.height
+  end
+
+  # [x, y]
+  def midpoint
+    [horizontal_midpoint, vertical_midpoint]
+  end
+
+  def horizontal_midpoint
+    self.left + (self.width / 2)
+  end
+
+  def vertical_midpoint
+    self.top + (self.height / 2)
+  end
+
+  def horizontal_distance(other)
+    (other.left - self.right).abs
+  end
+
+  def vertical_distance(other)
+    (other.bottom - self.bottom).abs
+  end
+
+
+  # Various ways that rectangles can overlap one another
+  #------------------------------
+
+  # Roughly, detects if self and other belong to the same line
+  def vertically_overlaps?(other)
+    vertical_overlap = [0, [self.bottom, other.bottom].min - [self.top, other.top].max].max
+    vertical_overlap > 0
+  end
+
+  # detects if self and other belong to the same column
+  def horizontally_overlaps?(other)
+    horizontal_overlap = [0, [self.right, other.right].min  - [self.left, other.left].max].max
+    horizontal_overlap > 0
+  end
+
+  def overlaps?(other)
+    self.intersects(*other.dims(:x, :y, :width, :height))
+  end
+
+  def overlaps_with_ratio?(other, ratio_tolerance=0.00001)
+    self.overlap_ratio(other) > ratio_tolerance
+  end
+
+  def overlap_ratio(other)
+    intersection_width = [0, [self.right, other.right].min  - [self.left, other.left].max].max
+    intersection_height = [0, [self.bottom, other.bottom].min - [self.top, other.top].max].max
+    intersection_area = [0, intersection_height * intersection_width].max
+
+    union_area = self.area + other.area - intersection_area
+    intersection_area / union_area
+  end
+
+  # as defined by PDF-TREX paper
+  def horizontal_overlap_ratio(other)
+    delta = [self.bottom - self.top, other.bottom - other.top].min
+    if [other.top, self.top, other.bottom, self.bottom].sorted?
+      (other.bottom - self.top) / delta
+    elsif [self.top, other.top, self.bottom, other.bottom].sorted?
+      (self.bottom - other.top) / delta
+    elsif [self.top, other.top, other.bottom, self.bottom].sorted?
+      (other.bottom - other.top) / delta
+    elsif [other.top, self.top, self.bottom, other.bottom].sorted?
+      (self.bottom - self.top) / delta
+    else
+      0
+    end
+  end
+
+
+  # Funky custom methods (i.e. not just geometry)
+  #----------------------------------------------
+
+  #used for "deduping" similar rectangles detected via CV.
+  def similarity_hash
+    [self.x.to_i / SIMILARITY_DIVISOR, self.y.to_i / SIMILARITY_DIVISOR, self.width.to_i / SIMILARITY_DIVISOR, self.height.to_i / SIMILARITY_DIVISOR].to_s
+  end
+
+  def self.unionize(non_overlapping_rectangles, next_rect)
+    #if next_rect doesn't overlap any of non_overlapping_rectangles
+    if !(overlapping = non_overlapping_rectangles.compact.select{|r| next_rect.overlaps? r}).empty? &&
+         !non_overlapping_rectangles.empty?
+      #remove all of those that it overlaps from non_overlapping_rectangles and
+      non_overlapping_rectangles -= overlapping
+      #add to non_overlapping_rectangles the bounding box of the overlapping rectangles.
+      non_overlapping_rectangles << overlapping.inject(next_rect) do |memo, overlap|
+        #all we're doing is unioning `overlap` and `memo` and setting that result to `memo`
+        union(overlap, memo, memo) #I </3 Java.
+        memo
+      end
+    else
+      non_overlapping_rectangles << next_rect
+    end
+  end
+
+  def to_h
+    hash = {}
+    [:top, :left, :width, :height].each do |m|
+      hash[m] = self.send(m)
+    end
+    hash
+  end
+
+  def inspect
+    "#<Rectangle2D dims:[#{top}, #{left}, #{bottom}, #{right}]>"
+  end
+
+end
+
+# used only in GetBounds2D in an intermediate step in HasCells#find_spreadsheets_from_cells
+class Rectangle #java.awt.Rectangle
+  def inspect
+    "#<Rectangle dims:[x:#{x}, y:#{y}, w:#{width}, h:#{height}]>"
+  end
+end

data/lib/tabula/entities.rb

@@ -1,456 +1,11 @@
-module Tabula
-
-  class ZoneEntity
-    attr_accessor :top, :left, :width, :height
-
-    attr_accessor :texts
-
-    def initialize(top, left, width, height)
-      self.top = top
-      self.left = left
-      self.width = width
-      self.height = height
-      self.texts = []
-    end
-
-    def bottom
-      self.top + self.height
-    end
-
-    def right
-      self.left + self.width
-    end
-
-    # [x, y]
-    def midpoint
-      [self.left + (self.width / 2), self.top + (self.height / 2)]
-    end
-
-    def area
-      self.width * self.height
-    end
-
-    def merge!(other)
-      self.top    = [self.top, other.top].min
-      self.left   = [self.left, other.left].min
-      self.width  = [self.right, other.right].max - left
-      self.height = [self.bottom, other.bottom].max - top
-    end
-
-    def horizontal_distance(other)
-      (other.left - self.right).abs
-    end
-
-    def vertical_distance(other)
-      (other.bottom - self.bottom).abs
-    end
-
-    # Roughly, detects if self and other belong to the same line
-    def vertically_overlaps?(other)
-      vertical_overlap = [0, [self.bottom, other.bottom].min - [self.top, other.top].max].max
-      vertical_overlap > 0
-    end
-
-    # detects if self and other belong to the same column
-    def horizontally_overlaps?(other)
-      horizontal_overlap = [0, [self.right, other.right].min  - [self.left, other.left].max].max
-      horizontal_overlap > 0
-    end
-
-    def overlaps?(other, ratio_tolerance=0.00001)
-      self.overlap_ratio(other) > ratio_tolerance
-    end
-
-    def overlap_ratio(other)
-      intersection_width = [0, [self.right, other.right].min  - [self.left, other.left].max].max
-      intersection_height = [0, [self.bottom, other.bottom].min - [self.top, other.top].max].max
-      intersection_area = [0, intersection_height * intersection_width].max
-
-      union_area = self.area + other.area - intersection_area
-      intersection_area / union_area
-    end
-
-    # as defined by PDF-TREX paper
-    def horizontal_overlap_ratio(other)
-      delta = [self.bottom - self.top, other.bottom - other.top].min
-      if [other.top, self.top, other.bottom, self.bottom].sorted?
-        (other.bottom - self.top) / delta
-      elsif [self.top, other.top, self.bottom, other.bottom].sorted?
-        (self.bottom - other.top) / delta
-      elsif [self.top, other.top, other.bottom, self.bottom].sorted?
-        (other.bottom - other.top) / delta
-      elsif [other.top, self.top, self.bottom, other.bottom].sorted?
-        (self.bottom - self.top) / delta
-      else
-        0
-      end
-    end
-
-    def to_h
-      hash = {}
-      [:top, :left, :width, :height].each do |m|
-        hash[m] = self.send(m)
-      end
-      hash
-    end
-
-    def to_json(options={})
-      self.to_h.to_json
-    end
-  end
-
-  class Page < ZoneEntity
-    attr_reader :rotation, :number
-
-    def initialize(width, height, rotation, number, texts=[])
-      super(0, 0, width, height)
-      @rotation = rotation
-      @number = number
-      self.texts = texts
-    end
-
-    # get text, optionally from a provided area in the page [top, left, bottom, right]
-    def get_text(area=nil)
-      area = [0, 0, width, height] if area.nil?
-
-      # spaces are not detected, b/c they have height == 0
-      # ze = ZoneEntity.new(area[0], area[1], area[3] - area[1], area[2] - area[0])
-      # self.texts.select { |t| t.overlaps? ze }
-      self.texts.select do |t|
-        t.top > area[0] && t.top + t.height < area[2] && t.left > area[1] && t.left + t.width < area[3]
-      end
-    end
-
-    def to_json(options={})
-      { :width => self.width,
-        :height => self.height,
-        :number => self.number,
-        :rotation => self.rotation,
-        :texts => self.texts
-      }.to_json(options)
-    end
-
-  end
-
-  class TextElement < ZoneEntity
-    attr_accessor :font, :font_size, :text, :width_of_space
-
-    CHARACTER_DISTANCE_THRESHOLD = 1.5
-    TOLERANCE_FACTOR = 0.25 #25
-
-    def initialize(top, left, width, height, font, font_size, text, width_of_space)
-      super(top, left, width, height)
-      self.font = font
-      self.font_size = font_size
-      self.text = text
-      self.width_of_space = width_of_space
-    end
-
-    # more or less returns True if distance < tolerance
-    def should_merge?(other)
-      raise TypeError, "argument is not a TextElement" unless other.instance_of?(TextElement)
-      overlaps = self.vertically_overlaps?(other)
-
-      tolerance = ((self.font_size + other.font_size) / 2) * TOLERANCE_FACTOR
-
-      overlaps or
-        (self.height == 0 and other.height != 0) or
-        (other.height == 0 and self.height != 0) and
-        self.horizontal_distance(other) < tolerance
-    end
-
-    # more or less returns True if (tolerance <= distance < CHARACTER_DISTANCE_THRESHOLD*tolerance)
-    def should_add_space?(other)
-      raise TypeError, "argument is not a TextElement" unless other.instance_of?(TextElement)
-      overlaps = self.vertically_overlaps?(other)
-
-      up_tolerance = ((self.font_size + other.font_size) / 2) * TOLERANCE_FACTOR
-      down_tolerance = 0.90 #90?
-
-      dist = self.horizontal_distance(other).abs
-
-      rv = overlaps && (dist.between?(self.width_of_space * down_tolerance, self.width_of_space + up_tolerance))
-      rv
-    end
-
-    def merge!(other)
-      raise TypeError, "argument is not a TextElement" unless other.instance_of?(TextElement)
-      # unless self.horizontally_overlaps?(other) or self.vertically_overlaps?(other)
-      #   raise ArgumentError, "won't merge TextElements that don't overlap"
-      # end
-      if self.horizontally_overlaps?(other) and other.top < self.top
-        self.text = other.text + self.text
-      else
-        self.text << other.text
-      end
-      super(other)
-    end
-
-    def to_h
-      hash = super
-      [:font, :text].each do |m|
-        hash[m] = self.send(m)
-      end
-      hash
-    end
-  end
-
-  class Table
-    attr_reader :lines
-    def initialize(line_count, separators)
-      @separators = separators
-      @lines = (0...line_count).inject([]) { |m| m << Line.new }
-    end
-
-    def add_text_element(text_element, i, j)
-      if @lines.size <= i
-        @lines[i] = Line.new
-      end
-      if @lines[i].text_elements[j]
-        @lines[i].text_elements[j].merge!(text_element)
-      else
-        @lines[i].text_elements[j] = text_element
-      end
-    end
-  end
-
-  class Line < ZoneEntity
-    attr_accessor :text_elements
-    attr_reader :index
-
-    def initialize(index=nil)
-      self.text_elements = []
-      @index = index
-    end
-
-    def <<(t)
-      if self.text_elements.size == 0
-        self.text_elements << t
-        self.top = t.top
-        self.left = t.left
-        self.width = t.width
-        self.height = t.height
-      else
-        if in_same_column = self.text_elements.find { |te| te.horizontally_overlaps?(t) }
-          #sometimes a space needs to be added here
-          unless in_same_column.vertically_overlaps?(t)
-            t.text = " " + t.text
-          end
-          in_same_column.merge!(t)
-        else
-          self.text_elements << t
-          self.merge!(t)
-        end
-      end
-    end
-
-
-  end
-
-  class Column < ZoneEntity
-    attr_accessor :text_elements
-
-    def initialize(left, width, text_elements=[])
-      super(0, left, width, 0)
-      @text_elements = text_elements
-    end
-
-    def <<(te)
-      self.text_elements << te
-      self.update_boundaries!(te)
-      self.text_elements.sort_by! { |t| t.top }
-    end
-
-    def update_boundaries!(text_element)
-      self.merge!(text_element)
-    end
-
-    # this column can be merged with other_column?
-    def contains?(other_column)
-      self.horizontally_overlaps?(other_column)
-    end
-
-    def average_line_distance
-      # avg distance between lines
-      # this might help to MERGE lines that are shouldn't be split
-      # e.g. cells with > 1 lines of text
-      1.upto(self.text_elements.size - 1).map { |i|
-        self.text_elements[i].top - self.text_elements[i - 1].top
-      }.inject{ |sum, el| sum + el }.to_f / self.text_elements.size
-    end
-
-    def inspect
-      vars = (self.instance_variables - [:@text_elements]).map{ |v| "#{v}=#{instance_variable_get(v).inspect}" }
-      texts = self.text_elements.sort_by { |te| te.top }.map { |te| te.text }
-      "<#{self.class}: #{vars.join(', ')}, @text_elements=[#{texts.join('], [')}]>"
-    end
-
-  end
-
-  require_relative './core_ext'
-
-  class Ruling < ZoneEntity
-    # 2D line intersection test taken from comp.graphics.algorithms FAQ
-    def intersects?(other)
-      r = ((self.top-other.top)*(other.right-other.left) - (self.left-other.left)*(other.bottom-other.top)) \
-      / ((self.right-self.left)*(other.bottom-other.top)-(self.bottom-self.top)*(other.right-other.left))
-
-        s = ((self.top-other.top)*(self.right-self.left) - (self.left-other.left)*(self.bottom-self.top)) \
-            / ((self.right-self.left)*(other.bottom-other.top) - (self.bottom-self.top)*(other.right-other.left))
-
-      r >= 0 and r < 1 and s >= 0 and s < 1
-    end
-
-    def length
-      Math.sqrt( (self.right - self.left).abs ** 2 + (self.bottom - self.top).abs ** 2 )
-    end
-
-    def vertical?
-      left == right
-    end
-
-    def horizontal?
-      top == bottom
-    end
-
-    def right
-      left + width
-    end
-    def bottom
-      top + height
-    end
-
-    def to_json(arg)
-      [left, top, right, bottom].to_json
-    end
-
-    def to_xml
-      "<ruling x1=\"%.2f\" y1=\"%.2f\" x2=\"%.2f\" y2=\"%.2f\" />" \
-      % [left, top, right, bottom]
-    end
-
-    def self.clean_rulings(rulings, max_distance=4)
-
-      # merge horizontal and vertical lines
-      # TODO this should be iterative
-
-      skip = false
-
-      horiz = rulings.select { |r| r.horizontal? && r.width > max_distance }
-        .group_by(&:top)
-        .values.reduce([]) do |memo, rs|
-
-        rs = rs.sort_by(&:left)
-        if rs.size > 1
-          memo +=
-            rs.each_cons(2)
-            .chunk { |p| p[1].left - p[0].right < 7 }
-            .select { |c| c[0] }
-            .map { |group|
-            group = group.last.flatten.uniq
-            Tabula::Ruling.new(group[0].top,
-                               group[0].left,
-                               group[-1].right - group[0].left,
-                               0)
-          }
-          Tabula::Ruling.new(rs[0].top, rs[0].left, rs[-1].right - rs[0].left, 0)
-        else
-          memo << rs.first
-        end
-        memo
-      end
-      .sort_by(&:top)
-
-      h = []
-      horiz.size.times do |i|
-
-        if i == horiz.size - 1
-          h << horiz[-1]
-          break
-        end
-
-        if skip
-          skip = false;
-          next
-        end
-        d = (horiz[i+1].top - horiz[i].top).abs
-
-        h << if d < 4 # THRESHOLD DISTANCE between horizontal lines
-               skip = true
-               Tabula::Ruling.new(horiz[i].top + d / 2, [horiz[i].left, horiz[i+1].left].min, [horiz[i+1].width.abs, horiz[i].width.abs].max, 0)
-             else
-               horiz[i]
-             end
-      end
-      horiz = h
-
-      vert = rulings.select { |r| r.vertical? && r.height > max_distance }
-        .group_by(&:left)
-        .values
-        .reduce([]) do |memo, rs|
-
-          rs = rs.sort_by(&:top)
-
-          if rs.size > 1
-            # Here be dragons:
-            # merge consecutive segments of lines that are close enough
-            memo +=
-              rs.each_cons(2)
-              .chunk { |p| p[1].top - p[0].bottom < 7 }
-              .select { |c| c[0] }
-              .map { |group|
-                group = group.last.flatten.uniq
-                Tabula::Ruling.new(group[0].top,
-                                   group[0].left,
-                                   0,
-                                   group[-1].bottom - group[0].top)
-              }
-         else
-           memo << rs.first
-         end
-         memo
-      end.sort_by(&:left)
-
-      # v = []
-
-      # vert.size.times do |i|
-      #   if i == vert.size - 1
-      #     v << vert[-1]
-      #     break
-      #   end
-
-      #   if skip
-      #     skip = false;
-      #     next
-      #   end
-      #   d = (vert[i+1].left - vert[i].left).abs
-
-      #   v << if d < 4 # THRESHOLD DISTANCE between vertical lines
-      #          skip = true
-      #          Tabula::Ruling.new([vert[i+1].top, vert[i].top].min, vert[i].left + d / 2, 0, [vert[i+1].height.abs, vert[i].height.abs].max)
-      #        else
-      #          vert[i]
-      #        end
-      # end
-      # vert = v
-
-
-      # - only keep horizontal rulings that intersect with at least one vertical ruling
-      # - only keep vertical rulings that intersect with at least one horizontal ruling
-      # yeah, it's a naive heuristic. but hey, it works.
-
-      # h_mean =  horiz.reduce(0) { |accum, i| accum + i.width } / horiz.size
-      # horiz.reject { |h| h.width < h_mean }
-
-      #vert.delete_if  { |v| !horiz.any? { |h| h.intersects?(v) } } unless horiz.empty?
-      #horiz.delete_if { |h| !vert.any?  { |v| v.intersects?(h) } } unless vert.empty?
-
-      return horiz += vert
-    end
-
-
-
-
-  end
-
-end
+require_relative './entities/zone_entity'
+require_relative './entities/cell'
+require_relative './entities/has_cells'
+require_relative './entities/line'
+require_relative './entities/page'
+require_relative './entities/page_area'
+require_relative './entities/ruling'
+require_relative './entities/spreadsheet'
+require_relative './entities/table'
+require_relative './entities/text_chunk'
+require_relative './entities/text_element'