Enum Orientation 

#[non_exhaustive]
#[repr(u8)]
pub enum Orientation {
    Identity = 1,
    FlipH = 2,
    Rotate180 = 3,
    FlipV = 4,
    Transpose = 5,
    Rotate90 = 6,
    Transverse = 7,
    Rotate270 = 8,
}

Image orientation — the 8-element D4 dihedral group.

Values 1-8 match EXIF tag 274 exactly. #[repr(u8)] means o as u8 gives the EXIF value directly.

Decomposition

| Variant    | Rotation | FlipH? | Swaps axes? |
|------------|----------|--------|-------------|
| Identity   | 0°       | no     | no          |
| FlipH      | 0°       | yes    | no          |
| Rotate180  | 180°     | no     | no          |
| FlipV      | 180°     | yes    | no          |
| Transpose  | 90° CW   | yes    | yes         |
| Rotate90   | 90° CW   | no     | yes         |
| Transverse | 270° CW  | yes    | yes         |
| Rotate270  | 270° CW  | no     | yes         |

D4 group operations

compose implements group multiplication (verified against a full Cayley table). inverse returns the element that undoes the transformation.

use zenpixels::Orientation;

let combined = Orientation::Rotate90.then(Orientation::FlipH);
assert_eq!(combined, Orientation::Transpose);

let roundtrip = Orientation::Rotate90.compose(Orientation::Rotate90.inverse());
assert_eq!(roundtrip, Orientation::Identity);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Identity = 1

No transformation. EXIF 1.

FlipH = 2

Horizontal flip (mirror left-right). EXIF 2.

Rotate180 = 3

180° rotation. EXIF 3.

FlipV = 4

Vertical flip (= Rotate180 + FlipH). EXIF 4.

Transpose = 5

Transpose: reflect over main diagonal (= Rotate90 + FlipH). EXIF 5. Swaps axes.

Rotate90 = 6

90° clockwise rotation. EXIF 6. Swaps axes.

Transverse = 7

Transverse: reflect over anti-diagonal (= Rotate270 + FlipH). EXIF 7. Swaps axes.

Rotate270 = 8

270° clockwise rotation (= 90° counter-clockwise). EXIF 8. Swaps axes.

Implementations

impl Orientation

pub const ALL: [Orientation; 8]

All 8 orientations in EXIF order (1-8).

pub const fn from_exif(value: u8) -> Option<Orientation>

Create from EXIF orientation tag value (1-8).

Returns None for values outside 1-8. Use .unwrap_or_default() if you want fallback to Identity.

pub const fn to_exif(self) -> u8

Convert to EXIF orientation tag value (1-8).

Equivalent to self as u8 thanks to #[repr(u8)].

pub const fn is_identity(self) -> bool

Whether this is the identity (no-op) transformation.

pub const fn swaps_axes(self) -> bool

Whether this orientation swaps width and height.

True for orientations involving a 90° or 270° rotation (EXIF 5-8).

pub const fn is_row_local(self) -> bool

Whether this can be applied per-row without buffering the full image.

Only Identity and FlipH are row-local — all other transforms require access to multiple rows.

pub const fn compose(self, other: Orientation) -> Orientation

Compose two orientations: apply self first, then other.

This is D4 group multiplication, verified against the full Cayley table.

pub const fn then(self, other: Orientation) -> Orientation

Alias for compose. Reads naturally in chains: Rotate90.then(FlipH) = “apply Rotate90 first, then FlipH.”

pub const fn inverse(self) -> Orientation

The inverse orientation: self.compose(self.inverse()) == Identity.

pub const fn output_dimensions(self, w: u32, h: u32) -> (u32, u32)

Compute output dimensions after applying this orientation.

Returns (width, height) — swapped when swaps_axes is true.

pub const fn forward_map(self, sx: u32, sy: u32, w: u32, h: u32) -> (u32, u32)

Forward-map a source pixel (sx, sy) to its destination position.

(w, h) are the source (pre-orientation) dimensions. Returns (dx, dy) in the output coordinate space.

Trait Implementations

impl Clone for Orientation

fn clone(&self) -> Orientation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Orientation

impl Debug for Orientation

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

Formats the value using the given formatter.

impl Default for Orientation

fn default() -> Orientation

Returns the “default value” for a type.

impl Eq for Orientation

impl Hash for Orientation

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Orientation

fn eq(&self, other: &Orientation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Orientation