Struct figures::units::Lp

source ·

#[repr(C)]
pub struct Lp(/* private fields */);

Expand description

Logical pixels, a device-independent measurement

A logical pixel is equivalent to a single pixel on a 96-DPI display. However, this unit is scaled when converiting to Px to honor the target display’s actual DPI.

For example, consider these assertions:

use figures::units::{Lp, Px};
use figures::{Fraction, ScreenScale};

// Scaling factor of 1.0
assert_eq!(Lp::new(1).into_px(Fraction::new_whole(1)), Px::new(1));

// Scaling factor of 2.0
assert_eq!(Lp::new(1).into_px(Fraction::new_whole(2)), Px::new(2));

// Scaling factor of 0.5
assert_eq!(Lp::new(1).into_px(Fraction::new(1, 2)), Px::from(0.5));

Logical pixels are designed around several use cases. Internally, this type uses integers to represent logical pixels, which ensures that math is always predictable, and any precision loss is controllable by the developer.

To ensure that the Lp type has as little precision loss as possible, it uses a scale of 1,905 subpixels . This number may seem arbitrary, but it is a multiple of the prime numbers 3, 5, and 127. These numbers are important because:

72: Typographic points are defined as 72 points per inch, and the prime factorization is 2^3 * 3^2.
96: A scaling factor of 1 is defined as 96 pixels per inchm, and the prime factorization is 2^5 * 3.
254: Allows using metric units lossleslly because 2.54cm = 1in, and it’s prime factorization is 2 * 127
5: Five is a low common prime, and everyone likes round numbers.

Because the Lp scale is arbitrary and hard to reason about, this type has many constructors to allow specifying measurements in various units developers will be more comfortable with:

use figures::units::Lp;

// Centimeters
assert_eq!(Lp::cm_f(1.), Lp::cm(1));
// Millimeters
assert_eq!(Lp::mm_f(1.), Lp::mm(1));
assert_eq!(Lp::mm(10), Lp::cm(1));

// Inches
assert_eq!(Lp::inches_f(1.), Lp::inches(1));
assert_eq!(Lp::inches(1), Lp::cm_f(2.54));

// Points
assert_eq!(Lp::points_f(36.), Lp::points(36));
assert_eq!(Lp::points(36), Lp::inches_f(0.5));

Struct figures::units::Lp

Implementations§

impl Lp

pub const MAX: Self = _

pub const MIN: Self = _

pub const fn new(value: i32) -> Self

pub const fn get(self) -> i32

pub const fn saturating_sub(self, other: Self) -> Self

pub const fn saturating_add(self, other: Self) -> Self

pub const fn saturating_mul(self, other: Self) -> Self

pub const fn saturating_div(self, other: Self) -> Self

impl Lp

pub const fn points(points: i32) -> Self

pub fn points_f(points: f32) -> Self

pub const fn cm(centimeters: i32) -> Self

pub fn cm_f(centimeters: f32) -> Self

pub const fn mm(millimeters: i32) -> Self

pub fn mm_f(millimeters: f32) -> Self

pub const fn inches(inches: i32) -> Self

pub fn inches_f(inches: f32) -> Self

Trait Implementations§

impl Abs for Lp

fn abs(&self) -> Self

impl<Unit> Add<Lp> for Point<Unit>where Unit: Add<Lp, Output = Unit>,

type Output = Point<Unit>

fn add(self, rhs: Lp) -> Self::Output

impl<Unit> Add<Lp> for Size<Unit>where Unit: Add<Lp, Output = Unit>,

type Output = Size<Unit>

fn add(self, rhs: Lp) -> Self::Output

impl Add<i32> for Lp

type Output = Lp

fn add(self, rhs: i32) -> Self::Output

impl Add for Lp

type Output = Lp

fn add(self, rhs: Self) -> Self::Output

impl AddAssign<i32> for Lp

fn add_assign(&mut self, rhs: i32)

impl AddAssign for Lp

fn add_assign(&mut self, rhs: Self)

impl Clone for Lp

fn clone(&self) -> Lp

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

impl Debug for Lp

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

impl Default for Lp

fn default() -> Lp

impl<'de> Deserialize<'de> for Lp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl Display for Lp

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

impl Div<Fraction> for Lp

type Output = Lp

fn div(self, rhs: Fraction) -> Self::Output

impl<Unit> Div<Lp> for Point<Unit>where Unit: Div<Lp, Output = Unit>,

type Output = Point<Unit>

fn div(self, rhs: Lp) -> Self::Output

impl<Unit> Div<Lp> for Size<Unit>where Unit: Div<Lp, Output = Unit>,

type Output = Size<Unit>

fn div(self, rhs: Lp) -> Self::Output

impl Div<f32> for Lp

type Output = Lp

fn div(self, rhs: f32) -> Self::Output

impl Div<i32> for Lp

type Output = Lp

fn div(self, rhs: i32) -> Self::Output

impl Div for Lp

type Output = Lp

fn div(self, rhs: Self) -> Self::Output

impl DivAssign<i32> for Lp

fn div_assign(&mut self, rhs: i32)

impl DivAssign for Lp

fn div_assign(&mut self, rhs: Self)

impl FloatConversion for Lp

type Float = f32

fn into_float(self) -> Self::Float

fn from_float(float: Self::Float) -> Self

impl From<Lp> for f32

fn from(value: Lp) -> Self

impl From<Lp> for i32

fn from(value: Lp) -> Self

impl<Unit> Add<Lp> for Point<Unit>
where Unit: Add<Lp, Output = Unit>,

impl<Unit> Add<Lp> for Size<Unit>
where Unit: Add<Lp, Output = Unit>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

impl<Unit> Div<Lp> for Point<Unit>
where Unit: Div<Lp, Output = Unit>,

impl<Unit> Div<Lp> for Size<Unit>
where Unit: Div<Lp, Output = Unit>,

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

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

fn to_vec<Type>(self) -> Type
where Type: FromComponents<Unit>,

fn to_vec<Type>(self) -> Type
where Type: FromComponents<Unit>,

impl<Unit> Mul<Lp> for Point<Unit>
where Unit: Mul<Lp, Output = Unit>,

impl<Unit> Mul<Lp> for Size<Unit>
where Unit: Mul<Lp, Output = Unit>,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,