udise_captcha_reader 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ad22c9c9ccbecfb3c8e6de058ea6aea678d217e8e4547ec245b2ff8daa2b4b3
+  data.tar.gz: d0a2015a3a1706582678e73199d90266a32bf1643a016578f3e86d5a22286270
+SHA512:
+  metadata.gz: 858984958f5332fa431d16a228f781dda76a1a0d03b096511f8cda39aeaa790d684f2ab70ed60a04557c29a1987588749d42bd33d7254319f52aae3ec6368746
+  data.tar.gz: f068ac564918ba5dc593239a0a6a7516254bd6970432cfdccb637f3cfedbeeaea75338af9f087ccff984ef03a3d1f3a80e0739c0a74e33a93697dc59a15ae20a

data/lib/udise_captcha_reader/character_recognizer.rb

@@ -0,0 +1,122 @@
+require "rtesseract"
+require "mini_magick"
+
+module UdiseCaptchaReader
+  class CharacterRecognizer
+    CHAR_SIZE = 32  # Target size for normalized characters
+
+    def initialize(options = {})
+      @options = {
+        lang: "eng",
+        processor: "mini_magick",
+        psm: 10,
+        oem: 1
+      }.merge(options)
+    end
+
+    def recognize_character(image_file)
+      image = MiniMagick::Image.open(image_file.path)
+      
+      # Normalize the character size
+      width = image.width
+      height = image.height
+      scale = CHAR_SIZE / [width, height].max.to_f
+      
+      # Create a normalized version
+      image.combine_options do |b|
+        # Resize to standard size
+        b.resize "#{(width * scale).round}x#{(height * scale).round}"
+        
+        # Center in a fixed-size canvas
+        b.background "white"
+        b.gravity "center"
+        b.extent "#{CHAR_SIZE}x#{CHAR_SIZE}"
+        
+        # Convert to grayscale and adjust contrast
+        b.colorspace "gray"
+        b.brightness_contrast "10x20"  # Slight brightness boost and contrast
+        
+        # Clean threshold
+        b.black_threshold "80%"
+        b.white_threshold "20%"
+      end
+      
+      # Save normalized image
+      temp_output = Tempfile.new(['norm_char', '.png'])
+      image.write(temp_output.path)
+      
+      # Try recognition with specific configurations
+      results = []
+      
+      # Configuration attempts
+      configs = [
+        { psm: 10, whitelist: "0123456789abcdef" },
+        { psm: 10, whitelist: "0123456789" },  # Numbers only
+        { psm: 10, whitelist: "abcdef" }  # Hex letters only
+      ]
+      
+      configs.each do |config|
+        result = RTesseract.new(
+          temp_output.path,
+          lang: @options[:lang],
+          processor: @options[:processor],
+          psm: config[:psm],
+          oem: 1,
+          options: {
+            "tessedit_char_whitelist" => config[:whitelist],
+            "tessedit_ocr_engine_mode" => "1",
+            "tessedit_pageseg_mode" => config[:psm].to_s,
+            "tessdata_dir" => "/usr/local/share/tessdata",  # Ensure using latest tessdata
+            "load_system_dawg" => "0",  # Disable dictionary
+            "load_freq_dawg" => "0"     # Disable frequency-based corrections
+          }
+        ).to_s.strip.downcase
+        
+        results << result unless result.empty?
+      end
+      
+      # Try with inverted image if no results
+      if results.empty?
+        image.negate
+        image.write(temp_output.path)
+        
+        configs.each do |config|
+          result = RTesseract.new(
+            temp_output.path,
+            lang: @options[:lang],
+            processor: @options[:processor],
+            psm: config[:psm],
+            oem: 1,
+            options: {
+              "tessedit_char_whitelist" => config[:whitelist],
+              "tessedit_ocr_engine_mode" => "1",
+              "tessedit_pageseg_mode" => config[:psm].to_s,
+              "tessdata_dir" => "/usr/local/share/tessdata",
+              "load_system_dawg" => "0",
+              "load_freq_dawg" => "0"
+            }
+          ).to_s.strip.downcase
+          
+          results << result unless result.empty?
+        end
+      end
+      
+      # Clean up
+      temp_output.unlink
+      
+      # Process results
+      char_counts = Hash.new(0)
+      results.each do |result|
+        next if result.empty?
+        char = result[0].downcase
+        # Map commonly confused characters
+        char = '1' if char == 'i' || char == 'l' || char == '|'
+        char = '0' if char == 'o'
+        char_counts[char] += 1 if char.match?(/^[a-f0-9]/)
+      end
+      
+      return '' if char_counts.empty?
+      char_counts.max_by { |_, count| count }[0]
+    end
+  end
+end 

data/lib/udise_captcha_reader/character_splitter.rb

@@ -0,0 +1,411 @@
+require "mini_magick"
+
+module UdiseCaptchaReader
+  class CharacterSplitter
+    def self.split_into_characters(image, original_filename)
+      # Get image dimensions
+      width = image.width
+      height = image.height
+
+      # Create a gridded version of the image
+      gridded = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      
+      # Convert to black and white for checking overlaps
+      bw_image = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      bw_image.combine_options do |b|
+        b.colorspace "gray"
+        b.threshold "50%"
+      end
+      
+      # Track potential split positions (red lines)
+      potential_splits = []
+      
+      # Draw grid and find splits
+      gridded.combine_options do |c|
+        c.strokewidth "0.5"  # Made thinner
+        
+        # Calculate horizontal line positions
+        horizontal_y_positions = 10.times.map { |i| ((i + 1) * height / 11.0).round }
+        
+        # Draw oblique lines and find splits
+        100.times do |i|
+          x = ((i + 1) * width / 101.0).round  # 101 segments = 100 lines
+          
+          # Calculate end point for -15 degree angle
+          angle_rad = -15 * Math::PI / 180  # Convert -15 degrees to radians
+          x_offset = (height * Math.tan(angle_rad)).round
+          end_x = x + x_offset
+          
+          # Check intersection points with horizontal lines
+          black_intersection_count = 0
+          horizontal_y_positions.each do |y|
+            # Calculate x position at this y level
+            progress = y.to_f / height
+            intersect_x = x + (x_offset * progress).round
+            next if intersect_x < 0 || intersect_x >= width
+            
+            # Check 3-pixel wide column at intersection
+            intersection_has_black = false
+            (-1..1).each do |offset|
+              check_x = intersect_x + offset
+              next if check_x < 0 || check_x >= width
+              
+              result = MiniMagick::Tool::Convert.new do |convert|
+                convert << bw_image.path
+                convert.crop("1x1+#{check_x}+#{y}")
+                convert << "txt:-"
+              end
+              
+              if result.include?("#000000") || result.include?("black")
+                intersection_has_black = true
+                break
+              end
+            end
+            
+            black_intersection_count += 1 if intersection_has_black
+            break if black_intersection_count > 1  # No need to check more if we're already over threshold
+          end
+          
+          # Set color based on intersection checks - allow up to 1 black intersection
+          if black_intersection_count > 1
+            c.stroke "blue"
+            c.strokewidth "0.75"  # Slightly thicker for overlapping lines
+          else
+            c.stroke "red"
+            c.strokewidth "0.5"
+            potential_splits << {x: x, end_x: end_x} if x > width * 0.10 && x < width * 0.90  # Store positions if not too close to edges
+          end
+          c.draw "line #{x},0 #{end_x},#{height}"
+        end
+        
+        # Draw 10 horizontal black lines
+        c.stroke "black"
+        c.strokewidth "0.5"
+        horizontal_y_positions.each do |y|
+          c.draw "line 0,#{y} #{width},#{y}"
+        end
+      end
+      
+      # Save gridded version
+      gridded_path = File.join(Dir.pwd, 'tmp', "#{original_filename}_gridded.png")
+      gridded.write(gridded_path)
+      
+      # Group consecutive red lines
+      groups = []
+      current_group = []
+
+      potential_splits.each_with_index do |split, i|
+        if current_group.empty? || (split[:x] - potential_splits[i-1][:x]) < width * 0.02
+          current_group << split
+        else
+          groups << current_group if current_group.any?
+          current_group = [split]
+        end
+      end
+      groups << current_group if current_group.any?
+      
+      # Sort groups by size (largest first) and x position
+      sorted_groups = groups.sort_by { |group| [-group.size, group[0][:x]] }
+      
+      # Create grouped image showing first and last lines of each group
+      grouped = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      
+      # Define distinct colors for groups (rgba with 0.2 alpha for fill, rgb for stroke)
+      colors = [
+        { fill: "rgba(255,0,0,0.2)", stroke: "rgb(255,0,0)" },    # Red
+        { fill: "rgba(0,255,0,0.2)", stroke: "rgb(0,255,0)" },    # Green
+        { fill: "rgba(0,0,255,0.2)", stroke: "rgb(0,0,255)" },    # Blue
+        { fill: "rgba(255,165,0,0.2)", stroke: "rgb(255,165,0)" }, # Orange
+        { fill: "rgba(128,0,128,0.2)", stroke: "rgb(128,0,128)" }, # Purple
+        { fill: "rgba(0,255,255,0.2)", stroke: "rgb(0,255,255)" }, # Cyan
+        { fill: "rgba(255,0,255,0.2)", stroke: "rgb(255,0,255)" }, # Magenta
+        { fill: "rgba(128,128,0,0.2)", stroke: "rgb(128,128,0)" }  # Olive
+      ]
+      
+      grouped.combine_options do |c|
+        # First draw the shaded regions
+        sorted_groups.each_with_index do |group, index|
+          color = colors[index % colors.size]
+          c.fill color[:fill]
+          c.stroke "none"
+          first_line = group.first
+          last_line = group.last
+          # Draw filled polygon between the lines
+          c.draw "polygon #{first_line[:x]},0 #{last_line[:x]},0 #{last_line[:end_x]},#{height} #{first_line[:end_x]},#{height}"
+        end
+
+        # Then draw the boundary lines on top
+        c.strokewidth "2"  # Thicker lines to highlight group boundaries
+        sorted_groups.each_with_index do |group, index|
+          color = colors[index % colors.size]
+          c.stroke color[:stroke]
+          first_line = group.first
+          last_line = group.last
+          c.draw "line #{first_line[:x]},0 #{first_line[:end_x]},#{height}"
+          c.draw "line #{last_line[:x]},0 #{last_line[:end_x]},#{height}"
+          
+          # Add text labels for x coordinates
+          c.pointsize "12"
+          c.fill color[:stroke]
+          c.draw "text #{first_line[:x]},15 '#{first_line[:x]}'"
+          c.draw "text #{last_line[:x]},30 '#{last_line[:x]}'"
+        end
+      end
+      
+      # Save grouped version
+      grouped_path = File.join(Dir.pwd, 'tmp', "#{original_filename}_grouped.png")
+      grouped.write(grouped_path)
+      
+      # Take the largest groups that are well-spaced
+      final_separators = []
+      min_distance = width / 10
+      
+      sorted_groups.each do |group|
+        # Find a line from within the group that's closest to the middle
+        middle_x = (group.first[:x] + group.last[:x]) / 2.0
+        middle_end_x = (group.first[:end_x] + group.last[:end_x]) / 2.0
+        chosen_line = {
+          x: middle_x,
+          end_x: middle_end_x
+        }
+        
+        # Check if this line is well-spaced from existing separators
+        too_close = final_separators.any? { |sep| (sep[:x] - chosen_line[:x]).abs < min_distance }
+        next if too_close
+        
+        final_separators << chosen_line
+        break if final_separators.size == 5
+      end
+      
+      # Sort final separators by x position
+      final_separators.sort_by! { |sep| sep[:x] }
+      
+      # If we don't have enough separators, fall back to equal spacing
+      if final_separators.size < 5
+        char_width = width / 6.0
+        angle_rad = -15 * Math::PI / 180
+        final_separators = 5.times.map do |i|
+          x = ((i + 1) * char_width).round
+          end_x = x + (height * Math.tan(angle_rad)).round
+          {x: x, end_x: end_x}
+        end
+      end
+      
+      # Create marked image with only selected split lines
+      marked = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      
+      marked.combine_options do |c|
+        c.stroke "red"
+        c.strokewidth "1"  # Make split lines more visible
+        final_separators.each_with_index do |sep, index|
+          c.draw "line #{sep[:x]},0 #{sep[:end_x]},#{height}"
+          # Add text label for x coordinate
+          c.pointsize "12"
+          c.fill "red"
+          c.draw "text #{sep[:x]},15 '#{sep[:x].round}'"
+        end
+      end
+      
+      # Save marked version
+      marked_path = File.join(Dir.pwd, 'tmp', "#{original_filename}_marked.png")
+      marked.write(marked_path)
+      
+      # Create array for character images
+      char_images = []
+      
+      # Split positions including image edges
+      split_positions = [{x: 0, end_x: 0}] + final_separators + [{x: width, end_x: width}]
+      
+      # Create tmp directory if it doesn't exist
+      tmp_dir = File.join(Dir.pwd, 'tmp')
+      FileUtils.mkdir_p(tmp_dir)
+      
+      # Create character images from the segments
+      6.times do |i|
+        # Create path for split character in tmp folder
+        char_path = File.join(tmp_dir, "#{original_filename}_#{i + 1}.png")
+        
+        # Get current and next split lines
+        current_split = split_positions[i]
+        next_split = split_positions[i + 1]
+        
+        # Calculate bounding box that contains both lines
+        x_start = [current_split[:x], current_split[:end_x]].min
+        x_end = [next_split[:x], next_split[:end_x]].max
+        crop_width = x_end - x_start
+        
+        # Create a new image for the character
+        char_image = MiniMagick::Image.create(".png") do |f|
+          image.format "png"
+          image.write f.path
+        end
+        
+        # First crop the bounding box
+        char_image.combine_options do |c|
+          c.crop "#{crop_width}x#{height}+#{x_start}+0"
+          c.repage.+
+        end
+        
+        # Create a mask for the area between the lines
+        mask = MiniMagick::Image.create(".png") do |f|
+          char_image.format "png"
+          char_image.write f.path
+        end
+        
+        # Draw white polygons to mask out areas outside the lines
+        mask.combine_options do |c|
+          # Convert coordinates to be relative to cropped image
+          left_line_start_x = current_split[:x] - x_start
+          left_line_end_x = current_split[:end_x] - x_start
+          right_line_start_x = next_split[:x] - x_start
+          right_line_end_x = next_split[:end_x] - x_start
+          
+          # Mask out area above/left of first line
+          c.draw "fill white stroke none polygon 0,0 #{left_line_start_x},0 #{left_line_end_x},#{height} 0,#{height}"
+          
+          # Mask out area below/right of second line
+          c.draw "fill white stroke none polygon #{right_line_start_x},0 #{crop_width},0 #{crop_width},#{height} #{right_line_end_x},#{height}"
+        end
+        
+        # Apply the mask to the character image
+        char_image = char_image.composite(mask) do |c|
+          c.compose "over"
+        end
+        
+        # Save the character image to tmp directory
+        char_image.write(char_path)
+        char_images << File.new(char_path)
+      end
+      
+      # Create a joined image from all split characters
+      joined = MiniMagick::Image.create(".png") do |f|
+        first_char = MiniMagick::Image.open(char_images.first.path)
+        first_char.format "png"
+        first_char.write f.path
+      end
+
+      # Calculate total width needed
+      total_width = char_images.sum do |char_file|
+        MiniMagick::Image.open(char_file.path).width
+      end
+
+      # Create blank white canvas
+      canvas = MiniMagick::Image.open(char_images.first.path)
+      canvas.combine_options do |c|
+        c.gravity "center"
+        c.background "white"
+        c.extent "#{total_width}x#{height}"
+      end
+
+      # Composite each character onto the canvas
+      x_offset = 0
+      char_images.each do |char_file|
+        char = MiniMagick::Image.open(char_file.path)
+        canvas = canvas.composite(char) do |c|
+          c.compose "over"
+          c.geometry "+#{x_offset}+0"
+        end
+        x_offset += char.width
+      end
+
+      # Save joined version
+      joined_path = File.join(Dir.pwd, 'tmp', "#{original_filename}_joined.png")
+      canvas.write(joined_path)
+      
+      char_images
+    end
+
+    private
+
+    def self.find_vertical_separators(image)
+      # Convert to black and white for easier pixel analysis
+      image.combine_options do |b|
+        b.colorspace "gray"
+        b.threshold "50%"
+      end
+      
+      # Get image dimensions
+      width = image.width
+      height = image.height
+      
+      # Create a histogram of black pixels in each column
+      column_scores = []
+      
+      # Score each column based on number of black pixels
+      width.times do |x|
+        # Use identify to check pixels in this column
+        result = MiniMagick::Tool::Convert.new do |convert|
+          convert << image.path
+          convert.crop("1x#{height}+#{x}+0")
+          convert << "txt:-"
+        end
+        
+        # Count black pixels in the column
+        black_count = result.split("\n").count { |line| line.include?("black") }
+        column_scores << { position: x, score: black_count }
+      end
+      
+      # Calculate moving average to smooth the scores
+      window_size = 3
+      smoothed_scores = []
+      
+      column_scores.each_with_index do |score, i|
+        start_idx = [0, i - window_size/2].max
+        end_idx = [column_scores.size - 1, i + window_size/2].min
+        window = column_scores[start_idx..end_idx]
+        avg_score = window.sum { |w| w[:score] } / window.size.to_f
+        smoothed_scores << { position: score[:position], score: avg_score }
+      end
+      
+      # Find local minima in the smoothed scores
+      local_minima = []
+      smoothed_scores.each_with_index do |score, i|
+        next if i == 0 || i == smoothed_scores.size - 1
+        
+        prev_score = smoothed_scores[i-1][:score]
+        next_score = smoothed_scores[i+1][:score]
+        current_score = score[:score]
+        
+        if current_score < prev_score && current_score < next_score
+          local_minima << score
+        end
+      end
+      
+      # Sort local minima by score
+      sorted_minima = local_minima.sort_by { |m| m[:score] }
+      
+      # Get the 5 best separator positions, excluding edges and too-close positions
+      separators = []
+      min_distance = width / 8  # Minimum distance between separators
+      
+      sorted_minima.each do |minima|
+        pos = minima[:position]
+        
+        # Skip if too close to edges
+        next if pos < width * 0.15 || pos > width * 0.85
+        
+        # Skip if too close to existing separator
+        too_close = separators.any? { |sep| (sep - pos).abs < min_distance }
+        next if too_close
+        
+        separators << pos
+        break if separators.size == 5
+      end
+      
+      # Sort separators by position
+      separators.sort
+    end
+  end
+end 

data/lib/udise_captcha_reader/image_preprocessor.rb

@@ -0,0 +1,105 @@
+require "mini_magick"
+require "fileutils"
+
+module UdiseCaptchaReader
+  class ImagePreprocessor
+    def self.preprocess_image(image_path, approach)
+      # Get original filename for trimming
+      original_filename = File.basename(image_path, ".*")
+      
+      # Open and process the image
+      image = MiniMagick::Image.open(image_path)
+      
+      # First trim the whitespace and get the trimmed image
+      trimmed_path = File.join(Dir.pwd, 'tmp', "#{original_filename}_trimmed.png")
+      FileUtils.mkdir_p(File.dirname(trimmed_path))
+      
+      # Clone and trim the image
+      trimmed = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      
+      # Trim white space from left and right
+      trimmed.combine_options do |b|
+        b.fuzz "10%" # Allow some tolerance for off-white pixels
+        b.trim "+repage"
+      end
+      
+      # Save trimmed image
+      trimmed.write(trimmed_path)
+      
+      # Open trimmed image for further processing
+      image = MiniMagick::Image.open(trimmed_path)
+      temp_output = Tempfile.new(['processed', '.png'])
+      
+      case approach
+      when :split_characters
+        # Split characters preprocessing - optimized for white bg, black text
+        image.combine_options do |b|
+          b.resize "300%"
+          b.threshold "50%"  # Simple threshold for already well-contrasted images
+          b.border "5x5"
+          b.bordercolor "white"
+        end
+      when :standard
+        # Standard preprocessing - optimized for white bg, black text
+        image.combine_options do |b|
+          b.resize "250%"
+          b.threshold "50%"  # Simple threshold for black text
+          b.border "5x5"
+          b.bordercolor "white"
+        end
+      when :high_contrast
+        # High contrast preprocessing - optimized for white bg, black text
+        image.combine_options do |b|
+          b.resize "300%"
+          b.threshold "50%"  # Simple threshold for black text
+          b.border "10x10"
+          b.bordercolor "white"
+        end
+      when :character_separation
+        # Character separation focused preprocessing
+        image.combine_options do |b|
+          b.resize "400%"
+          b.threshold "50%"  # Simple threshold for black text
+          b.border "15x15"
+          b.bordercolor "white"
+        end
+      end
+
+      image.write(temp_output.path)
+      temp_output
+    end
+
+    def self.trim_whitespace(image)
+      # Create tmp directory if it doesn't exist
+      tmp_dir = File.join(Dir.pwd, 'tmp')
+      FileUtils.mkdir_p(tmp_dir)
+      
+      # Get original filename from the image path
+      original_filename = File.basename(image.path, ".*")
+      
+      # Create path for trimmed image in tmp folder
+      trimmed_path = File.join(tmp_dir, "#{original_filename}_trimmed.png")
+      
+      # Clone the image to avoid modifying the original
+      trimmed = MiniMagick::Image.create(".png") do |f|
+        image.format "png"
+        image.write f.path
+      end
+      
+      # Trim white space from left and right
+      trimmed.combine_options do |b|
+        b.fuzz "10%" # Allow some tolerance for off-white pixels
+        b.trim "+repage"
+      end
+      
+      # Save to tmp folder
+      trimmed.write(trimmed_path)
+      
+      # Return as a File object
+      File.new(trimmed_path)
+    end
+  end
+end 

data/lib/udise_captcha_reader/paths.rb

@@ -0,0 +1,11 @@
+module UdiseCaptchaReader
+  module Paths
+    def self.root
+      @root ||= File.expand_path('../..', __dir__)
+    end
+
+    def self.samples
+      File.join(root, 'samples')
+    end
+  end
+end 

data/lib/udise_captcha_reader/reader.rb

@@ -0,0 +1,42 @@
+require_relative "image_preprocessor"
+require_relative "character_splitter"
+require_relative "character_recognizer"
+
+module UdiseCaptchaReader
+  class Reader
+    def initialize(options = {})
+      @options = {
+        lang: "eng",
+        processor: "mini_magick",
+        psm: 7,  # Treat image as a single text line
+        oem: 1   # Use LSTM OCR Engine
+      }.merge(options)
+      
+      @recognizer = CharacterRecognizer.new(@options)
+    end
+
+    def read_text(image_path)
+      raise Error, "Image file not found" unless File.exist?(image_path)
+
+      # Get original filename without extension
+      original_filename = File.basename(image_path, ".*")
+
+      # First preprocess the image
+      processed = ImagePreprocessor.preprocess_image(image_path, :standard)
+      
+      # Open the processed image for splitting
+      image = MiniMagick::Image.open(processed.path)
+      
+      # Split into characters
+      char_images = CharacterSplitter.split_into_characters(image, original_filename)
+      
+      # Recognize each character
+      recognized_chars = char_images.map { |char_image| @recognizer.recognize_character(char_image) }
+      
+      # Join the characters
+      recognized_chars.join
+    rescue RTesseract::Error => e
+      raise Error, "OCR processing failed: #{e.message}"
+    end
+  end
+end 

data/lib/udise_captcha_reader/version.rb

@@ -0,0 +1,3 @@
+module UdiseCaptchaReader
+  VERSION = "0.1.0"
+end 

data/lib/udise_captcha_reader.rb

@@ -0,0 +1,13 @@
+require "rtesseract"
+require "mini_magick"
+require "fileutils"
+require_relative "udise_captcha_reader/version"
+require_relative "udise_captcha_reader/paths"
+require_relative "udise_captcha_reader/image_preprocessor"
+require_relative "udise_captcha_reader/character_splitter"
+require_relative "udise_captcha_reader/character_recognizer"
+require_relative "udise_captcha_reader/reader"
+
+module UdiseCaptchaReader
+  class Error < StandardError; end
+end 

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: udise_captcha_reader
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Syed Fazil Basheer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rtesseract
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A Ruby gem that uses Tesseract OCR to extract text from UDISE captcha
+  images. This gem helps in automating UDISE-related tasks by providing captcha reading
+  capabilities.
+email:
+- fazil@fazn.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/udise_captcha_reader.rb
+- lib/udise_captcha_reader/character_recognizer.rb
+- lib/udise_captcha_reader/character_splitter.rb
+- lib/udise_captcha_reader/image_preprocessor.rb
+- lib/udise_captcha_reader/paths.rb
+- lib/udise_captcha_reader/reader.rb
+- lib/udise_captcha_reader/version.rb
+homepage: https://github.com/UDISE-Plus/udise_captcha_reader
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/UDISE-Plus/udise_captcha_reader
+  source_code_uri: https://github.com/UDISE-Plus/udise_captcha_reader
+  changelog_uri: https://github.com/UDISE-Plus/udise_captcha_reader/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/UDISE-Plus/udise_captcha_reader/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Extract text from UDISE captcha images using OCR
+test_files: []