ruby_pager 0.1.1

data/lib/ruby_pager/image.rb

@@ -0,0 +1,338 @@
+require 'rmagick'
+#require 'set'
+#require 'ap'
+
+module Utils
+  class Image
+    def initialize(ex_path)
+      @logger = Utils::ApplicationLogger.instance
+      @image_path = ex_path
+      @logger.info("Loading image")
+      @img = Magick::ImageList.new(@image_path)
+      @increment = 200
+      @img_aux = Magick::Image.new(@img.columns+@increment,@img.rows){ self.background_color = "white" }
+      @intensity_calculated = false
+      @integral_calculated = false
+    end
+
+    def calculate_intensity_matrix
+      unless @intensity_calculated
+        @logger.info("Calculating intensity matrix")
+        @intensity_matrix = obtain_image_intensity_matrix #obtains the gray channel of the image
+        @logger.info("Calculating normalized intensity histogram")
+        @histogram = @intensity_matrix.to_normalized_histogram
+        @intensity_calculated=true
+      end
+    end
+
+
+    def rows
+      @img.rows
+    end
+
+    def columns
+      @img.columns
+    end
+
+
+    def display
+      @img.display {server_name = @image_path; delay=1}
+    end
+
+    def mean_of_region(from_x=@integral_image.row_size-1,from_y=@integral_image.column_size-1,region_height=@integral_image.row_size-1,region_width=@integral_image.column_size-1)
+      #if no parameters are given the input variables get assigned the default values indicated in the above specification and hence return the mean of the whole image
+      #raise "Region size provided exceeds the image boundaries" if from_y - region_width < 0 or from_x - region_height < 0
+
+=begin
+      
+      [1]-------[2] height + 1
+       |         |
+       |         |    basic formula is [4] - [2] - [3] + [1] but if [2] or [3] coincide with boundary size then 
+       |         |    we do not have to delete the region beyond width or height ( as there is no region beyond)
+       |         |    hence we do not have to add [1] to recover that corner section from being substracted twice
+      [3]-------[4]
+      width +1
+=end      
+    
+      res = @integral_image[from_x,from_y]
+      region_cuts = 0
+      
+      
+      if from_y - region_width > 0
+        res -= @integral_image[from_x,from_y-(region_width+1)]
+        region_cuts+=1
+      end
+      
+      if from_x - region_height > 0
+        res -= @integral_image[from_x-(region_height+1),from_y]
+        region_cuts+=1
+      end
+      
+      if region_cuts == 2
+        res += @integral_image[from_x-(region_height+1),from_y-(region_width+1)]
+      end
+      
+      return res.to_f/(region_height*region_width).to_f
+      
+    end
+    
+    def standard_deviation_of_region(mean,from_x=@integral_image.row_size-1,from_y=@integral_image.column_size-1,region_height=@integral_image.row_size-1,region_width=@integral_image.column_size-1)
+      #if no parameters are given the input variables get assigned the default values indicated in the above specification and hence return the deviation of the whole image
+      #raise "Region size provided exceeds the image boundaries" if from_y - region_width < 0 or from_x - region_height < 0
+
+      res = @sum_of_squares_intensity_matrix[from_x,from_y]
+      region_cuts = 0
+
+      if from_y - region_width > 0
+        res -= @sum_of_squares_intensity_matrix[from_x,from_y-(region_width+1)]
+        region_cuts+=1
+      end
+
+      if from_x - region_height > 0
+        res -= @sum_of_squares_intensity_matrix[from_x-(region_height+1),from_y]
+        region_cuts+=1
+      end
+
+      if region_cuts == 2
+        res += @sum_of_squares_intensity_matrix[from_x-(region_height+1),from_y-(region_width+1)]
+      end
+      
+      #region_width = region_width - from_y  if from_y - region_width < 0 
+     # region_height = region_height - from_x if from_x - region_height < 0 
+      
+      return Math.sqrt(((res.to_f/(region_height*region_width).to_f)-mean**2).abs)
+
+    end
+    
+    def obtain_image_intensity_matrix(img=@img)
+      return Matrix.rows(img.export_pixels(0,0,img.columns,img.rows,"I").each_slice(img.columns).reduce([]) {|x,y| x<<y })
+    end
+    
+    def intensity_matrix_to_image(intensity_matrix=@intensity_matrix)
+      @logger.info("Transforiming intensity matrix to image")
+      return Magick::Image.constitute(intensity_matrix.column_size, intensity_matrix.row_size,"I", intensity_matrix.to_elements)
+    end
+    
+    def to_file(path,img=@img)
+      @logger.info("Saving image to path: #{path}")
+      img.write(path)
+    end
+    
+    def calculate_integral_images(intensity_matrix=@intensity_matrix)
+      if not @integral_calculated
+      calculate_intensity_matrix unless @intensity_calculated
+      @logger.info("Calculating integral images")
+      res = intensity_matrix.clone
+      res2= intensity_matrix.clone
+      res.each_with_index do |val,x,y|
+        res2[x,y]=res2[x,y]**2
+        if x !=0 and y != 0
+          res[x,y]+=res[x-1,y]+res[x,y-1]-res[x-1,y-1]
+          res2[x,y]+=res2[x-1,y]+res2[x,y-1]-res2[x-1,y-1]
+        elsif x ==0 and y != 0
+          res[x,y]+=res[x,y-1]
+          res2[x,y]+=res2[x,y-1]
+        elsif x !=0 and y == 0
+          res[x,y]+=res[x-1,y]
+          res2[x,y]+=res2[x-1,y]
+        end
+      end
+      @integral_calculated=true
+      @sum_of_squares_intensity_matrix = res2
+      @integral_image = res
+      end
+    end
+    
+    def apply_threshold(threshold=0.5,intensity_matrix=@intensity_matrix)
+      threshold *= 255
+      intensity_matrix.map{|val| val < threshold ? 0.0 : 1.0 }
+    end
+    
+    def simple_binarization(intensity_matrix=@intensity_matrix,*params)
+      #1. select initial estimate T (between mean gray value and (min+max)/2, depending on the expected area of the objects)
+      median=(intensity_matrix.max+intensity_matrix.max)/2
+      mean=mean_of_region #uses the method with integral image, no input params means default input params 
+      threshold_old = Random.new.rand([mean,median].min..[mean,median].max)#selects a random value between the median and the mean
+      threshold_new = threshold_old
+      begin
+        threshold_old = threshold_new
+        mean_lower = 0; count_lower = 0 ; mean_higher = 0; count_higher = 0; 
+        #2. compute average value μ1 of pixels > T and μ2 of pixels ≤ T 
+        intensity_matrix.each do |val| 
+          if val < threshold_old
+            mean_lower+=val
+            count_lower+=1.0
+          else
+            mean_higher+=val
+            count_higher+=1.0
+          end
+        end
+        
+        mean_lower /= count_lower
+        mean_higher /= count_higher
+        
+        #3. T ← (μ1 + μ2)/2
+        threshold_new = (mean_lower + mean_higher) / 2
+        
+      end while (threshold_old - threshold_new).abs > 0.0001 #4. repeat from (2) until convergence
+      
+      threshold_new/=255.0
+      
+      return apply_threshold(threshold_new,intensity_matrix)
+      
+    end
+    
+    def otsu_binarization(intensity_matrix=@intensity_matrix,*params)
+      
+      percentage_calculated = 0
+      csum=0.0
+      sbmax=0.0
+      threshold = -1
+      sum = @histogram.inject(0.0){|res,(key,val)| res += key * val} #total sum of the histogram, in one line :-)
+      @histogram.each do |key,value| 
+        #we only visit the keys with values, hence we do not need to check if we have visited all filled buckets
+        percentage_calculated += value.to_f
+        percentage_pending = 1.0- percentage_calculated
+        
+        csum += (key * value).to_f
+        m1 = csum / percentage_calculated.to_f
+        m2 = (sum - csum) / percentage_pending.to_f
+        sb = (percentage_calculated * percentage_pending *((m1 - m2)**2)).to_f
+        if (sb > sbmax)
+          sbmax = sb
+          threshold = key
+        end
+      end
+      threshold/=255.0
+      return apply_threshold(threshold,intensity_matrix)
+      
+    end
+    
+    def niblack_binarization(intensity_matrix=@intensity_matrix,region_height=30,region_width=30)
+      
+      vec = intensity_matrix.each_with_index.map do |val,x,y|
+        
+        from_x = x+((region_height-1)/2) > intensity_matrix.row_size-1 ? intensity_matrix.row_size-1 : x+((region_height-1)/2)
+        from_y = y+((region_width-1)/2) > intensity_matrix.column_size-1 ? intensity_matrix.column_size-1 : y+((region_width-1)/2)
+        
+        @logger.debug("Im on #{x} #{y} - region is going to start on #{from_x} #{from_y}")
+        
+        mean = mean_of_region(from_x,from_y,region_height,region_width).to_f
+        
+        threshold = (mean - 0.2 * standard_deviation_of_region(mean,from_x,from_y,region_height,region_width).to_f).to_f
+        val < threshold ? 0.0 : 1.0 
+      end
+      
+      return Matrix.rows(vec.each_slice(intensity_matrix.column_size).reduce([]) {|x,y| x += [y] })
+      
+    end
+    
+    def binarize!(method,*params)
+      @logger.info("Performing #{method} binarization on image")
+      calculate_intensity_matrix
+      @intensity_matrix = send(method,@intensity_matrix,*params)
+      @logger.info("IMAGE CHANGED!! Recalculating internal representation")
+      @img=intensity_matrix_to_image(@intensity_matrix)
+      calculate_integral_images
+      @histogram = @intensity_matrix.to_normalized_histogram
+    end
+    
+    def draw_intensity_matrix(intensity_matrix=@intensity_matrix)
+      @logger.info("Drawing intensity matrix")
+      intensity_matrix_to_image(intensity_matrix).display
+    end
+    
+    def draw_binary_image(method,*params)
+      @logger.info("Performing #{method} binarization on image")
+      bin_mat = send(method,@intensity_matrix,*params)
+      draw_intensity_matrix(bin_mat)
+    end
+    
+    def save_binary_image(path,method,*params)
+      @logger.info("Performing #{method} binarization on image")
+      bin_mat = send(method)
+      to_file(path,intensity_matrix_to_image(bin_mat))
+    end
+    
+    
+    
+    def detect_connected_regions(neighbourhood,output_file,intensity_matrix=@intensity_matrix)
+      label_assignment_matrix = Matrix.build(intensity_matrix.row_size,intensity_matrix.column_size){0}
+      labels_translation = Hash.new
+      labels_translation[0]=0 #label of the empty regions
+      @logger.info("Detecting connected regions")
+      intensity_matrix.each_with_index do |val,x,y|
+        
+        next unless val.zero?        
+        
+        neighbour_labels = neighbour_labels_set(label_assignment_matrix,x,y,neighbourhood)
+                
+        if neighbour_labels.empty?
+          new_label=labels_translation.keys.last+1
+          labels_translation[new_label]=new_label
+          label_assignment_matrix[x,y]=new_label
+        else
+          #we always assign the label with least number, so that level equivalence translation will be linear
+          new_label=neighbour_labels.first
+          label_assignment_matrix[x,y]=new_label
+          neighbour_labels.each{|label| labels_translation[label]=new_label } if neighbour_labels.size > 1
+        end
+      end
+      
+      @logger.info("Translating region labels as per equivalence detected")
+      labels_translation.each{|key,val|labels_translation[key]=labels_translation[val] if key != val}
+      draw_connected_regions(extract_regions(label_assignment_matrix,labels_translation),output_file)
+      
+    end
+    
+    def neighbour_labels_set(label_assignment_matrix,x,y,neighbourhood)
+      result = SortedSet.new
+      
+      result.add(label_assignment_matrix[x-1,y]) 
+      result.add(label_assignment_matrix[x,y-1])
+      
+      if neighbourhood == 8
+        result.add(label_assignment_matrix[x-1,y-1])
+        result.add(label_assignment_matrix[x-1,y+1])         
+      end
+      
+      result.delete(nil)
+      result.delete(0)
+      
+      return result
+    end
+    
+    def extract_regions(label_assignment_matrix,label_translation)
+      @logger.info("Extracting regions to drawable format")
+      regions= Hash.new{|h,key|h[key]=Array.new} #Array that will initialize an array for the key if not specified yet
+      label_assignment_matrix.each_with_index do |val,x,y|
+        unless label_translation[val].zero?
+          region_target=label_translation[val]
+          regions[region_target].push([y,x])
+        end
+      end
+      
+      return regions
+    end
+      
+    def draw_connected_regions(region_list,output_file)
+      @logger.info("Drawing regions")
+      colors=["red","seagreen","royalblue","purple","sienna","steelblue","khaki","lightcoral","olive"]
+      region_list.each_value do |region|
+        gc = Magick::Draw.new 
+        gc.stroke_width = 1
+        gc.fill=colors.rotate![0]
+        region.each do |point|       
+          gc.point(point[0],point[1])  
+        end
+        gc.draw(@img)      
+      end
+      @img.display
+      to_file(output_file,@img)
+    end
+
+	private :niblack_binarization , :otsu_binarization, :simple_binarization, :apply_threshold, :calculate_integral_images
+  end
+  
+
+end

data/lib/ruby_pager/image_data.rb

@@ -0,0 +1,53 @@
+
+module RubyPager
+
+  class Image_Data
+
+    attr_reader :file_name ,:width ,:height
+    def initialize(ex_data)
+      @data=Hash.new
+      @data["@imageFilename"]=ex_data["@imageFilename"]
+      @data["@imageWidth"]=ex_data["@imageWidth"]
+      @data["@imageHeight"]=ex_data["@imageHeight"]
+      @file_name = @data["@imageFilename"]
+      @width = @data["@imageWidth"].to_i
+      @height = @data["@imageHeight"].to_i
+    end
+
+    def file_name= (ex_file_name)
+      raise(ArgumentError, "Got passed a non string object") if ex_file_name.class != String
+      @file_name=ex_file_name
+    end
+
+    def width=(ex_width)
+      raise(ArgumentError, "Got passed a non integer object") if ex_width.class != Fixnum or ex_width < 0
+      @width=ex_width
+    end
+
+    def height=(ex_height)
+      raise(ArgumentError, "Got passed a non integer object") if ex_height.class != Fixnum or ex_height < 0
+      @height=ex_height
+    end
+
+    def self.blank_data
+      res=Hash.new
+      res["@imageFilename"]=""
+      res["@imageWidth"]="0"
+      res["@imageHeight"]="0"
+      return res
+    end
+
+    def get_consolidated_data
+      consolidate_data()
+      return @data
+    end
+
+    private
+
+    def consolidate_data()
+      @data["@imageFilename"]=@file_name
+      @data["@imageWidth"]=@width.to_s
+      @data["@imageHeight"]=@height.to_s
+    end
+  end
+end

data/lib/ruby_pager/intersect.rb

@@ -0,0 +1,33 @@
+
+require 'rgeo'
+
+module RubyPager
+  class Intersect
+
+    def initialize(ex_object1, ex_object2, ex_mode)
+
+    end
+
+    def intersects?
+
+    end
+
+    def overlap_percentage
+
+    end
+
+    private
+
+    def run
+
+    end
+
+    def calculate_polygon_line_intersection
+
+    end
+
+    def calculate_polygon_polygon_intersection
+
+    end
+  end
+end

data/lib/ruby_pager/metadata.rb

@@ -0,0 +1,56 @@
+module RubyPager
+  class Metadata
+
+    attr_reader :creator
+    def initialize(ex_data)
+      @data=ex_data
+      @creator = @data["Creator"]
+      @created = DateTime.parse(@data["Created"])
+      @lastchange = DateTime.parse(@data["LastChange"])
+    end
+
+    def creator= (ex_creator)
+      raise(ArgumentError, "Got passed a non string object") if ex_creator.class != String
+      @creator=ex_creator
+    end
+
+    def created
+      return @created.strftime("%FT%T")
+    end
+
+    def created= (ex_created)
+      raise(ArgumentError, "Got passed a non DateTime object") if ex_created.class != DateTime
+      @created=ex_created
+    end
+
+    def lastchange
+      return @lastchange.strftime("%FT%T")
+    end
+
+    def lastchange= (ex_lastchange)
+      raise(ArgumentError, "Got passed a non DateTime object") if ex_lastchange.class != DateTime
+      @lastchange=ex_lastchange
+    end
+
+    def self.blank_data
+      res=Hash.new
+      res["Creator"]="Ruby Page"
+      res["Created"]=DateTime.now.strftime("%FT%T")
+      res["LastChange"]=DateTime.now.strftime("%FT%T")
+      return res
+    end
+
+    def get_consolidated_data
+      consolidate_data()
+      return @data
+    end
+
+    private
+
+    def consolidate_data()
+      @data["Creator"]=@creator
+      @data["Created"]=self.created
+      @data["LastChange"]=self.lastchange
+    end
+  end
+end

data/lib/ruby_pager/page.rb

@@ -0,0 +1,167 @@
+
+module RubyPager
+
+  class Page
+    attr_reader :file_name, :metadata, :image_data, :xmlns, :xmlns_xsi, :xsi_schemaLocation
+    def initialize(ex_file_name,ex_data)
+      @logger = Utils::ApplicationLogger.instance
+      @logger.info("Loading data from XML #{ex_file_name}")
+      @file_name=ex_file_name
+      @data=ex_data
+      @text_regions=Hash.new
+      @metadata=Metadata.new(@data["PcGts"]["Metadata"])
+      load_xml_schema_data
+      load_xml_image_info
+      load_text_regions
+      @reading_order=Reading_Order.new(@data["PcGts"]["Page"]["ReadingOrder"])
+    end
+
+    def self.load_from_xml(ex_file_name)
+      logger = Utils::ApplicationLogger.instance
+      logger.info("Loading XML #{ex_file_name}")
+      data=XML.load(ex_file_name)
+      return Page.new(ex_file_name,data)
+    end
+
+    def self.create_from_image(ex_image_name)
+      logger = Utils::ApplicationLogger.instance
+      logger.info("Generating XML for image #{ex_image_name}")
+      image=Utils::Image.new(ex_image_name)
+      data=self.blank_data
+      data["PcGts"]["Page"]["@imageFilename"]=ex_image_name
+      data["PcGts"]["Page"]["@imageWidth"]=image.rows.to_s
+      data["PcGts"]["Page"]["@imageHeight"]=image.columns.to_s
+      return Page.new(ex_image_name,data)
+    end
+
+    def self.blank(ex_image_name)
+      data=self.blank_data
+      return Page.new(ex_image_name,data)
+    end
+
+    def create_full_page_region(region_id)
+      @logger.info("Creating full page region #{region_id}")
+      data=Text_Region.blank_data
+      raise(ArgumentError, "Region id #{region_id} is already in use") if @text_regions.has_key? region_id
+      data["Coords"]["@points"]="0,0 0,#{@image_data.width} #{@image_data.height},#{@image_data.width} #{@image_data.height},0"
+      data["@id"]=region_id
+      push(Text_Region.new(0,data))
+    end
+
+    def save(ex_save_name=@file_name)
+      @logger.info("Saving page object #{@file_name} to #{ex_save_name}")
+      consolidate_data
+      XML.save(ex_save_name, @data)
+    end
+
+
+    def [](ex_key)
+      raise(RangeError, "Index #{ex_key} is out of range") unless @text_regions.has_key? ex_key
+      return @text_regions[ex_key]
+    end
+
+    def has_region?(ex_region_id)
+      return @text_regions.has_key? ex_region_id
+    end
+
+    def each_region
+      @text_regions.values.each {|text_region| yield text_region}
+    end
+
+    def delete(ex_region_id)
+      if has_region? ex_region_id
+        @logger.info("Deleting text region #{ex_region_id}")
+        @text_regions.delete(ex_region_id)
+        review_regions_index()
+      else
+        raise(ArgumentError, "Region id #{ex_region_id} does not exist so it can not be deleted")
+      end
+    end
+
+    def push(ex_text_region)
+      raise(ArgumentError, "Got passed a non text region object") if ex_text_region.class != RubyPager::Text_Region
+      raise(ArgumentError, "Region id #{ex_text_region.id} is already in use") if @text_regions.has_key? ex_text_region.id
+      ex_text_region.index=@text_regions.size
+      @text_regions[ex_text_region.id]=ex_text_region
+    end
+
+    def size
+      return @text_regions.size
+    end
+
+    def self.blank_data
+      logger = Utils::ApplicationLogger.instance
+      logger.info("Creating blank XML data")
+      res=Hash.new
+      res["PcGts"]=Hash.new
+      res["PcGts"]["Metadata"]=Metadata.blank_data
+      res["PcGts"]["@xmlns:xsi"]="http://www.w3.org/2001/XMLSchema-instance"
+      res["PcGts"]["@xmlns"]="http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15"
+      res["PcGts"]["@xsi:schemaLocation"]="http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15 http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15/pagecontent.xsd"
+      res["PcGts"]["@pcGtsId"]=""
+      res["PcGts"]["Page"]=Hash.new
+      res["PcGts"]["Page"]["TextRegion"]=Array.new
+      res["PcGts"]["Page"]["ReadingOrder"]=Hash.new
+      res["PcGts"]["Page"]["@imageFilename"]="blank.jpg"
+      res["PcGts"]["Page"]["@imageWidth"]="0"
+      res["PcGts"]["Page"]["@imageHeight"]="0"
+      return res
+    end
+
+    private
+
+    def review_regions_index
+      index =0
+      @text_regions.values.each {|region|
+        region.index=index
+        index+=1
+      }
+    end
+
+    def load_text_regions
+      if @data["PcGts"]["Page"]["TextRegion"]
+        if @data["PcGts"]["Page"]["TextRegion"].class == Array
+          region_array= @data["PcGts"]["Page"]["TextRegion"]
+          region_array.each_with_index {|text_region,index |
+            @text_regions[text_region["@id"]]=Text_Region.new(index,text_region)
+          }
+        end
+        if @data["PcGts"]["Page"]["TextRegion"].class == Hash
+          text_region= @data["PcGts"]["Page"]["TextRegion"]
+          @text_regions[text_region["@id"]]=Text_Region.new(0,text_region)
+        end
+      end
+    end
+
+    def load_xml_schema_data
+      @xmlns_xsi=@data["PcGts"]["@xmlns:xsi"]
+      @xmlns= @data["PcGts"]["@xmlns"]
+      @xsi_schemaLocation=@data["PcGts"]["@xsi:schemaLocation"]
+      @pc_gts_id=@data["PcGts"]["@pcGtsId"]
+    end
+
+    def load_xml_image_info
+      @image_data = Image_Data.new(@data["PcGts"]["Page"])
+    end
+
+    def consolidate_data
+      @data["PcGts"]["Metadata"]=@metadata.get_consolidated_data
+      @data["PcGts"]["@xmlns:xsi"]=@xmlns_xsi
+      @data["PcGts"]["@xmlns"]=@xmlns
+      @data["PcGts"]["@xsi:schemaLocation"]=@xsi_schemaLocation
+      @data["PcGts"]["@pcGtsId"]=@pc_gts_id
+      @data["PcGts"]["Page"]["ReadingOrder"]=@reading_order.get_consolidated_data
+      img_cons = @image_data.get_consolidated_data
+      @data["PcGts"]["Page"]["@imageFilename"]=img_cons["@imageFilename"]
+      @data["PcGts"]["Page"]["@imageWidth"]=img_cons["@imageWidth"]
+      @data["PcGts"]["Page"]["@imageHeight"]=img_cons["@imageHeight"]
+      @data["PcGts"]["Page"]["TextRegion"]=Array.new
+      @text_regions.values.each {|text_region|
+        @data["PcGts"]["Page"]["TextRegion"].push(text_region.get_consolidated_data)
+      }
+
+    end
+
+  end
+
+end

data/lib/ruby_pager/reading_order.rb

@@ -0,0 +1,18 @@
+module RubyPager
+  class Reading_Order
+    def initialize(ex_data)
+      @data=ex_data
+      #ap @data
+    end
+
+    def get_consolidated_data
+      consolidate_data()
+      return @data
+    end
+
+    private
+    def consolidate_data
+
+    end
+  end
+end