tesseract-ocr 0.0.2 → 0.0.3

data/README.md

@@ -19,19 +19,30 @@ Example
 require 'tesseract'
 
 e = Tesseract::Engine.new {|e|
-	e.language  = :eng
-	e.blacklist = '|'
+  e.language  = :eng
+  e.blacklist = '|'
 }
 
 e.text_for('test/first.png').strip # => 'ABC'
-e.words_for('test/second.png') # => ["I'm", "12", "and", "what", "is", "this.", "INSTALL", "GENTOO", "OH", "HAI", "1234"]
 
-e.with { |e| e.whitelist = '1234567890' }.text_for('test/second.png') # => "11111 12 3116 1111113115111151\n11157411 6511700\n014 11141 1234\n\n"
+e.words_for('test/second.png') # [
+                               #      [ 0] #<Tesseract(93.41653442382812): "|'m">,
+                               #      [ 1] #<Tesseract(91.11811828613281): "12">,
+                               #      [ 2] #<Tesseract(85.71760559082031): "and">,
+                               #      [ 3] #<Tesseract(83.4853515625): "what">,
+                               #      [ 4] #<Tesseract(86.71072387695312): "is">,
+                               #      [ 5] #<Tesseract(83.2227783203125): "this.">,
+                               #      [ 6] #<Tesseract(82.81439208984375): "INSTALL">,
+                               #      [ 7] #<Tesseract(86.46566772460938): "GENTOO">,
+                               #      [ 8] #<Tesseract(93.19613647460938): "OH">,
+                               #      [ 9] #<Tesseract(82.81439208984375): "HAI">,
+                               #      [10] #<Tesseract(85.9158935546875): "1234">
+                               #  ]
 ```
 
-You can pass to `#text_for` either a path, an IO object or a string containing the image,
-there are few supported formats so try to stay in the BMP/JPEG/PNG boundaries. This means
-that you can also work on an image with RMagick or similar and then pass the raw data.
+You can pass to `#text_for` either a path, an IO object, a string containing the image or
+an object that responds to `#to_blob` (for example  Magick::Image), keep in mind that
+the format has to be supported by leptonica.
 
 Using the binary
 ----------------

data/Rakefile

@@ -5,6 +5,10 @@ task :default => :test
 
 task :test do
 	Dir.chdir 'test'
-
 	sh 'rspec tesseract_spec.rb --color --format doc'
 end
+
+task :bench do
+	Dir.chdir 'test'
+	sh 'ruby tesseract_bench.rb'
+end

data/examples/nerdz-captcha-breaker.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/env ruby
+require 'tesseract'
+require 'RMagick'
+
+def near (x, y)
+	[
+		[x - 1, y - 1],
+		[x,     y - 1],
+		[x + 1, y - 1],
+		[x - 1, y    ],
+		# FIRE IN THE HOLE
+		[x + 1, y    ],
+		[x - 1, y + 1],
+		[x,     y + 1],
+		[x + 1, y + 1]
+	]
+end
+
+Tesseract::Engine.new.tap {|engine|
+	ARGV.each {|path|
+		image  = Magick::Image.read(path).first
+		pixels = Hash.new { |h, k| h[k] = 0 }
+
+		image.each_pixel {|p|
+			pixels[p] += 1
+		}
+
+		pixels.delete(Magick::Pixel.from_color('black'))
+
+		text_color, count = pixels.max { |a, b| a.last <=> b.last }
+
+		image.each_pixel {|p, x, y|
+			next unless p == text_color or p.to_color == 'black'
+
+			image.pixel_color x, y, p == text_color ? 'black' : 'white'
+		}
+
+		image.each_pixel {|p, x, y|
+			next if p.to_color == 'black' || p.to_color == 'white'
+
+			if near(x, y).map { |(x, y)| image.pixel_color x, y }.any? { |p| p.to_color == 'black' }
+				image.pixel_color x, y, 'gray'
+			else
+				image.pixel_color x, y, 'white'
+			end
+		}
+
+		image.each_pixel {|p, x, y|
+			next unless p.to_color == 'gray'
+
+			image.pixel_color x, y, 'black'
+		}
+
+		puts engine.text_for(image.resize 10).strip
+	}
+}

data/lib/tesseract/api.rb

@@ -25,6 +25,9 @@
 require 'tesseract/extensions'
 require 'tesseract/c'
 
+require 'tesseract/api/image'
+require 'tesseract/api/iterator'
+
 module Tesseract
 
 class API
@@ -32,35 +35,7 @@ class API
 	# Get a pointer to a tesseract-ocr usable image from a path, a string
 	# with the data or an IO stream.
 	def self.image_for (image)
-		image = suppress_stderr {
-			if image.is_a?(String) && (File.exists?(File.expand_path(image)) rescue nil)
-				C::pix_read(File.expand_path(image))
-			elsif image.is_a?(String)
-				C::pix_read_mem(image, image.bytesize)
-			elsif image.is_a?(IO)
-				C::pix_read_stream(image.to_i)
-			end
-		}
-
-		raise ArgumentError, 'invalid image' if image.nil? || image.null?
-
-		image = FFI::AutoPointer.new(image, method(:image_finalizer))
-
-		class << image
-			def width
-				C::pix_get_width(self)
-			end
-
-			def height
-				C::pix_get_height(self)
-			end
-		end
-
-		image
-	end
-
-	def self.image_finalizer (pointer) # :nodoc:
-		C::pix_destroy(pointer)
+		Image.new(image)
 	end
 
 	##
@@ -79,35 +54,35 @@ class API
 	}
 
 	def initialize
-		@internal = FFI::AutoPointer.new(C::create, self.class.method(:finalizer))
+		@internal = FFI::AutoPointer.new(C::BaseAPI.create, self.class.method(:finalize))
 	end
 
-	def self.finalizer (pointer) # :nodoc:
-		C::destroy(pointer)
+	def self.finalize (pointer) # :nodoc:
+		C::BaseAPI.destroy(pointer)
 	end
 
 	def version
-		C::version(to_ffi)
+		C::BaseAPI.version(to_ffi)
 	end
 
 	def input_name= (name)
-		C::set_input_name(to_ffi, name)
+		C::BaseAPI.set_input_name(to_ffi, name)
 	end
 
 	def output_name= (name)
-		C::set_output_name(to_ffi, name)
+		C::BaseAPI.set_output_name(to_ffi, name)
 	end
 
 	def set_variable (name, value)
-		C::set_variable(to_ffi, name, value)
+		C::BaseAPI.set_variable(to_ffi, name, value)
 	end
 
 	def get_variable (name, type = nil)
 		if type.nil?
-			type = Types.keys.find { |type| C.__send__ "has_#{type}_variable", to_ffi, name }
+			type = Types.keys.find { |type| C::BaseAPI.__send__ "has_#{type}_variable", to_ffi, name }
 
 			if type
-				C.__send__ "get_#{type}_variable", to_ffi, name
+				C::BaseAPI.__send__ "get_#{type}_variable", to_ffi, name
 			end
 		else
 			unless Types.has_key?(type)
@@ -118,87 +93,83 @@ class API
 				type = name
 			end
 
-			if C.__send__ "has_#{type}_variable", to_ffi, name
-				C.__send__ "get_#{type}_variable", to_ffi, name
+			if C::BaseAPI.__send__ "has_#{type}_variable", to_ffi, name
+				C::BaseAPI.__send__ "get_#{type}_variable", to_ffi, name
 			end
 		end
 	end
 
 	def init (datapath = '.', language = 'eng', mode = :DEFAULT)
-		unless C::init(to_ffi, datapath, language.to_s, mode).zero?
+		unless C::BaseAPI.init(to_ffi, datapath, language.to_s, mode).zero?
 			raise 'the API did not Init correctly'
 		end
 	end
 
 	def read_config_file (path, init_only = false)
-		C::read_config_file(to_ffi, path, init_only)
+		C::BaseAPI.read_config_file(to_ffi, path, init_only)
 	end
 
-	def page_seg_mode
-		C::get_page_seg_mode(to_ffi)
+	def get_page_seg_mode
+		C::BaseAPI.get_page_seg_mode(to_ffi)
 	end
 
-	def page_seg_mode= (value)
-		C::set_page_seg_mode(to_ffi, value)
+	def set_page_seg_mode (value)
+		C::BaseAPI.set_page_seg_mode(to_ffi, value)
 	end
 
 	def set_image (pix)
-		C::set_image(to_ffi, pix)
+		C::BaseAPI.set_image(to_ffi, pix.is_a?(Image) ? pix.to_ffi : pix)
 	end
 
 	def set_rectangle (left, top, width, height)
-		C::set_rectangle(to_ffi, left, top, width, height)
+		C::BaseAPI.set_rectangle(to_ffi, left, top, width, height)
 	end
 
-	def get_text
-		pointer = C::get_utf8_text(to_ffi)
-		result  = pointer.read_string
-		result.force_encoding 'UTF-8'
-		C::free_string(pointer)
-
-		result
+	def get_iterator
+		Iterator.new(C::BaseAPI.get_iterator(to_ffi))
 	end
 
-	def get_hocr (page = 0)
-		pointer = C::get_hocr_text(to_ffi, page)
+	def get_text
+		pointer = C::BaseAPI.get_utf8_text(to_ffi)
 		result  = pointer.read_string
 		result.force_encoding 'UTF-8'
+		C.free_string(pointer)
 
 		result
 	end
 
 	def get_box (page = 0)
-		pointer = C::get_box_text(to_ffi, page)
+		pointer = C::BaseAPI.get_box_text(to_ffi, page)
 		result  = pointer.read_string
 		result.force_encoding 'UTF-8'
-		C::free_string(pointer)
+		C.free_string(pointer)
 
 		result
 	end
 
 	def get_unlv
-		pointer = C::get_unlv_text(to_ffi)
+		pointer = C::BaseAPI.get_unlv_text(to_ffi)
 		result  = pointer.read_string
 		result.force_encoding 'ISO8859-1'
-		C::free_string(pointer)
+		C.free_string(pointer)
 
 		result
 	end
 
 	def mean_text_confidence
-		C::mean_text_conf(to_ffi)
+		C::BaseAPI.mean_text_conf(to_ffi)
 	end
 
 	def all_word_confidences
-		C::all_word_confidences(to_ffi)
+		C::BaseAPI.all_word_confidences(to_ffi)
 	end
 
 	def clear
-		C::clear(to_ffi)
+		C::BaseAPI.clear(to_ffi)
 	end
 
 	def end
-		C::end(to_ffi)
+		C::BaseAPI.end(to_ffi)
 	end
 
 	def to_ffi

data/lib/tesseract/api/image.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright 2011 meh. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+#
+#    1. Redistributions of source code must retain the above copyright notice, this list of
+#       conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY meh ''AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL meh OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# The views and conclusions contained in the software and documentation are those of the
+# authors and should not be interpreted as representing official policies, either expressed
+# or implied, of meh.
+#++
+
+module Tesseract; class API
+
+class Image
+	def self.new (image)
+		image = if image.is_a?(String) && (File.exists?(File.expand_path(image)) rescue nil)
+			C::Leptonica.pix_read(File.expand_path(image))
+		elsif image.is_a?(String)
+			C::Leptonica.pix_read_mem(image, image.bytesize)
+		elsif image.is_a?(IO)
+			C::Leptonica.pix_read_stream(image.to_i)
+		elsif image.respond_to? :to_blob
+			image = image.to_blob
+
+			C::Leptonica.pix_read_mem(image, image.bytesize)
+		end
+
+		raise ArgumentError, 'invalid image' if image.nil? || image.null?
+
+		super(image)
+	end
+
+	attr_accessor :x, :y
+
+	def initialize (pointer, x = 0, y = 0)
+		@internal = FFI::AutoPointer.new(pointer, self.class.method(:finalize))
+		@x        = x
+		@y        = y
+	end
+
+	def self.finalize (pointer)
+		C::Leptonica.pix_destroy(pointer)
+	end
+
+	def width
+		C::Leptonica.pix_get_width(to_ffi)
+	end
+
+	def height
+		C::Leptonica.pix_get_height(to_ffi)
+	end
+
+	def to_blob (format = :default)
+		data = FFI::MemoryPointer.new(:pointer)
+		size = FFI::MemoryPointer.new(:size_t)
+
+		C::Leptonica.pix_write_mem(to_ffi, data, size, C.for_enum(format))
+
+		result = data.typecast(:pointer).read_string(size.typecast(:size_t))
+
+		data.typecast(:pointer).free
+
+		result
+	end
+
+	def to_ffi
+		@internal
+	end
+end
+
+end; end

data/lib/tesseract/api/iterator.rb

@@ -0,0 +1,122 @@
+#--
+# Copyright 2011 meh. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+#
+#    1. Redistributions of source code must retain the above copyright notice, this list of
+#       conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY meh ''AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL meh OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# The views and conclusions contained in the software and documentation are those of the
+# authors and should not be interpreted as representing official policies, either expressed
+# or implied, of meh.
+#++
+
+module Tesseract; class API
+
+class Iterator
+	def initialize (pointer)
+		raise ArgumentError, 'the pointer is null' if pointer.nil? || pointer.null?
+
+		@internal = FFI::AutoPointer.new(pointer, self.class.method(:finalize))
+	end
+
+	def self.finalize (pointer) # :nodoc:
+		C::Iterator.destroy(pointer)
+	end
+
+	def begin
+		C::Iterator.begin(to_ffi)
+	end
+
+	def beginning? (level = :word)
+		C::Iterator.is_at_beginning_of(to_ffi, C.for_enum(level))
+	end
+
+	def end? (level, element)
+		C::Iterator.is_at_final_element(to_ffi, C.for_enum(level), C.for_enum(element))
+	end
+
+	def next (level = :word)
+		C::Iterator.next(to_ffi, C.for_enum(level))
+	end
+
+	def bounding_box (level = :word)
+		C::Iterator.bounding_box(to_ffi, C.for_enum(level))
+	end
+
+	def get_binary_image (level = :word)
+		Image.new(C::Iterator.get_binary_image(to_ffi, C.for_enum(level)))
+	end
+
+	def get_image (level = :word, padding = 0)
+		image = C::Iterator.get_image(to_ffi, C.for_enum(level), padding)
+
+		Image.new(image.pix, image.x, image.y)
+	end
+
+	def baseline (level = :word)
+		C::Iterator.baseline(to_ffi, C.for_enum(level))
+	end
+
+	def orientation
+		C::Iterator.orientation(to_ffi)
+	end
+
+	def get_text (level = :word)
+		pointer = C::Iterator.get_utf8_text(to_ffi, C.for_enum(level))
+		result  = pointer.read_string
+		result.force_encoding 'UTF-8'
+		C.free_string(pointer)
+
+		result
+	end
+
+	def confidence (level = :word)
+		C::Iterator.confidence(to_ffi, C.for_enum(level))
+	end
+
+	def block_type
+		C::Iterator.block_type(to_ffi)
+	end
+
+	def word_font_attributes
+		C::Iterator.word_font_attributes(to_ffi)
+	end
+
+	def word_is_from_dictionary?
+		C::Iterator.word_is_from_dictionary(to_ffi)
+	end
+
+	def word_is_numeric?
+		C::Iterator.word_is_numeric(to_ffi)
+	end
+
+	def symbol_is_superscript?
+		C::Iterator.symbol_is_superscript(to_ffi)
+	end
+
+	def symbol_is_subscript?
+		C::Iterator.symbol_is_subscript(to_ffi)
+	end
+
+	def symbol_is_dropcap?
+		C::Iterator.symbol_is_dropcap(to_ffi)
+	end
+
+	def to_ffi
+		@internal
+	end
+end
+
+end; end