Struct BiLevel

pub struct BiLevel;

A bi-level color map

Examples

use image::imageops::colorops::{index_colors, BiLevel, ColorMap};
use image::{ImageBuffer, Luma};

let (w, h) = (16, 16);
// Create an image with a smooth horizontal gradient from black (0) to white (255).
let gray = ImageBuffer::from_fn(w, h, |x, y| -> Luma<u8> { [(255 * x / w) as u8].into() });
// Mapping the gray image through the `BiLevel` filter should map gray pixels less than half
// intensity (127) to black (0), and anything greater to white (255).
let cmap = BiLevel;
let palletized = index_colors(&gray, &cmap);
let mapped = ImageBuffer::from_fn(w, h, |x, y| {
    let p = palletized.get_pixel(x, y);
    cmap.lookup(p.0[0] as usize)
        .expect("indexed color out-of-range")
});
// Create an black and white image of expected output.
let bw = ImageBuffer::from_fn(w, h, |x, y| -> Luma<u8> {
    if x <= (w / 2) {
        [0].into()
    } else {
        [255].into()
    }
});
assert_eq!(mapped, bw);

Trait Implementations

impl Clone for BiLevel

fn clone(&self) -> BiLevel

impl ColorMap for BiLevel

type Color = Luma<u8>;
fn index_of(&self, color: &Luma<u8>) -> usize
fn lookup(&self, idx: usize) -> Option<Self::Color>
fn has_lookup(&self) -> bool

Indicate NeuQuant implements lookup.

fn map_color(&self, color: &mut Luma<u8>)

impl Copy for BiLevel

Auto Trait Implementations

impl Freeze for BiLevel

impl RefUnwindSafe for BiLevel

impl Send for BiLevel

impl Sync for BiLevel

impl Unpin for BiLevel

impl UnsafeUnpin for BiLevel

impl UnwindSafe for BiLevel

Blanket Implementations

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for BiLevel where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for BiLevel where ST: ?Sized, DT: ?Sized,

impl<T> Any for BiLevel where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for BiLevel where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for BiLevel where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for BiLevel where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for BiLevel

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoEither for BiLevel

impl<T> Pointable for BiLevel

const ALIGN: usize = _;
type Init = T;
unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

impl<T> Read<Exclusive, BecauseExclusive> for BiLevel where T: ?Sized,

impl<T> ToOwned for BiLevel where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for BiLevel where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for BiLevel where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for BiLevel where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>