rMQR: add SizeStrategy (Balanced/MinHeight/MaxHeight) for shape control

rMQR spans flat-and-wide to tall-and-narrow form factors; RmqrEncoder::build_with
/ build_text_with let the caller pick the shape (min-height 77x7, balanced 43x11,
max-height 43x17 for the same data) instead of always minimizing area.

Author: MagicalTux

src/codes/rmqr/encode.rs

@@ -6,7 +6,7 @@
 
 use super::matrix::Canvas;
 use super::tables::{char_count_bits, info, mode_value};
-use super::{RmqrEcLevel, RmqrMeta, RmqrSize};
+use super::{RmqrEcLevel, RmqrMeta, RmqrSize, SizeStrategy};
 use crate::codes::qr::gf;
 use crate::error::{Error, Result};
 use crate::output::Encoding;
@@ -26,9 +26,20 @@ impl RmqrEncoder {
     }
 
     /// Build a reproducible [`Symbol`] from `segments` at EC `level`, choosing the
-    /// smallest-area fitting size.
+    /// smallest-area fitting size ([`SizeStrategy::Balanced`]).
     pub fn build(&self, segments: Vec<Segment>, level: RmqrEcLevel) -> Result<Symbol> {
-        let size = choose_size(&segments, level)?;
+        self.build_with(segments, level, SizeStrategy::Balanced)
+    }
+
+    /// Build a reproducible [`Symbol`], choosing the fitting size per `strategy`
+    /// (flat-and-wide, tall-and-narrow, or most-compact).
+    pub fn build_with(
+        &self,
+        segments: Vec<Segment>,
+        level: RmqrEcLevel,
+        strategy: SizeStrategy,
+    ) -> Result<Symbol> {
+        let size = choose_size(&segments, level, strategy)?;
         let meta = RmqrMeta {
             size,
             ec_level: level,
@@ -44,6 +55,20 @@ impl RmqrEncoder {
     pub fn build_text(&self, text: &str, level: RmqrEcLevel) -> Result<Symbol> {
         self.build(vec![Segment::byte(text.as_bytes().to_vec())], level)
     }
+
+    /// Convenience: [`build_with`](Self::build_with) from UTF-8 `text`.
+    pub fn build_text_with(
+        &self,
+        text: &str,
+        level: RmqrEcLevel,
+        strategy: SizeStrategy,
+    ) -> Result<Symbol> {
+        self.build_with(
+            vec![Segment::byte(text.as_bytes().to_vec())],
+            level,
+            strategy,
+        )
+    }
 }
 
 impl Encode for RmqrEncoder {
@@ -186,21 +211,35 @@ fn segments_bit_len(segments: &[Segment], size: RmqrSize) -> Option<usize> {
 }
 
 /// The smallest-area size (at `level`) whose data capacity holds `segments`.
-fn choose_size(segments: &[Segment], level: RmqrEcLevel) -> Result<RmqrSize> {
-    let mut best: Option<(RmqrSize, usize)> = None;
+fn choose_size(
+    segments: &[Segment],
+    level: RmqrEcLevel,
+    strategy: SizeStrategy,
+) -> Result<RmqrSize> {
+    let mut best: Option<RmqrSize> = None;
     for size in RmqrSize::all() {
         let cap = info(size).data_bit_capacity(level);
         if let Some(len) = segments_bit_len(segments, size)
             && len <= cap
+            && best.is_none_or(|b| prefers(size, b, strategy))
         {
-            let area = size.width() * size.height();
-            if best.as_ref().is_none_or(|&(_, a)| area < a) {
-                best = Some((size, area));
-            }
+            best = Some(size);
+        }
+    }
+    best.ok_or_else(|| Error::capacity("data does not fit any rMQR size at this EC level"))
+}
+
+/// Whether `a` is preferred over the current best `b` under `strategy`. Every
+/// strategy uses smaller area as the tie-breaker so the result stays compact.
+fn prefers(a: RmqrSize, b: RmqrSize, strategy: SizeStrategy) -> bool {
+    let area = |s: RmqrSize| s.width() * s.height();
+    match strategy {
+        SizeStrategy::Balanced => area(a) < area(b),
+        SizeStrategy::MinHeight => (a.height(), area(a)) < (b.height(), area(b)),
+        SizeStrategy::MaxHeight => {
+            a.height() > b.height() || (a.height() == b.height() && area(a) < area(b))
         }
     }
-    best.map(|(s, _)| s)
-        .ok_or_else(|| Error::capacity("data does not fit any rMQR size at this EC level"))
 }
 
 /// Build the full interleaved codeword bit stream (data + EC + remainder).

src/codes/rmqr/mod.rs

@@ -79,6 +79,20 @@ pub enum RmqrEcLevel {
     H,
 }
 
+/// How [`RmqrEncoder::build_with`](crate::codes::rmqr::RmqrEncoder::build_with)
+/// chooses among the rMQR sizes that fit the data. rMQR spans flat-and-wide to
+/// tall-and-narrow form factors, so the caller can pick the shape for the space.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum SizeStrategy {
+    /// Smallest total module area — the most compact fitting symbol (default).
+    #[default]
+    Balanced,
+    /// Prefer the shortest (flattest, widest) fitting symbol.
+    MinHeight,
+    /// Prefer the tallest (narrowest) fitting symbol.
+    MaxHeight,
+}
+
 /// rMQR-specific parameters needed to re-encode a symbol identically.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RmqrMeta {

tests/rmqr.rs

@@ -238,3 +238,29 @@ fn wrong_size_matrix_is_undecodable() {
     let m = BitMatrix::new(40, 8, 2);
     assert!(RmqrDecoder::new().decode(&Encoding::Matrix(m)).is_err());
 }
+
+#[test]
+fn size_strategy_picks_shape() {
+    use anyd::codes::rmqr::{RmqrEcLevel, RmqrEncoder, SizeStrategy};
+    use anyd::output::Encoding;
+    use anyd::traits::Encode;
+    let e = RmqrEncoder::new();
+    let dims = |s| {
+        let sym = e
+            .build_text_with("HELLO WORLD 12345", RmqrEcLevel::M, s)
+            .unwrap();
+        match e.encode(&sym).unwrap() {
+            Encoding::Matrix(m) => (m.width(), m.height()),
+            _ => unreachable!(),
+        }
+    };
+    let (_, bh) = dims(SizeStrategy::Balanced);
+    let (_, minh) = dims(SizeStrategy::MinHeight);
+    let (_, maxh) = dims(SizeStrategy::MaxHeight);
+    // min-height must be the shortest, max-height the tallest, all valid rMQR heights.
+    assert!(minh <= bh && bh <= maxh);
+    assert!(minh < maxh, "strategies should differ ({minh} vs {maxh})");
+    for h in [minh, bh, maxh] {
+        assert!([7, 9, 11, 13, 15, 17].contains(&h));
+    }
+}