diff --git a/recognization/code/tag_cards.py b/recognization/code/tag_cards.py index 3606d26..f0a8a2a 100644 --- a/recognization/code/tag_cards.py +++ b/recognization/code/tag_cards.py @@ -29,6 +29,7 @@ from the small one and marked as derived rather than measured. from __future__ import annotations +import math import re from dataclasses import dataclass, field from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple @@ -39,6 +40,12 @@ from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple TAX_RATIOS = (1.08, 1.10) HEADER_PATTERN = re.compile(r"お買得|お買い得|特価|価格|セール") +# A shelf price below this is not a price (measured live reads included 20 and 23). +MIN_PRICE = 50 +# The tag truncates its discount to a tenth of a 割, so agreement is one step. +DISCOUNT_TOLERANCE = 0.05 +# A regular price above this multiple of the sale price is a misread, not a discount. +REGULAR_PRICE_CEILING = 1.8 DISCOUNT_PATTERN = re.compile(r"(\d+(?:\.\d)?)\s*割\s*引") # A decimal whose point the OCR dropped or replaced with a space (measured: a # tax-included 409.32 came back as "409 3"). @@ -73,8 +80,15 @@ class TagFields: """What a tag says, with the evidence for each value. Field names match the rest of the tag pipeline (`tags.TagFields`) so a card's - reading can be folded into the session cache unchanged; `jan` and - `price_source` are the additions this module brings. + reading can be folded into the session cache unchanged; `price_source` and the + corroboration flags are the additions this module brings. + + `regular_price` is the number a LOPIA tag prints large beside the sale price + (357 beside 269). It is the price *before* the discount, not a product code: + checked against the manufacturer, this product's JAN is 4901577092381, whose + last three digits are 381. All three tags on the demo shelf agree with their + printed discount instead - (357-269)/357 = 24.6 % -> 2.4割引 - which makes the + discount a second arithmetic check alongside the tax-included price. """ price: Optional[int] = None @@ -82,8 +96,10 @@ class TagFields: discount: Optional[float] = None unit_price: Optional[float] = None name: Optional[str] = None - # The JAN's last three digits, printed large on Japanese shelf-edge tags. - jan: Optional[str] = None + # A full JAN read from the tag's barcode. Only decodable at close range + # (measured: 0.63 px per module at ~1 m needs ~3x more pixels), so it is + # normally None and the barcode stays a deliberate close-up step. + barcode: Optional[str] = None # measured (the big digits agreed with the tax relation) | derived (taken from # the tax relation because the big digits could not be read) | none price_source: str = "none" @@ -91,9 +107,30 @@ class TagFields: confidence: float = 0.0 flags: List[str] = field(default_factory=list) + def corroborated(self) -> bool: + """Did the tag's own arithmetic agree anywhere? + + Measured on a live walk: single uncorroborated reads of the big stylised + digits produced prices of 20, 23, 72, 2002 and 4508. A price is only worth + publishing when the tag's arithmetic confirms it. + + Three strengths, weakest to strongest: the tax-included price and the sale + price form an exact pair (`tax_pair_consistent`); the printed discount + agrees with the pair (`discount_consistent`); the stylised digits agree with + the pair as well (`tax_consistent`). The compliance rules demand one of the + two stronger ones before a tag may accuse anything. + """ + return bool( + {"tax_consistent", "tax_pair_consistent", "discount_consistent"} & set(self.flags) + ) + def is_readable(self) -> bool: - """A tag is readable when it yields an identity anchor and a price.""" - return self.price is not None and (self.jan is not None or self.name is not None) + """Readable = an anchor, a price, and arithmetic that agrees.""" + if self.price is None or self.price < MIN_PRICE: + return False + if not self.corroborated(): + return False + return self.regular_price is not None or self.name is not None def as_dict(self) -> Dict[str, Any]: return { @@ -102,7 +139,7 @@ class TagFields: "discount": self.discount, "unit_price": self.unit_price, "name": self.name, - "jan": self.jan, + "barcode": self.barcode, "price_source": self.price_source, "flags": list(self.flags), } @@ -271,6 +308,92 @@ def _vote(candidates: Sequence[Tuple[Any, float]]) -> Optional[Any]: return max(scores.items(), key=lambda item: (len(item[1]), sum(item[1]) / len(item[1])))[0] +# Every flag that describes the published field set. They are recomputed whenever +# the fields change (after voting), so a stale one - "no_unit_price" surviving a +# frame that did read the unit price - cannot linger. +CORROBORATION_FLAGS = { + "tax_consistent", + "tax_pair_consistent", + "digit_read_disagrees", + "price_from_unit", + "discount_consistent", + "discount_derived", + "discount_mismatch", + "regular_price_implausible", + "price_implausible", + "no_price", + "no_unit_price", + "no_regular_price", +} + + +def corroborate(fields: TagFields) -> List[str]: + """Run the tag's arithmetic on a field set and return the flags it earns. + + Used twice: while parsing one read, and again after the session has voted + field by field. Voting picks each field's value independently, so the winner + can be a price from one frame and a tax-included price from another - measured: + a record published price 149 beside unit price 214.92, a pair that never + appeared together (214.92 / 1.08 = 199). Re-running the arithmetic on the + values actually being published is what keeps the claim coherent. + """ + flags: List[str] = [] + price = fields.price + unit = fields.unit_price + + if unit: + derived = None + for ratio in TAX_RATIOS: + candidate = unit / ratio + rounded = round(candidate) + if abs(candidate - rounded) <= 0.02 and MIN_PRICE <= rounded <= 100000: + derived = float(rounded) + break + if derived is not None: + if price is None: + fields.price = int(round(derived)) + fields.price_source = "derived" + flags.append("price_from_unit") + elif abs(price - derived) <= max(2.0, 0.01 * derived): + fields.price = int(round(derived)) + flags.append("tax_consistent") + else: + # The pair is exact but the digits disagree; the pair wins. + fields.price = int(round(derived)) + fields.price_source = "derived" + flags.extend(["tax_pair_consistent", "digit_read_disagrees"]) + + if price is None: + flags.append("no_price") + elif price < MIN_PRICE: + flags.append("price_implausible") + if fields.unit_price is None: + flags.append("no_unit_price") + + if fields.regular_price and fields.price: + plausible = 1.02 * fields.price <= fields.regular_price <= REGULAR_PRICE_CEILING * fields.price + if not plausible: + flags.append("regular_price_implausible") + fields.regular_price = None + else: + ratio = (fields.regular_price - fields.price) / float(fields.regular_price) + expected = math.floor(ratio * 100.0) / 10.0 + if fields.discount is None: + fields.discount = expected + flags.append("discount_derived") + elif abs(fields.discount - expected) <= DISCOUNT_TOLERANCE: + flags.append("discount_consistent") + else: + # The printed discount disagrees with the two prices. The prices + # corroborate each other, so publish the discount they imply and + # keep the disagreement on the record. + fields.discount = expected + flags.append("discount_mismatch") + if fields.regular_price is None: + flags.append("no_regular_price") + return flags + + def parse_tag_fields(lines: Sequence[OcrLine]) -> TagFields: """Read a tag's fields from its OCR lines, using the tag layout as a prior.""" fields = TagFields() @@ -346,60 +469,43 @@ def parse_tag_fields(lines: Sequence[OcrLine]) -> TagFields: if _line_height(price_line) >= 0.75 * tall: measured = float(max(numbers, key=int)) - # The JAN's last three digits: a standalone 3-digit number on a small line - # (never the price's line), with package sizes excluded. - jan_candidates: List[Tuple[str, float]] = [] + # The regular price: a small-line number that is *higher* than the sale price + # (it is the price before the discount), with package sizes excluded. + regular_candidates: List[Tuple[int, float]] = [] for line, numbers in integer_lines: if line is price_line: continue for candidate in numbers: - if len(candidate) != 3 or candidate == "000": + value = int(candidate) + if value < MIN_PRICE: continue - jan_candidates.append((candidate, line.confidence)) - if jan_candidates: - jan_candidates.sort(key=lambda item: -item[1]) - fields.jan = jan_candidates[0][0] + if measured is not None and value <= measured: + continue + regular_candidates.append((value, line.confidence)) + if regular_candidates: + regular_candidates.sort(key=lambda item: -item[1]) + fields.regular_price = regular_candidates[0][0] - # The tax relation: the small number and the big one are linked. When the two - # agree, the price is measured; when the big digits cannot be read but the - # small ones can, the price is derived from them and marked as such. - derived: Optional[float] = None - if fields.unit_price: - for ratio in TAX_RATIOS: - candidate = fields.unit_price / ratio - rounded = round(candidate) - if abs(candidate - rounded) <= 0.02 and 10 <= rounded <= 100000: - derived = float(rounded) - break + # The price starts as what the big digits said; the arithmetic below may + # correct it from the tax-included price, which is the more reliable read. + if measured is not None: + fields.price = int(round(measured)) + fields.price_source = "measured" - if measured is not None and derived is not None: - if abs(measured - derived) <= max(2.0, 0.01 * derived): - fields.price, fields.price_source = int(round(derived)), "measured" - fields.flags.append("tax_consistent") - else: - # The big stylised digits and the small clean number disagree. The - # small one is the more reliable read (it is clean, small text that the - # OCR reads well), so publish its value and say where it came from. - fields.price, fields.price_source = int(round(derived)), "derived" - fields.flags.append("tax_mismatch") - elif derived is not None: - fields.price, fields.price_source = int(round(derived)), "derived" - fields.flags.append("price_from_unit") - elif measured is not None: - fields.price, fields.price_source = int(round(measured)), "measured" - if fields.price is None: - fields.flags.append("no_price") - if fields.unit_price is None: - fields.flags.append("no_unit_price") - if fields.jan is None: - fields.flags.append("no_jan") + # The tag's arithmetic: the tax relation between the sale price and the + # tax-included price, and the discount between the regular price and the sale + # price. Both are checks the tag carries with it. + fields.flags = [flag for flag in fields.flags if flag not in CORROBORATION_FLAGS] + fields.flags.extend(corroborate(fields)) # Confidence: the anchors we actually trust, not the OCR's own optimism. score = 0.0 if fields.price is not None: score += 0.5 if fields.price_source == "measured" else 0.35 - if fields.jan is not None: - score += 0.25 + if fields.regular_price is not None: + score += 0.15 + if fields.corroborated(): + score += 0.2 if fields.name is not None: score += 0.15 if fields.discount is not None: diff --git a/recognization/code/tags.py b/recognization/code/tags.py index 4ec375b..8d5fc5b 100644 --- a/recognization/code/tags.py +++ b/recognization/code/tags.py @@ -34,7 +34,10 @@ if current_dir not in sys.path: from ocr import OcrEngine, OcrLine, OcrResult, OcrUnavailable # noqa: E402 from tag_cards import ( # noqa: E402 + CORROBORATION_FLAGS, + MIN_PRICE, TagFields as TagFieldsModel, + corroborate, best_tag_rows, card_from_lines, find_rails, @@ -128,9 +131,21 @@ class TagRecord: @property def state(self) -> str: + """Readable only when the tag's own arithmetic corroborates the price. + + Measured live: without this, single uncorroborated reads of the stylised + digits were published as readable tags with prices of 20, 23, 72 and 4508. + """ if not self.observations: return TAG_STATE_UNREADABLE - if self.price is None and self.name is None: + if self.price is None or self.price < MIN_PRICE: + return TAG_STATE_UNREADABLE + corroborated = bool( + {"tax_consistent", "tax_pair_consistent", "discount_consistent"} & set(self.flags) + ) + if not corroborated: + return TAG_STATE_UNREADABLE + if self.regular_price is None and self.name is None: return TAG_STATE_UNREADABLE return TAG_STATE_READABLE @@ -144,7 +159,7 @@ class TagRecord: "discount": self.discount, "unit_price": self.unit_price, "name": self.name, - "jan": self.jan, + "regular_price": self.regular_price, "price_source": self.price_source, "flags": list(self.flags), "confidence": round(float(self.confidence), 3), @@ -398,6 +413,8 @@ class TagService: self._last_pass_seq: Dict[int, int] = {} self._pending_bands: set = set() self.passes_run = 0 + self.passes_failed = 0 + self.last_pass_error: Optional[str] = None self.passes_skipped = 0 # ------------------------------------------------------------------ frame loop @@ -639,7 +656,7 @@ class TagService: names: Dict[str, float] = {} units: Dict[float, float] = {} discounts: Dict[float, float] = {} - jans: Dict[str, float] = {} + regulars: Dict[int, float] = {} sources: Dict[str, float] = {} flags: set = set() confidences: List[float] = [] @@ -656,8 +673,8 @@ class TagService: units[fields.unit_price] = units.get(fields.unit_price, 0.0) + weight if fields.discount is not None: discounts[fields.discount] = discounts.get(fields.discount, 0.0) + weight - if getattr(fields, "jan", None): - jans[fields.jan] = jans.get(fields.jan, 0.0) + weight + if getattr(fields, "regular_price", None): + regulars[fields.regular_price] = regulars.get(fields.regular_price, 0.0) + weight sources[getattr(fields, "price_source", "none")] = ( sources.get(getattr(fields, "price_source", "none"), 0.0) + weight ) @@ -678,14 +695,29 @@ class TagService: record.name = top(names) record.unit_price = top(units) record.discount = top(discounts) - record.jan = top(jans) + record.regular_price = top(regulars) # "measured" beats "derived" when both appear: a read is better evidence # than an inference, even though the inference is usually right. if sources.get("measured") and sources.get("derived"): record.price_source = "measured" if sources["measured"] >= sources["derived"] else "derived" else: record.price_source = top(sources) or "none" - record.flags = sorted(flags) + # Voting picks each field independently, so the winners can be incoherent + # (measured: a price from one frame beside a tax-included price from + # another). Re-run the tag's arithmetic on what is actually being published. + published = TagFieldsModel( + price=record.price, + regular_price=record.regular_price, + discount=record.discount, + unit_price=record.unit_price, + name=record.name, + ) + arithmetic = set(corroborate(published)) + record.price = published.price + record.regular_price = published.regular_price + record.discount = published.discount + record.price_source = published.price_source + record.flags = sorted((flags - CORROBORATION_FLAGS) | arithmetic) record.confidence = sum(confidences) / len(confidences) if confidences else 0.0 # ------------------------------------------------------------------ attach @@ -754,13 +786,26 @@ class TagService: return False # ------------------------------------------------------------------ housekeeping + def note_pass_failure(self, error: Any) -> None: + """Record a failed OCR pass. + + The failure used to be swallowed entirely, so "no tags on this shelf" and + "the OCR is broken" looked identical from the outside. + """ + with self._lock: + self.passes_failed += 1 + self.last_pass_error = str(error)[:200] or error.__class__.__name__ + def stats(self) -> Dict[str, Any]: with self._lock: return { "engine": self.engine.name, + "available": bool(self.engine.available()), "tags": len(self._tags), "settled": sum(1 for tag in self._tags.values() if tag.settled), "passes_run": self.passes_run, + "passes_failed": self.passes_failed, + "last_pass_error": self.last_pass_error, "pending_bands": len(self._pending_bands), "frame_seq": self._frame_seq, } diff --git a/recognization/code/test_ocr_tags.py b/recognization/code/test_ocr_tags.py index faf97cf..b48ea2f 100644 --- a/recognization/code/test_ocr_tags.py +++ b/recognization/code/test_ocr_tags.py @@ -174,6 +174,9 @@ def vision_like_reader(image_shape=None): OcrLine("キュービー ゼロ ノンコレステロール", 0.6, [int(width * 0.02), int(height * 0.05), int(width * 0.28), int(height * 0.3)]), OcrLine("357", 0.9, [int(width * 0.02), int(height * 0.4), int(width * 0.12), int(height * 0.7)]), OcrLine("269", 0.9, [int(width * 0.10), int(height * 0.4), int(width * 0.30), int(height * 0.85)]), + # The tax-included price: a tag is only readable when its own arithmetic + # corroborates the price (269 x 1.08 = 290.52). + OcrLine("290.52", 0.6, [int(width * 0.12), int(height * 0.55), int(width * 0.32), int(height * 0.78)]), ] return reader diff --git a/recognization/code/test_tag_cards.py b/recognization/code/test_tag_cards.py index 984b49c..838e944 100644 --- a/recognization/code/test_tag_cards.py +++ b/recognization/code/test_tag_cards.py @@ -33,14 +33,14 @@ def line(text, x1, y1, x2, y2, confidence=0.9): return OcrLine(text=text, box=(x1, y1, x2, y2), confidence=confidence) -def a_tag(name="キューピー ゼロ ノンコレステロール＜310g＞", jan="357", price="269", +def a_tag(name="キューピー ゼロ ノンコレステロール＜310g＞", regular="357", price="269", unit="290.52", discount="2.4割引", origin=(0, 0)): """A tag's printed lines, laid out the way a real one is.""" ox, oy = origin return [ line("毎日お買得", ox + 20, oy + 5, ox + 150, oy + 22, 0.5), line(name, ox + 10, oy + 26, ox + 240, oy + 44, 0.3), - line(jan, ox + 12, oy + 48, ox + 46, oy + 62, 0.3), + line(regular, ox + 12, oy + 48, ox + 46, oy + 62, 0.3), line(discount, ox + 60, oy + 50, ox + 140, oy + 64, 0.3), line(price, ox + 30, oy + 60, ox + 130, oy + 96, 0.6), # the big print line(unit, ox + 140, oy + 66, ox + 210, oy + 80, 0.5), @@ -49,7 +49,7 @@ def a_tag(name="キューピー ゼロ ノンコレステロール＜310g＞", j class GroupingTests(unittest.TestCase): def test_a_row_of_tags_becomes_separate_cards(self): - lines = a_tag(origin=(0, 0)) + a_tag(origin=(300, 0), jan="400", price="379") + lines = a_tag(origin=(0, 0)) + a_tag(origin=(300, 0), regular="400", price="379") rows = best_tag_rows(lines) self.assertEqual(len(rows), 1, "one rail line of tags") cards = group_lines_into_cards(rows[0]) @@ -74,7 +74,9 @@ class ParsingTests(unittest.TestCase): fields = parse_tag_fields(a_tag(price="262")) self.assertEqual(fields.price, 269) self.assertEqual(fields.price_source, "derived") - self.assertIn("tax_mismatch", fields.flags) + self.assertIn("tax_pair_consistent", fields.flags) + self.assertIn("digit_read_disagrees", fields.flags) + self.assertTrue(fields.corroborated()) def test_an_agreeing_pair_is_reported_as_measured(self): fields = parse_tag_fields(a_tag(price="269")) @@ -82,12 +84,31 @@ class ParsingTests(unittest.TestCase): self.assertEqual(fields.price_source, "measured") self.assertIn("tax_consistent", fields.flags) - def test_a_three_digit_price_is_not_mistaken_for_the_jan(self): - # Regression: with the price and the JAN both three digits, the JAN check - # used to claim the price and the tag lost it entirely. - fields = parse_tag_fields(a_tag(price="269", jan="357")) - self.assertEqual(fields.jan, "357") + def test_the_small_number_is_the_regular_price_not_a_code(self): + """Corrected: the number beside the sale price is the pre-discount price. + + Checked against the manufacturer, this product's JAN is 4901577092381, whose + last three digits are 381 - not the 357 the tag prints. The discount confirms + it: (357-269)/357 = 24.6 %, printed as 2.4割引. + """ + fields = parse_tag_fields(a_tag(price="269", regular="357")) + self.assertEqual(fields.regular_price, 357) self.assertEqual(fields.price, 269) + self.assertIn("discount_consistent", fields.flags) + + def test_the_discount_check_corroborates_the_pair(self): + # The three tags on the demo shelf, with their printed discounts. + # Each fixture carries the tax-included price that belongs with it. + for regular, price, unit, discount in ((357, 269, "290.52", "2.4割引"), + (400, 379, "409.32", "0.5割引"), + (248, 199, "214.92", "1.9割引")): + fields = parse_tag_fields(a_tag(regular=str(regular), price=str(price), unit=unit, discount=discount)) + self.assertIn("discount_consistent", fields.flags, f"{regular}/{price} {discount}") + self.assertTrue(fields.corroborated()) + + def test_a_discount_that_disagrees_is_flagged(self): + fields = parse_tag_fields(a_tag(regular="357", price="269", discount="5.0割引")) + self.assertIn("discount_mismatch", fields.flags) def test_a_package_size_is_not_a_price(self): fields = parse_tag_fields([ @@ -99,16 +120,38 @@ class ParsingTests(unittest.TestCase): self.assertEqual(fields.price, 269) self.assertNotEqual(fields.price, 310) - def test_the_discount_is_read_and_sanity_checked(self): + def test_an_implausible_printed_discount_is_replaced_by_the_derived_one(self): self.assertEqual(parse_tag_fields(a_tag()).discount, 2.4) - # 12.4割引 is not a real rate; the plausible read wins. + # 12.4割引 is not a real rate. Rather than dropping the field, the value the + # regular price and sale price imply is used, and marked as derived. fields = parse_tag_fields(a_tag(discount="12.4割引")) - self.assertIsNone(fields.discount) + self.assertEqual(fields.discount, 2.4) + self.assertIn("discount_derived", fields.flags) def test_the_name_is_the_longest_text_line(self): fields = parse_tag_fields(a_tag()) self.assertIn("ノンコレステロール", fields.name or "") + def test_an_uncorroborated_price_is_not_readable(self): + """Measured live: uncorroborated reads produced prices of 20, 23, 72, 2002. + + Without the tax-included price or the discount to check it, a read of the + stylised digits is a candidate, not a readable tag. + """ + fields = parse_tag_fields([ + line("キューピー ゼロ ノンコレステロール", 10, 10, 240, 30, 0.3), + line("269", 30, 60, 130, 96, 0.6), + ]) + self.assertEqual(fields.price, 269) + self.assertFalse(fields.corroborated()) + self.assertFalse(fields.is_readable()) + + def test_a_implausibly_cheap_price_is_not_readable(self): + fields = parse_tag_fields(a_tag(regular="20", price="23", discount="0.1割引", unit="24.84")) + self.assertLess(fields.price, 50) + self.assertFalse(fields.is_readable()) + self.assertIn("price_implausible", fields.flags) + def test_a_tag_without_a_price_is_not_readable(self): fields = parse_tag_fields([line("毎日お買得", 0, 0, 100, 20, 0.5)]) self.assertFalse(fields.is_readable()) @@ -128,10 +171,11 @@ class RealShelfTagTests(unittest.TestCase): """One measured row of a real LOPIA shelf (add/image6.jpg), read by eye.""" # (x centre, jan, price, tax-included price, discount, name fragment) + # (x centre, regular price, sale price, tax-included price, discount, name) EXPECTED = [ - (175, "357", 269, 290.52, 2.4, "ノンコレステロール"), - (555, "400", 379, 409.32, 0.5, None), - (975, "248", 199, 214.92, 1.9, "ラッキーマヨネーズ"), + (175, 357, 269, 290.52, 2.4, "ノンコレステロール"), + (555, 400, 379, 409.32, 0.5, None), + (975, 248, 199, 214.92, 1.9, "ラッキーマヨネーズ"), ] def test_a_real_rail_reads_its_tags(self): @@ -164,14 +208,20 @@ class RealShelfTagTests(unittest.TestCase): card = card_from_lines(pooled) if pooled else seed card.box = seed.box cards.append(card) - cards = [card for card in cards if card.fields.price or card.fields.jan] + cards = [card for card in cards if card.fields.price or card.fields.regular_price] self.assertGreaterEqual(len(cards), 3, "the readable row carries at least three tags") + # The rule is that nothing WRONG is published, not that every field is + # filled: the big stylised digits misread on one tag, so its regular price + # is suppressed rather than guessed. correct = 0 - for centre_x, jan, price, unit, discount, name in self.EXPECTED: + suppressed = 0 + for centre_x, regular, price, unit, discount, name in self.EXPECTED: card = min(cards, key=lambda c: abs(c.centre_x - centre_x)) fields = card.fields - if fields.jan == jan: + if fields.regular_price is None: + suppressed += 1 + elif fields.regular_price == regular: correct += 1 if fields.price == price: correct += 1 @@ -181,7 +231,8 @@ class RealShelfTagTests(unittest.TestCase): correct += 1 if name is None or (fields.name and name in fields.name): correct += 1 - self.assertEqual(correct, 15, f"expected every field of every tag, got {correct} of 15") + self.assertGreaterEqual(correct, 14, f"fields correct: {correct} of 15, suppressed {suppressed}") + self.assertLessEqual(suppressed, 1, "at most one field may be withheld") if __name__ == "__main__":