Struct CostMap 

pub struct CostMap<'img> { /* private fields */ }

Per-pixel embedding cost of a container image, in row-major order.

What the lifetime buys

'img is the borrow of the ImageBuffer the map was computed from. The map holds no reference to the image at run time — only a PhantomData — but the borrow checker treats it as if it did, so for as long as a CostMap<'img> is alive the compiler refuses every call to CoverSource::pixels_mut on the source image.

That is the whole point. A cost map computed from one set of samples and applied to another is silently wrong: the embedder would steer bits towards regions that are no longer the textured ones, which is exactly the mistake a steganalyst is looking for. Rather than keeping map and image in sync by convention, the pipeline is forced to drop the map before it may touch the pixels, and the invariant is checked at compile time.

Implementations

impl<'img> CostMap<'img>

pub fn dimensions(&self) -> (u32, u32)

Dimensions of the map as (width, height), in pixels.

Always the dimensions of the image the map was computed from.

pub fn pixel_count(&self) -> usize

Number of pixels covered by the map.

pub fn costs(&self) -> &[f32]

The costs as a flat row-major slice.

The embedding layer consumes the map in permuted order, so it needs the raw vector rather than coordinate access.

pub fn get(&self, x: u32, y: u32) -> Option<f32>

Cost of the pixel at (x, y), or None when the coordinates fall outside the map.

The total counterpart of the Index implementation.

Trait Implementations

impl Debug for CostMap<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Prints the geometry of the map, never its contents.

Written by hand rather than derived: a derived implementation would format several million floats, which is not what anyone putting a cost map behind {:?} is asking for.

impl Index<(u32, u32)> for CostMap<'_>

fn index(&self, (x, y): (u32, u32)) -> &f32

Cost of the pixel at (x, y).

Follows the convention of every indexing implementation in the standard library and treats out-of-range coordinates as a programming error rather than as a runtime condition. Use CostMap::get wherever the coordinates come from outside the caller.

type Output = f32

The returned type after indexing.