first commit

This commit is contained in:
Romulus21 committed 2026-09-30 16:49:11 +02:00
commit 253206e6c5
8 files changed
+2960

No files matched your search

+4
View File
@@ -0,0 +1,4 @@
/target
.env
/models
/debug
Generated
+2710
View File
File diff suppressed because it is too large. Load diff
+13
View File
@@ -0,0 +1,13 @@
[package]
name = "watermeter_watcher"
version = "0.1.0"
edition = "2024"
[dependencies]
anyhow = "1.0.104"
dotenvy = "0.15.7"
image = "0.25.10"
ocrs = "0.13.1"
reqwest = { version = "0.13.5", features = ["blocking"] }
rten = "0.26.0"
rten-imageproc = "0.26.0"
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
# Download the ocrs text recognition model into ./models (or $OCRS_MODELS_DIR).
set -e
DIR="${OCRS_MODELS_DIR:-models}"
mkdir -p "$DIR"
curl -fL "https://ocrs-models.s3-accelerate.amazonaws.com/text-recognition.onnx" -o "$DIR/text-recognition.onnx"
+82
View File
@@ -0,0 +1,82 @@
use image::RgbImage;
/// Minimum blue channel value for an overlay pixel.
const BLUE_MIN: u8 = 150;
/// How much the blue channel must exceed red and green.
const BLUE_MARGIN: i16 = 60;
/// Components smaller than this (in pixels of their bounding box side) are noise.
const MIN_SIDE: u32 = 10;
/// Pixels trimmed from each side of a box to drop the blue outline.
const BORDER: u32 = 3;
#[derive(Debug, Clone, Copy)]
pub struct BBox {
pub x: u32,
pub y: u32,
pub w: u32,
pub h: u32,
}
impl BBox {
/// The box shrunk by `BORDER` on each side, i.e. the area inside the outline.
pub fn interior(&self) -> Option<BBox> {
(self.w > 2 * BORDER && self.h > 2 * BORDER).then(|| BBox {
x: self.x + BORDER,
y: self.y + BORDER,
w: self.w - 2 * BORDER,
h: self.h - 2 * BORDER,
})
}
}
fn is_overlay_blue(p: &image::Rgb<u8>) -> bool {
let [r, g, b] = p.0.map(i16::from);
b >= i16::from(BLUE_MIN) && b - r >= BLUE_MARGIN && b - g >= BLUE_MARGIN
}
/// Find the blue overlay rectangles, sorted left to right.
pub fn find_blue_boxes(img: &RgbImage) -> Vec<BBox> {
let (w, h) = img.dimensions();
let idx = |x: u32, y: u32| (y * w + x) as usize;
let mask: Vec<bool> = img.pixels().map(is_overlay_blue).collect();
let mut seen = vec![false; mask.len()];
let mut boxes = Vec::new();
let mut stack = Vec::new();
for y in 0..h {
for x in 0..w {
if !mask[idx(x, y)] || seen[idx(x, y)] {
continue;
}
let (mut x0, mut y0, mut x1, mut y1) = (x, y, x, y);
seen[idx(x, y)] = true;
stack.push((x, y));
while let Some((cx, cy)) = stack.pop() {
x0 = x0.min(cx);
y0 = y0.min(cy);
x1 = x1.max(cx);
y1 = y1.max(cy);
for dy in -1i32..=1 {
for dx in -1i32..=1 {
let (nx, ny) = (cx as i32 + dx, cy as i32 + dy);
if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 {
continue;
}
let i = idx(nx as u32, ny as u32);
if mask[i] && !seen[i] {
seen[i] = true;
stack.push((nx as u32, ny as u32));
}
}
}
}
let b = BBox { x: x0, y: y0, w: x1 - x0 + 1, h: y1 - y0 + 1 };
if b.w >= MIN_SIDE && b.h >= MIN_SIDE {
boxes.push(b);
}
}
}
boxes.sort_by_key(|b| b.x);
boxes
}
+11
View File
@@ -0,0 +1,11 @@
use anyhow::{Context, Result};
use image::DynamicImage;
/// Download the meter picture and decode it.
pub fn fetch_image(url: &str) -> Result<DynamicImage> {
let bytes = reqwest::blocking::get(url)
.and_then(|r| r.error_for_status())
.with_context(|| format!("failed to download {url}"))?
.bytes()?;
image::load_from_memory(&bytes).context("failed to decode image")
}
+82
View File
@@ -0,0 +1,82 @@
mod boxes;
mod fetch;
mod ocr;
use std::path::PathBuf;
use std::process::ExitCode;
use anyhow::{Context, Result};
use image::{Rgb, RgbImage};
use boxes::{BBox, find_blue_boxes};
use ocr::DigitReader;
const DEBUG_DIR: &str = "debug";
fn main() -> ExitCode {
match run() {
Ok(true) => ExitCode::SUCCESS,
Ok(false) => ExitCode::from(2),
Err(e) => {
eprintln!("error: {e:#}");
ExitCode::FAILURE
}
}
}
/// Returns whether every box could be read.
fn run() -> Result<bool> {
dotenvy::dotenv().ok();
let debug = std::env::args().skip(1).any(|a| a == "--debug");
let url = std::env::var("WATERMETER_URL").context("WATERMETER_URL is not set")?;
let models_dir = std::env::var_os("OCRS_MODELS_DIR")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("models"));
let img = fetch::fetch_image(&url)?.into_rgb8();
let boxes: Vec<BBox> = find_blue_boxes(&img)
.iter()
.filter_map(BBox::interior)
.collect();
anyhow::ensure!(!boxes.is_empty(), "no blue box found in image");
let reader = DigitReader::new(&models_dir)?;
let digits = reader.read_boxes(&img, &boxes)?;
if debug {
save_debug(&img, &boxes, &digits)?;
}
let reading: String = digits
.iter()
.map(|d| d.as_deref().unwrap_or("?"))
.collect();
println!("{reading}");
Ok(digits.iter().all(Option::is_some))
}
fn save_debug(img: &RgbImage, boxes: &[BBox], digits: &[Option<String>]) -> Result<()> {
std::fs::create_dir_all(DEBUG_DIR)?;
let mut annotated = img.clone();
for (i, (b, d)) in boxes.iter().zip(digits).enumerate() {
image::imageops::crop_imm(img, b.x, b.y, b.w, b.h)
.to_image()
.save(format!("{DEBUG_DIR}/box_{i}.png"))?;
draw_rect(&mut annotated, b, Rgb([255, 0, 0]));
eprintln!("box {i}: {b:?} -> {}", d.as_deref().unwrap_or("?"));
}
annotated.save(format!("{DEBUG_DIR}/full.png"))?;
Ok(())
}
fn draw_rect(img: &mut RgbImage, b: &BBox, color: Rgb<u8>) {
let (x1, y1) = (b.x + b.w - 1, b.y + b.h - 1);
for x in b.x..=x1 {
img.put_pixel(x, b.y, color);
img.put_pixel(x, y1, color);
}
for y in b.y..=y1 {
img.put_pixel(b.x, y, color);
img.put_pixel(x1, y, color);
}
}
+52
View File
@@ -0,0 +1,52 @@
use std::path::Path;
use anyhow::{Context, Result};
use image::RgbImage;
use ocrs::{ImageSource, OcrEngine, OcrEngineParams};
use rten::Model;
use rten_imageproc::{RectF, RotatedRect};
use crate::boxes::BBox;
pub struct DigitReader {
engine: OcrEngine,
}
impl DigitReader {
pub fn new(models_dir: &Path) -> Result<Self> {
let rec_path = models_dir.join("text-recognition.onnx");
let recognition_model = Model::load_file(&rec_path)
.with_context(|| format!("failed to load {} (run ./download-models.sh)", rec_path.display()))?;
let engine = OcrEngine::new(OcrEngineParams {
recognition_model: Some(recognition_model),
allowed_chars: Some("0123456789".into()),
..Default::default()
})?;
Ok(Self { engine })
}
/// Read the digits inside each box. Each box yields its recognized digits,
/// or `None` when nothing could be read.
///
/// Text detection is skipped: every box is fed directly to the recognizer
/// as a single line of text.
pub fn read_boxes(&self, img: &RgbImage, boxes: &[BBox]) -> Result<Vec<Option<String>>> {
let source = ImageSource::from_bytes(img.as_raw(), img.dimensions())?;
let input = self.engine.prepare_input(source)?;
let lines: Vec<Vec<RotatedRect>> = boxes
.iter()
.map(|b| {
let rect = RectF::from_tlhw(b.y as f32, b.x as f32, b.h as f32, b.w as f32);
vec![RotatedRect::from_rect(rect)]
})
.collect();
let texts = self.engine.recognize_text(&input, &lines)?;
Ok(texts
.into_iter()
.map(|line| {
line.map(|l| l.to_string().chars().filter(char::is_ascii_digit).collect::<String>())
.filter(|s| !s.is_empty())
})
.collect())
}
}