tesseract-ocr 0.0.2 → 0.0.3

data/lib/tesseract/c/iterator.rb

@@ -0,0 +1,282 @@
+#--
+# 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; module C
+
+module Iterator
+	extend FFI::Inliner
+
+	inline 'C++' do |cpp|
+		cpp.include   'tesseract/resultiterator.h'
+		cpp.libraries 'tesseract'
+
+		cpp.raw 'using namespace tesseract;'
+
+		cpp.eval {
+			enum :PolyBlockType, [
+				:UNKNOWN,
+				:FLOWING_TEXT, :HEADING_TEXT, :PULLOUT_TEXT, :TABLE, :VERTICAL_TEXT, :CAPTION_TEXT,
+				:FLOWING_IMAGE, :HEADING_IMAGE, :PULLOUT_IMAGE,
+				:HORZ_LINE, :VERT_LINE, :NOISE, :COUNT
+			]
+
+			enum :PageIteratorLevel, [
+				:BLOCK, :PARAGRAPH, :LINE, :WORD, :SYMBOL
+			]
+
+			orientation = enum :UP, :RIGHT, :DOWN, :LEFT
+			direction   = enum :LEFT_TO_RIGHT, :RIGHT_TO_LEFT, :TOP_TO_BOTTOM
+
+			BoundingBox = Class.new(FFI::Struct) {
+				layout \
+					:left,   :int,
+					:top,    :int,
+					:right,  :int,
+					:bottom, :int
+			}
+
+			Image = Class.new(FFI::Struct) {
+				layout \
+					:pix,  :pointer,
+					:x,    :int,
+					:y,    :int
+			}
+
+			Baseline = Class.new(FFI::Struct) {
+				layout \
+					:x1, :int,
+					:y1, :int,
+					:x2, :int,
+					:y2, :int
+			}
+
+			Orientation = Class.new(FFI::Struct) {
+				layout \
+					:orientation,       orientation,
+					:writing_direction, direction,
+					:textline_order,    direction,
+					:deskew_angle,      :float
+			}
+
+			FontAttributes = Class.new(FFI::Struct) {
+				layout \
+				:id,        :int,
+				:name,      :string,
+				:pointsize, :int,
+
+				:is_bold,       :bool,
+				:is_italic,     :bool,
+				:is_underlined, :bool,
+				:is_monospace,  :bool,
+				:is_serif,      :bool,
+				:is_smallcaps,  :bool
+			}
+
+			typedef BoundingBox.by_value,    :BoundingBox
+			typedef Image.by_value,          :Image
+			typedef Baseline.by_value,       :Baseline
+			typedef Orientation.by_value,    :OrientationResult
+			typedef FontAttributes.by_value, :FontAttributes
+		}
+
+		cpp.raw %{
+			typedef struct BoundingBox {
+				int left;
+				int top;
+				int right;
+				int bottom;
+			} BoundingBox;
+
+			typedef struct Image {
+				Pix* pix;
+				int  x;
+				int  y;
+			} Image;
+
+			typedef struct Baseline {
+				int x1;
+				int y1;
+				int x2;
+				int y2;
+			} Baseline;
+
+			typedef struct OrientationResult {
+				Orientation      orientation;
+				WritingDirection writing_direction;
+				TextlineOrder    textline_order;
+				float            deskew_angle;
+			} OrientationResult;
+
+			typedef struct FontAttributes {
+				int         id;
+				const char* name;
+				int         pointsize;
+
+				bool is_bold;
+				bool is_italic;
+				bool is_underlined;
+				bool is_monospace;
+				bool is_serif;
+				bool is_smallcaps;
+			} FontAttributes;
+		}
+
+		cpp.function %{
+			void destroy (PageIterator* it) {
+				delete it;
+			}
+		}
+
+		cpp.function %{
+			void begin (PageIterator* it) {
+				it->Begin();
+			}
+		}
+
+		cpp.function %{
+			bool next (PageIterator* it, PageIteratorLevel level) {
+				return it->Next(level);
+			}
+		}
+
+		cpp.function %{
+			bool is_at_beginning_of (PageIterator* it, PageIteratorLevel level) {
+				return it->IsAtBeginningOf(level);
+			}
+		}
+
+		cpp.function %{
+			bool is_at_final_element (PageIterator* it, PageIteratorLevel level, PageIteratorLevel element) {
+				return it->IsAtFinalElement(level, element);
+			}
+		}
+
+		cpp.function %{
+			BoundingBox bounding_box (PageIterator* it, PageIteratorLevel level) {
+				BoundingBox result;
+
+				it->BoundingBox(level, &result.left, &result.top, &result.right, &result.bottom);
+				
+				return result;
+			}
+		}
+
+		cpp.function %{
+			PolyBlockType block_type (PageIterator* it) {
+				return it->BlockType();
+			}
+		}
+
+		cpp.function %{
+			Pix* get_binary_image (PageIterator* it, PageIteratorLevel level) {
+				return it->GetBinaryImage(level);
+			}
+		}
+
+		cpp.function %{
+			Image get_image (PageIterator* it, PageIteratorLevel level, int padding) {
+				Image result;
+
+				result.pix = it->GetImage(level, padding, &result.x, &result.y);
+
+				return result;
+			}
+		}
+
+		cpp.function %{
+			Baseline baseline (PageIterator* it, PageIteratorLevel level) {
+				Baseline result;
+
+				it->Baseline(level, &result.x1, &result.y1, &result.x2, &result.y2);
+
+				return result;
+			}
+		}
+
+		cpp.function %{
+			OrientationResult orientation (PageIterator* it) {
+				OrientationResult result;
+				
+				it->Orientation(&result.orientation, &result.writing_direction, &result.textline_order, &result.deskew_angle);
+
+				return result;
+			}
+		}
+
+		cpp.function %{
+			char* get_utf8_text (ResultIterator* it, PageIteratorLevel level) {
+				return it->GetUTF8Text(level);
+			}
+		}
+
+		cpp.function %{
+			float confidence (ResultIterator* it, PageIteratorLevel level) {
+				return it->Confidence(level);
+			}
+		}
+
+		cpp.function %{
+			FontAttributes word_font_attributes (ResultIterator* it) {
+				FontAttributes result;
+
+				result.name = it->WordFontAttributes(&result.is_bold, &result.is_italic, &result.is_underlined,
+					&result.is_monospace, &result.is_serif, &result.is_smallcaps, &result.pointsize, &result.id);
+
+				return result;
+			}
+		}
+
+		cpp.function %{
+			bool word_is_from_dictionary (ResultIterator* it) {
+				return it->WordIsFromDictionary();
+			}
+		}
+
+		cpp.function %{
+			bool word_is_numeric (ResultIterator* it) {
+				return it->WordIsNumeric();
+			}
+		}
+
+		cpp.function %{
+			bool symbol_is_superscript (ResultIterator* it) {
+				return it->SymbolIsSuperscript();
+			}
+		}
+
+		cpp.function %{
+			bool symbol_is_subscript (ResultIterator* it) {
+				return it->SymbolIsSubscript();
+			}
+		}
+
+		cpp.function %{
+			bool symbol_is_dropcap (ResultIterator* it) {
+				return it->SymbolIsDropcap();
+			}
+		}
+	end
+end
+
+end; end

data/lib/tesseract/c/leptonica.rb

@@ -0,0 +1,88 @@
+#--
+# 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; module C
+
+module Leptonica
+	extend FFI::Inliner
+
+	inline 'C++' do |cpp|
+		cpp.include   'leptonica/allheaders.h'
+		cpp.libraries 'lept'
+
+		cpp.eval {
+			enum :Format, [
+				:UNKNOWN, :BMP, :JFIF_JPEG, :PNG,
+				:TIFF, :TIFF_PACKBITS, :TIFF_RLE, :TIFF_G3, :TIFF_G4, :TIFF_LZW, :TIFF_ZIP,
+				:PNM, :PS, :GIF, :JP2, :WEBP, :LPDF, :DEFAULT, :SPIX
+			]
+		}
+
+		cpp.typedef 'int32_t', 'Format'
+
+		cpp.function %{
+			Pix* pix_read (const char* path) {
+				return pixRead(path);
+			}
+		}
+
+		cpp.function %{
+			Pix* pix_read_fd (int fd) {
+				return pixReadStream(fdopen(fd, "rb"), 0);
+			}
+		}
+
+		cpp.function %{
+			Pix* pix_read_mem (const l_uint8* data, size_t size) {
+				return pixReadMem(data, size);
+			}
+		}
+
+		cpp.function %{
+			bool pix_write_mem (Pix* pix, uint8_t** data, size_t* size, Format format) {
+				return pixWriteMem(data, size, pix, format);
+			}
+		}
+
+		cpp.function %{
+			void pix_destroy (Pix* pix) {
+				pixDestroy(&pix);
+			}
+		}
+
+		cpp.function %{
+			int32_t pix_get_width (Pix* pix) {
+				return pixGetWidth(pix);
+			}
+		}
+
+		cpp.function %{
+			int32_t pix_get_height (Pix* pix) {
+				return pixGetHeight(pix);
+			}
+		}
+	end
+end
+
+end; end

data/lib/tesseract/engine.rb

@@ -24,6 +24,8 @@
 
 require 'tesseract/api'
 
+require 'tesseract/engine/iterator'
+
 module Tesseract
 
 class Engine
@@ -32,16 +34,18 @@ class Engine
 	namedic :path, :language, :mode, :variables,
 		:optional => { :path => '.', :language => :eng, :mode => :DEFAULT, :variables => {}, :config => [] },
 		:alias    => { :data => :path, :lang => :language }
-	def initialize (path = '.', language = :eng, mode = :DEFAULT, variables = {}, config = []) # :yields: self
+	def initialize (path = '.', language = :eng, mode = :DEFAULT, variables = {}, config = [], &block) # :yields: self
 		@api = API.new
 
 		@initializing = true
 
+		@init      = block
 		@path      = path
 		@language  = language
 		@mode      = mode
 		@variables = variables
 		@config    = config
+		@rectangle = []
 
 		yield self if block_given?
 
@@ -65,7 +69,10 @@ class Engine
 	end
 
 	def with (&block) # :yields: self
-		self.class.new(@path, @language, @mode, @variables.clone, &block)
+		self.class.new(@path, @language, @mode, @variables.clone, @config.clone) {|e|
+			@init.call(e) if @init
+			block.call(e) if block
+		}
 	end
 
 	def set (name, value)
@@ -111,35 +118,25 @@ class Engine
 	end
 
 	def page_segmentation_mode= (value)
-		@api.page_seg_mode = if value.to_i >= 1 && value.to_i <= 10
-			value.to_i
-		else
-			value.to_s.upcase.to_sym
-		end
+		@api.set_page_seg_mode C.for_enum(value)
 	end
 
 	def image= (image)
 		@image = image
 	end
 
+	namedic :x, :y, :width, :height,
+		:optional => 0 .. -1,
+		:alias    => { :w => :width, :h => :height }
+	def select (x = nil, y = nil, width = nil, height = nil)
+		@rectangle = [x, y, width, height]
+	end
+
 	namedic :image, :x, :y, :width, :height,
 		:optional => 0 .. -1,
 		:alias    => { :w => :width, :h => :height }
 	def text_for (image = nil, x = nil, y = nil, width = nil, height = nil)
-		image ||= @image or raise ArgumentError, 'you have to set an image first'
-		image   = API.image_for(image)
-
-		x      ||= 0
-		y      ||= 0
-		width  ||= image.width
-		height ||= image.height
-
-		if (x + width) > image.width || (y + height) > image.height
-			raise IndexError, 'image access out of boundaries'
-		end
-
-		@api.set_image(image)
-		@api.set_rectangle(x, y, width, height)
+		_setup(image, x, y, width, height)
 
 		@api.get_text.tap {|text|
 			text.instance_exec(@api) {|api|
@@ -160,61 +157,40 @@ class Engine
 		text_for(nil, x, y, width, height)
 	end
 
-	def words_for (*args)
-		_confidences(text_for(*args).split(/\s+/))
+	def text
+		text_at
 	end
 
-	def words_at (*args)
-		_confidences(text_at(*args).split(/\s+/))
-	end
+	%w(block paragraph line word symbol).each {|level|
+		define_method "each_#{level}" do |&block|
+			raise ArgumentError, 'you have to pass a block' unless block
 
-	namedic :image, :page, :x, :y, :width, :height,
-		:optional => 0 .. -1,
-		:alias    => { :w => :width, :h => :height }
-	def chars_for (image = nil, page = nil, x = nil, y = nil, width = nil, height = nil)
-		image ||= @image or raise ArgumentError, 'you have to set an image first'
-		image   = API.image_for(image)
-
-		page   ||= 0
-		x      ||= 0
-		y      ||= 0
-		width  ||= image.width
-		height ||= image.height
-
-		if (x + width) > image.width || (y + height) > image.height
-			raise IndexError, 'image access out of boundaries'
+			_iterator.__send__ "each_#{level}", &block
 		end
 
-		@api.set_image(image)
-		@api.set_rectangle(x, y, width, height)
-
-		@api.get_box(page).lines.map {|line|
-			char, x, y, width, height, page = line.chomp.split ' '
-
-			char.instance_eval {
-				@x      = x.to_i
-				@y      = y.to_i
-				@width  = width.to_i
-				@height = height.to_i
-				@page   = page.to_i
+		define_method "#{level}s" do
+			_iterator.__send__ "#{level}s"
+		end
 
-				class << self
-					attr_reader :x, :y, :width, :height, :page
-				end
-			}
+		namedic :image, :x, :y, :width, :height,
+			:optional => 0 .. -1,
+			:alias    => { :w => :width, :h => :height }
+		define_method "#{level}s_for" do |image = nil, x = nil, y = nil, width = nil, height = nil|
+			self.image = image if image
+			select x, y, width, height
 
-			char
-		}
-	end
+			__send__("#{level}s")
+		end
 
-	namedic :page, :x, :y, :width, :height,
-		:optional => 0 .. -1,
-		:alias    => { :w => :width, :h => :height }
-	def chars_at (page = nil, x = nil, y = nil, width = nil, height = nil)
-		chars_for(nil, page, x, y, width, height)
-	end
+		namedic :x, :y, :width, :height,
+			:optional => 0 .. -1,
+			:alias    => { :w => :width, :h => :height }
+		define_method "#{level}s_at" do |x = nil, y = nil, width = nil, height = nil|
+			__send__("#{level}s_for", nil, x, y, width, height)
+		end
+	}
 
-private
+protected
 	def _init
 		@api.end
 
@@ -229,27 +205,41 @@ private
 		}
 	end
 
-	def _confidences (words)
-		pointer = @api.all_word_confidences
-		current = 0
+	def _setup (image = nil, x = nil, y = nil, width = nil, height = nil)
+		image ||= @image or raise ArgumentError, 'you have to set an image first'
+		image   = API.image_for(image)
 
-		while (tmp = pointer.get_int(current)) != -1
-			break unless words[current]
+		if !width && x
+			width = image.width - x
+		end
 
-			words[current].instance_eval {
-				@confidence = tmp
+		if !height && y
+			height = image.height - y
+		end
 
-				class << self
-					attr_reader :confidence
-				end
-			}
+		x      ||= @rectangle[0] || 0
+		y      ||= @rectangle[1] || 0
+		width  ||= @rectangle[2] || image.width
+		height ||= @rectangle[3] || image.height
 
-			current += 1
+		if (x + width) > image.width || (y + height) > image.height
+			raise IndexError, 'image access out of boundaries'
 		end
 
-		C::free_array_of_int(pointer)
+		@api.set_image(image)
+		@api.set_rectangle(x, y, width, height)
+	end
+
+	def _recognize
+		_setup
+
+		@api.get_text
+	end
+
+	def _iterator
+		_recognize
 
-		words
+		Iterator.new(@api.get_iterator)
 	end
 end