+use core::intrinsics::transmute_unchecked as transmute;

+use std::fmt::{Debug, Display, Formatter, Result, Write};

+

+use crate::{Image, pixels::convert::PFrom};

+

+use super::Basic;

+

+/// Outputs [sixel](https://en.wikipedia.org/wiki/Sixel) encoded data in its [`Display`] and [`Debug`] implementations, for easy visual debugging.

+pub struct Sixel<T: AsRef<[u8]>, const N: usize>(pub Image<T, N>);

+

+impl<T: AsRef<[u8]>, const N: usize> std::ops::Deref for Sixel<T, N> {

+ type Target = Image<T, N>;

+

+ fn deref(&self) -> &Self::Target {

+ &self.0

+ }

+}

+

+impl<T: AsRef<[u8]>, const N: usize> Display for Sixel<T, N>

+where

+ [(); N]: Basic,

+{

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

+ self.write(f)

+ }

+}

+

+impl<T: AsRef<[u8]>, const N: usize> Debug for Sixel<T, N>

+where

+ [(); N]: Basic,

+{

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

+ self.write(f)

+ }

+}

+

+impl<T: AsRef<[u8]>, const N: usize> Sixel<T, N> {

+ /// Write out sixel data.

+ pub fn write(&self, to: &mut impl Write) -> Result

+ where

+ [(); N]: Basic,

+ {

+ #[cfg(unix)]

+ let q = {

+ extern crate libc;

+ // SAFETY: is stdout a tty

+ (unsafe { libc::isatty(1) } == 1)

+ };

+ #[cfg(not(unix))]

+ let q = true;

+ let colors = q

+ .then(|| {

+ super::query("[?1;1;0S").and_then(|x| {

+ // [?1;0;65536S

+ if let [b'?', b'1', b';', b'0', b';', n @ ..] = x.as_bytes() {

+ Some(

+ n.iter()

+ .copied()

+ .take_while(u8::is_ascii_digit)

+ .fold(0u16, |acc, x| {

+ acc.saturating_mul(10).saturating_add((x - b'0') as u16)

+ })

+ .max(64)

+ .min(0xfff),

+ )

+ } else {

+ None

+ }

+ })

+ })

+ .flatten()

+ .unwrap_or(255);

+ to.write_str("Pq")?;

+ write!(to, r#""1;1;{};{}"#, self.width(), self.height())?;

+ let buf;

+ let rgba = if N == 4 {

+ // SAFETY: buffer cannot have half pixels (cant use flatten bcoz N)

+ unsafe { self.buffer().as_ref().as_chunks_unchecked() }

+ } else {

+ buf = self

+ .chunked()

+ .copied()

+ // SAFETY: #[allow(clippy::undocumented_unsafe_blocks)]

+ .map(|x| unsafe {

+ match N {

+ 1 => <[u8; 4] as PFrom<1>>::pfrom(transmute(x)),

+ 2 => <[u8; 4] as PFrom<2>>::pfrom(transmute(x)),

+ 3 => <[u8; 4] as PFrom<3>>::pfrom(transmute(x)),

+ _ => unreachable!(),

+ }

+ })

+ .collect::<Vec<_>>();

+ &*buf

+ };

+

+ let q = qwant::NeuQuant::new(15, colors as _, rgba);

+

+ // TODO: don't colllect

+ let pixels: Vec<u16> = rgba.iter().map(|&pix| q.index_of(pix) as _).collect();

+

+ for ([r, g, b], i) in q

+ .color_map_rgb()

+ .map(|x| x.map(|x| (x as f32 * (100. / 255.)) as u32))

+ .zip(0u64..)

+ {

+ write!(to, "#{i};2;{r};{g};{b}")?;

+ }

+ for sixel_row in pixels.chunks_exact(self.width() as usize * 6).map(|x| {

+ x.iter()

+ .zip(0u32..)

+ .map(|(&p, j)| (p, (j % self.width(), j / self.width())))

+ .collect::<Vec<_>>()

+ }) {

+ // extracted

+ for samples in Grouped(&sixel_row, |r| r.0) {

+ write!(to, "#{}", samples[0].0)?;

+ let mut last = -1;

+ for (x, byte) in Grouped(samples, |(_, (x, _))| x).map(|v| {

+ (

+ v[0].1.0 as i32,

+ v.iter()

+ .map(|&(_, (_, y))| 1 << y)

+ .fold(0, |acc, x| acc | x),

+ )

+ }) {

+ if last + 1 != x {

+ write!(to, "!{}?", x - last - 1)?;

+ }

+ to.write_char((byte + b'?') as char)?;

+ last = x;

+ }

+

+ write!(to, "$")?;

+ }

+ write!(to, "-")?;

+ }

+ write!(to, r"\")?;

+

+ Ok(())

+ }

+}

+

+struct Grouped<'a, K: Eq, T, F: Fn(T) -> K>(&'a [T], F);

+impl<'a, K: Eq, T: Copy, F: Fn(T) -> K> Iterator for Grouped<'a, K, T, F> {

+ type Item = &'a [T];

+ fn next(&mut self) -> Option<Self::Item> {

+ self.0.first()?;

+ self.0

+ .split_at_checked(

+ self.0

+ .array_windows::<2>()

+ .take_while(|&&[a, b]| (self.1)(a) == (self.1)(b))

+ .count()

+ + 1,

+ )

+ .inspect(|(_, t)| self.0 = t)

+ .map(|(h, _)| h)

+ }

+}

+

+#[test]

+fn test() {

+ assert_eq!(

+ Sixel(Image::<Vec<u8>, 3>::open("tdata/small_cat.png")).to_string(),

+ include_str!("../../tdata/small_cat.six")

+ );

+}