Hey there! Sorry to hear Tesseract's letting you down with those meter readings. Since ML/DL is off the table, let's dive into traditional computer vision tweaks and alternatives that can get you accurate numbers without fancy models.

First: Fix Image Preprocessing (Tesseract Thrives on Clean Input!) #

Most OCR failures with meters come from messy images—reflections, noise, uneven lighting, or unseparated text/background. Let's tweak your code with targeted preprocessing steps using OpenCV:

import cv2
import pytesseract as pts

pts.pytesseract.tesseract_cmd = r'C:\Users\Thep Ho\AppData\Local\Programs\Tesseract-OCR\tesseract.exe'
img = cv2.imread("images/text1.jpg")

# 1. Convert to grayscale to eliminate color noise
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 2. Remove noise (median blur works great for salt-and-pepper noise common in meter photos)
denoised = cv2.medianBlur(gray, 3)

# 3. Adaptive thresholding to handle uneven lighting (separates text from background cleanly)
# We use THRESH_BINARY_INV if your meter has dark text on light background—flip it if reversed!
thresh = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)

# 4. Optional: Fix tilted meters
contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if contours:
    # Grab the largest contour (should be the number block)
    largest_contour = max(contours, key=cv2.contourArea)
    rect = cv2.minAreaRect(largest_contour)
    angle = rect[2]
    # Adjust angle to correct for upside-down or sideways tilts
    if angle < -45:
        angle = 90 + angle
    # Rotate the image to straighten it
    h, w = gray.shape[:2]
    center = (w // 2, h // 2)
    rotation_matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
    rotated = cv2.warpAffine(thresh, rotation_matrix, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
else:
    rotated = thresh

# 5. Optional: Crop to only the number region (cuts out irrelevant dials/frames)
# Uncomment this if you know the rough location of the numbers:
# x, y, w, h = cv2.boundingRect(largest_contour)
# roi = rotated[y:y+h, x:x+w]

# Now run Tesseract with optimized config for numbers
# --psm 7 = treat input as a single line of text; adjust to 6 if numbers are a tight block
# tessedit_char_whitelist = only allow digits to avoid garbage characters
custom_config = r'--oem 3 --psm 7 -c tessedit_char_whitelist=0123456789'
text = pts.image_to_string(rotated, config=custom_config)
# Clean up stray spaces/newlines
text = text.strip()
print(text)

Key Config Explanations: #

• --psm 7: Tells Tesseract to treat the input as a single line of text (perfect for meter numbers)
• tessedit_char_whitelist: Restricts recognition to only digits, so Tesseract won't guess letters or symbols
• --oem 3: Uses the default OCR engine mode (most reliable for traditional use cases)

If Preprocessing Still Fails: Try Template Matching (No ML Required!) #

If Tesseract can't handle your meter's font, template matching is a rock-solid alternative. It works by comparing individual digits in your image to pre-made templates of 0-9:

Step 1: Create Digit Templates #

First, make clean templates of each digit (0-9). The easiest way is to crop clear digits from a working meter photo, then save them as template_0.jpg, template_1.jpg, etc. Make sure they're the same size and have the same contrast as your processed images.

Step 2: Implement the Matching Code #

import cv2
import numpy as np

# Load and preprocess your digit templates
templates = []
for num in range(10):
    template = cv2.imread(f'templates/template_{num}.jpg', 0)
    # Match the thresholding style from your input image
    _, template_thresh = cv2.threshold(template, 127, 255, cv2.THRESH_BINARY_INV)
    # Resize to a standard size (adjust based on your meter's digit size)
    template_resized = cv2.resize(template_thresh, (50, 50), interpolation=cv2.INTER_AREA)
    templates.append((num, template_resized))

# Process your meter image (same preprocessing as before)
img = cv2.imread("images/text1.jpg")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
denoised = cv2.medianBlur(gray, 3)
thresh = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)

# Find and sort digit contours (left-to-right to preserve number order)
contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# Sort contours by their x-coordinate to read numbers left to right
contours = sorted(contours, key=lambda ctr: cv2.boundingRect(ctr)[0])

recognized_numbers = []
for cnt in contours:
    x, y, w, h = cv2.boundingRect(cnt)
    # Filter out tiny contours that aren't digits (adjust thresholds to your meter)
    if w < 20 or h < 20:
        continue
    # Crop and resize the digit to match template size
    digit = thresh[y:y+h, x:x+w]
    digit_resized = cv2.resize(digit, (50, 50), interpolation=cv2.INTER_AREA)
    
    # Match against all templates to find the best fit
    max_match_score = -1
    best_digit = -1
    for num, template in templates:
        # Use normalized cross-correlation for matching
        match_result = cv2.matchTemplate(digit_resized, template, cv2.TM_CCOEFF_NORMED)
        current_score = np.max(match_result)
        if current_score > max_match_score:
            max_match_score = current_score
            best_digit = num
    # Only keep matches with a high confidence threshold (adjust based on your templates)
    if max_match_score > 0.8:
        recognized_numbers.append(str(best_digit))

# Combine the results into the final number
final_reading = ''.join(recognized_numbers)
print(final_reading)

Pro Tips for Template Matching: #

• Use real meter digits for templates (not hand-drawn) to match font style exactly
• Adjust the confidence threshold (0.8 in the code) based on how closely your templates match the input
• If your meter has a decimal point, add a template for . and include it in your whitelist

Quick Bonus Tweaks #

• Enhance Contrast: Use cv2.equalizeHist(gray) after converting to grayscale to fix washed-out images
• Update Tesseract: Make sure you're running the latest version—older releases have worse support for non-standard fonts
• Check Lighting: Avoid taking photos with direct flash (it causes reflections); use soft, even lighting instead

内容的提问来源于stack exchange，提问作者thep200