code guessing, round #101 (completed)

import sys
from PIL import Image

def fix(filename):
    image = Image.open(filename).convert("RGBA")
    pixels = image.load()
    width, height = image.size
    for y in xrange(height):
        for x in xrange(width):
            colors = pixels[x,y]
            pixels[x,y] = (colors[0], colors[1], 0, colors[3])
    image.save(filename + "_fixed.png")
    print "done"

if __name__ == "__main__":
    fix(sys.argv[1])

#!/bin/sh
#
# WARNING :: BAD perfromance  Sorry
#
#
#
# STDIN = Image (Blue)
# STDOUT = Image Sans (
#
#                ##################
#            ####                  ####
#          ##                          ##
#          ##                          ##
#        ##                              ##
#        ##                    ######    ##
#        ##                    ######    ##
#        ##    ######    ##    ######    ##
#          ##          ######          ##
#        ####  ##                  ##  ####
#        ##    ######################    ##
#        ##      ##  ##  ##  ##  ##      ##
#          ####    ##############    ####
#        ##########              ##########
#      ##  ##############################  ##
#    ####  ##    ##      ##      ##    ##  ####
#    ##      ##    ######  ######    ##      ##
#  ##    ####  ######    ##    ######  ####    ##
#  ##        ##    ##          ##    ##        ##
#  ##          ##  ##          ##  ##          ##
#    ##      ##    ####      ####    ##      ##
#      ####  ##    ##          ##    ##  ####
#        ######    ##############    ######
#          ####    ##############    ####
#        ##################################
#        ################  ################
#          ############      ############
#      ######        ##      ##        ######
#      ##          ####      ####          ##
#        ##########              ##########
#
# ) Blue
#
take() {
	_v="$(dd status=none bs="$1" count=1)"
	test -n "$_v" || return 1
	printf '%s' "$_v";
}
hex() {
	od -An -tx1 | tr -d ' \n'
}
unhex() {
	while true; do
		_vv="$(take 2)" || break
		printf '\x'"$_vv"
	done
}
if command -v xxd >/dev/null 2>&1; then
	hex() {
		xxd -p | tr -d ' \n'
	}
	unhex() {
		xxd -p -r
	}
fi
if test -z "$(printf 'a\nna' | (read -N4 v; cat) 2>/dev/null)"; then
	take() {
		read -N$(($1 + 0)) _v
		test -n "$_v" || return 1
		printf '%s' "$_v"
	}
fi
(
	(
		ffmpeg \
			-i - \
			-f rawvideo \
			-pix_fmt rgba \
			-y - \
			3>&1 4>&2 2>&3 1>&4
	) |
		grep -Em1 Video: |
		grep -Eom1 '[0-9][0-9]*x[0-9][0-9]*'
) 2>&1 | (
	read size
	echo $size
	pxs=$(eval 'echo $(('"$(echo $size | tr 'x' '*')"'))')
	i=0
	p_a=1000
	p_b=1000
	hex | while :; do
		take 4 || break
		take 2 >/dev/null || break
		printf '00'
		take 2 || break
		i=$(($i + 1))
		p_a=$(($i * 100 / $pxs))
		if test -t 2 && test $p_a -ne $p_b; then
			p_b=$p_a;
			printf '\r%s%%' "$p_a" >&2;
		fi
	done
	if test -t 2; then
		printf '\n' >&2
	fi
) | (
	read size
	unhex | ffmpeg \
		-f rawvideo \
		-pixel_format rgba \
		-video_size $size \
		-i - \
		-f apng \
		-y - \
		2>/dev/null
)

°img &frab "download.png"

? Written and tested on a little endian system
? Good luck porting it to big endian
? May take some time to fully execute

"io.ec"
"utilities.ec"
"bmp.ec"

      +--E ? Discard file length
>-⎚-⬟-r  |
         +-⛁-+ ? Sign correction
             |
             +-⌂-b ? Check signature and move file size backwards, we'll need that
                 F-b
                   F-b
                     F-b
                       F-⛩-+ ? Check reserved
                           |
                           +f#fB ? Move offset to the right and construct it at the same time
                               B
                               +f#f
                                  OⓄ#MM
                                      A
                                     *
                                     B
                                     B
                                Of#f-+
                                |
                                +Ⓞ#M#MM
                                      A
                                     * 
                                     B
                                     B
                                Of#f-+
                                |
                                +Ⓞ#M##MMM
                                        A
                                         bbb
                                           |
                                          +F
                                          |
                                          O ? Check and validate some important bytes, otherwise skip to the data section
                                          I
                                          I
                                          I   +-⁖-O ? Bits per pixel should be 24
                                          #   I   I
                                          I   I   I
                                          +-M-+   #M# #--f-+
                                                    I $    B
                                                    I |    S
                                                    +M+  #-+-#
                                                         [   ]
                                                         +⚠  EfB
                                                          o    |
                                                               | ? Compression should be zero
                                                             #-+-#
                                                             [   ]
                                                             +⚠  +-f-B
                                                              o      f-B
                                                                       f-B
                                                                         f-B
                                                                           B
                                                                           f-O ? Move offset value, subtract 34 from it
                                                                             I
                                                                             I      
                                                                             I +MD-+      +--------+
                                                                             I I   $      |        B
                                                                             I I   S      U        B
                                                                             #-+   +--⁖}--+        +4ff-+
                                                                                          |             B ? Apply blue light filter
                                                                                        +-+-+     +-5ff-B
                                                                                        (   )     B
                                                                                        |   +-8ff-B
                                                                                       +F
                                                                                       |
                                                                                      +F
                                                                                      |
                                                                                     +R
                                                                                     U
                                                                                     +{---+
                                                                                     B    |
                                                                                   +-+-+  |
                                                                                   (   )  |
                                                                                 O-F   +-f+
                                                                                 O           ? Construct reserved part
                                                                                 O
                                                                                 O     +-fff-+     +-fff-+
                                                                                 B     B     B     B     O
                                                                                 B     B     B     B     I
                                                                                 B     B     B     B     I
                                                                                 +-fff-+     +-fff-+     I
                                                                                                         I
                                                                                              +-+   #--+ I
                                                                                              I I   |  I I
                                                                                              I I   +b I I
                                                                                              I OfB  | +-#
                                                                                              I   +-MF I
                                                                                            +M+        I
                                                                                            |
                                                                                            +-O
                                                                                              |
                                                                                              OⓄO©DM#DDD##⦵DDD+
                                                                                                              |
                                                                                                              $
                                                                                              O---------------+
                                                                                              I
                                                                                              I
                                                                                              I
                                                                                              OⓄMDD+
                                                                                                   $
                                                                                                   +-©D#
                                                                                                       I
                                                                                                 #DDDDD#
                                                                                                 I
                                                                                                 I
                                                                                                 I
                                                                                                 I
                                                                                                 #
                                                                                                 I
                                                                                                 #DDDDDDw-OD+
                                                                                                            $
                                                                                                            W

"utilities.ec"
"io.ec"

? Check signature
? Error and exit if signature does not match
+-⌂-O
|   I+M#fB
|   II   S
|   II #-+-#
++  II ]   [
 |  II E   +-⚠
 E  II +-+   o
 |  #+  +F
 |      +-b
 | +⚠  A  O
 ] [o * * I
 #+#  S I I
  +---+ I I
        +M#


? Check reserved
+-⛩-+
|   |
| +-#-+
| [   ]
| +⚠  |
|  o  |
|   +-#-+
|   [   ]
|   +⚠  |
|   |o  |
]   [ +-#-+
+-+-+ ]   [
  #---+   +⚠
           o

? Move N numbers to the next stack where N is the top-most item
+-⁖---+
|     U
|     +{--+
|     |   |
|   #-+-# |
|   ]   [ |
+---E   $ D
        f-B

? Divide by 255
+-◲-+
|   |
|   +-OⓄ#MD-+
|           $
+-----------Q

? Multiply by 255
+-⧉-OⓄ#MD
|       |
+---M---+

? Gamma correction approximation
? x**2.2 ≈ max(0, -0.1099x+1.0989x**2)
+-γ-#O©+
|      I +-MMDO©+
|      I I      I
|      ##+      I
+{OE            ###MMM+
n  |                  |
l  +L +-MMM###        $
|   | $      |    +-M-Q
#-+-# Q    +©+    $
  S   I    I    O-#
  +-MM+    I    |
           OD+  +©+
             S    I
             |    I
             +MM###

? Manipulate blue channel
+-8-◲-O
|     I
+--+  I
   |  ##
   |   I    
   |   ####M+
+γ⧉+        I
|           I
|     OMMMMM+
|     I
|     Q
|     O
+--M+ I ? Multiply with magic constant, 2/9-1/1187. (Approximates 0.22137978)
    S I
    Q #
    $ I
    +M#

? Manipulate green channel
+-5-◲-O
|     I +-+
+--+  I I $
   |  I I Q
   |  #-+ O
   |      +-ⓄDD#
+γ⧉+           D
|       A      D
+---M--* *Q    D ? Multiply with magic constant, 3/5+1/138. (Approximates 0.60724493)
          I    D
          ODDM-+

? Manipulate red channel, only do gamma correction
+-4--+
|    |
+-◲γ⧉+

"utilities.ec"

? Print "Enter filename: "
+-⎚-O                   
|   I      +-P-O        +-P-#
|   I      |   I        I   D
+P+ I      I   I        I   D
  | I      A   #        I   D
MM+ #-###MM    I  +-M-# I   D
|              I  I   | I   D
+MM            I  |   | I   D
  #            +-M#   #-P   D-DDP-+
  #                               I
  #  +MM###                       I
  #  |    I   +-P-+               I
  I  |    I   I   D               I
  I  S    #   I   $               #-PO
  |  S    I   I   +-P-#              I
  OP-+    I   I       I   O#P+   +-+ I
          O-P-+       I   I  |   I I ####MMMMPDDDD#DDD
                      I   I  #PD-P I                 |
                      S   I        +----P# +-P#DDD#DD+
                      $   I              | $          
                      |   |              +-+
                      +-M-#

? Filename read loop, terminates if the input is equal to 0 (EOF)
+-⬟----+
|      | +--+
+E     U U  |
 |     +++  |
+R      |   |
|       &-+ |
|         | [
|       #-+-#
|       ]
+{-E----+

? Print newline, useful for debugging
+-⏎-O
|   I
|   I
PM+ #
  | I
  I I
  +-+

? Print "Invalid file"
+-+
| ⚠-O
|   I #MMDD#P-O #MM+  A
|   I I       I I  I * *
|   I I       I I  I I #-P-##©P-ⓣ+
|   #-+       #-+  I I           I
|         +P#      +-+           I
+PM+      I I                    I
   I I    I I        +PDDDP##DDP-+
   I O-P+ I I        |
   I I  DP+ +-#P#    +⦵#PO
   +-#          I        I
                I        I
                +PMMMM####

? Sign corrects the entire stack
? Pushes a -1 to the next stack first. 
? Then goes back, loops through every item on the stack, adds 256 if the number is negative,
? and moves them to the next stack
? Finally moves everything back until it hits a -1 and pops it off
? Should work correctly if the stack contains bytes read from a file
? Otherwise you may end up in situations you wouldn't want to be in
+-⛁-FODO
|      I
|      I
|      #######MMMMMMMB
|                    U
+{--------------+    +{-----+
                |    |      |
          +-+   E  +-+-+    |
          | [   ]  (   )    |
          | +-+-+  | #-+-#  |
          |   #    | |   |  |
          |   A   EF +L  |  |
          |    *  |   |  l  |
          |    I  | b#F  |  B
          |    O  | A    U  $
          F-}+b#  |  *--}+f-+
             n    |
             +----+

? Add 8 to the number on top of the stack
*-©-O
 \  I
  \ I
   \##MM+
    \   |
     \  A
      **
        
? Add 16 to the number on top of the stack
*-Ⓞ-O
 \  I
  \ I
   \###MMM*
    \     A
     *---*

? Subtract 8 from the number on top of the stack 
*-⦵-O
 \  I
  \ I
   \##MM+
    \   $
     \  S
      *-+

? Subtract 16 from the number on top of the stack 
*-ⓣ-O
 \  I
  \ I
   \###MMM+
    \     $
     \    S
      *---+

function out = remBLUE(mat)
  mat(:, :, 3) = 0;
  out = mat;
endfunction

//! Takes sRGB PPM files as input
//! I know PPM isn't sRGB according to the spec
//! But even in the spec they mention putting sRGB data in
//! So fuck the spec it assumes sRGB
//! Usage: input output [target temperature] [source temperature]
//! Default target is 4000K, default source is 6500K
//! Temperatures are in Kelvin
//! Not much output apart from that. It's a tad slow but does its job.
use std::env::Args;
use std::error::Error;
use std::fs::File;
use std::io;
use std::io::BufReader;
use std::io::BufWriter;
use std::io::ErrorKind;
use std::io::prelude::*;
use std::path::Path;
use std::str::FromStr;

/// Second radiation constant
/// Source: https://en.wikipedia.org/wiki/Planckian_locus#International_Temperature_Scale
const C_2: f64 = 1.438_776_877;

/// Adapting luminance
/// https://en.wikipedia.org/wiki/CIECAM02#Parameter_decision_table
/// https://en.wikipedia.org/wiki/SRGB#Viewing_environment
const L_A: f64 = 0.20 * 80.;

/// Surround factor
const F: f64 = 1.;

#[derive(Debug)]
enum PPMRaster {
    PPM8(Vec<Vec<(u8, u8, u8)>>),
    PPM16(Vec<Vec<(u16, u16, u16)>>),
}

#[derive(Debug)]
struct PPM {
    width: usize,
    height: usize,
    maxval: u16,
    raster: PPMRaster,
}

impl PPM {
    fn write(&self, mut file: File) -> Result<(), io::Error> {
        file.write_all(&['P' as u8, '6' as u8, '\n' as u8])?;
        file.write_all(self.width.to_string().as_bytes())?;
        file.write_all(&[' ' as u8])?;
        file.write_all(self.height.to_string().as_bytes())?;
        file.write_all(&['\n' as u8])?;
        file.write_all(self.maxval.to_string().as_bytes())?;
        file.write_all(&['\n' as u8])?;
        let mut handle: BufWriter<File> = BufWriter::with_capacity(
            match self.maxval {
                0..256 => self.width * 3,
                _ => self.width * 6,
            },
            file,
        );
        for row in 0..self.height {
            for column in 0..self.width {
                match &self.raster {
                    PPMRaster::PPM8(pixels) => {
                        handle.write_all(&[
                            pixels[row][column].0,
                            pixels[row][column].1,
                            pixels[row][column].2,
                        ])?;
                    }
                    PPMRaster::PPM16(pixels) => {
                        handle.write_all(&pixels[row][column].0.to_be_bytes())?;
                        handle.write_all(&pixels[row][column].1.to_be_bytes())?;
                        handle.write_all(&pixels[row][column].2.to_be_bytes())?;
                    }
                }
            }
        }
        handle.flush()?;
        Ok(())
    }

    fn read(mut file: File) -> Result<PPM, Box<dyn Error>> {
        fn read_line(file: &mut File) -> Result<Vec<char>, io::Error> {
            let mut buf: Vec<char> = Vec::new();

            loop {
                let mut byte: [u8; 1] = Default::default();
                file.read_exact(&mut byte)?;
                let chr: char = byte[0] as char;
                match chr {
                    '#' => {
                        while (byte[0] as char) != '\r' && (byte[0] as char) != '\n' {
                            match file.read_exact(&mut byte) {
                                Ok(_) => {}
                                Err(why) => match why.kind() {
                                    ErrorKind::UnexpectedEof => {
                                        return Ok(buf);
                                    }
                                    _ => {
                                        return Err(why);
                                    }
                                },
                            }
                        }
                    }
                    '\t' | '\r' | '\n' | ' ' | '\x0b' | '\x0c' => {
                        return Ok(buf);
                    }
                    _ => {
                        buf.push(chr);
                    }
                }
            }
        }
        fn parse_number<N: FromStr>(v: Vec<char>) -> Result<N, <N as FromStr>::Err> {
            v.into_iter().collect::<String>().parse::<N>()
        }

        let magic_number: Vec<char> = read_line(&mut file)?;
        if magic_number != vec!['P', '6'] {
            return Err(format!(
                "This program only supports PPM files! (magic number = {:?})",
                magic_number
            )
            .into());
        }
        let width: usize = parse_number(read_line(&mut file)?)?;
        let height: usize = parse_number(read_line(&mut file)?)?;
        let maxval: u16 = parse_number(read_line(&mut file)?)?;

        let mut raster: PPMRaster;
        if maxval < 256 {
            raster = PPMRaster::PPM8(Vec::with_capacity(height));
        } else {
            raster = PPMRaster::PPM16(Vec::with_capacity(height));
        }

        let mut handle: BufReader<File> = match raster {
            PPMRaster::PPM8(_) => BufReader::with_capacity(width * 3, file),
            PPMRaster::PPM16(_) => BufReader::with_capacity(width * 6, file),
        };

        for row in 0..height {
            match raster {
                PPMRaster::PPM8(ref mut v) => v.push(Vec::with_capacity(width)),
                PPMRaster::PPM16(ref mut v) => v.push(Vec::with_capacity(width)),
            }
            for _ in 0..width {
                match raster {
                    PPMRaster::PPM8(ref mut v) => {
                        let mut buf: [u8; 3] = Default::default();
                        handle.read_exact(&mut buf)?;
                        v[row].push((buf[0], buf[1], buf[2]));
                    }
                    PPMRaster::PPM16(ref mut v) => {
                        let mut buf: [u8; 6] = Default::default();
                        handle.read_exact(&mut buf)?;
                        fn to_u16(a: u8, b: u8) -> u16 {
                            ((a as u16) << 8) | (b as u16)
                        }
                        v[row].push((
                            to_u16(buf[0], buf[1]),
                            to_u16(buf[2], buf[3]),
                            to_u16(buf[4], buf[5]),
                        ));
                    }
                }
            }
        }

        Ok(PPM {
            width,
            height,
            maxval,
            raster,
        })
    }
}

impl From<&PPM> for Raster<SRgb> {
    fn from(value: &PPM) -> Self {
        let mut floats: Vec<Vec<SRgb>>;
        match &value.raster {
            PPMRaster::PPM8(v) => {
                floats = Vec::with_capacity(v.len());
                for row in 0..v.len() {
                    floats.push(Vec::with_capacity(v[row].len()));
                    for pixel in 0..v[row].len() {
                        floats[row].push(SRgb::from((
                            f64::from(v[row][pixel].0) / (value.maxval as f64),
                            f64::from(v[row][pixel].1) / (value.maxval as f64),
                            f64::from(v[row][pixel].2) / (value.maxval as f64),
                        )));
                    }
                }
            }
            PPMRaster::PPM16(v) => {
                floats = Vec::with_capacity(v.len());
                for row in 0..v.len() {
                    floats.push(Vec::with_capacity(v[row].len()));
                    for pixel in 0..v[row].len() {
                        floats[row].push(SRgb::from((
                            f64::from(v[row][pixel].0) / (value.maxval as f64),
                            f64::from(v[row][pixel].1) / (value.maxval as f64),
                            f64::from(v[row][pixel].2) / (value.maxval as f64),
                        )));
                    }
                }
            }
        }

        Self(floats)
    }
}

impl From<(&Raster<SRgb>, u16)> for PPM {
    fn from(value: (&Raster<SRgb>, u16)) -> Self {
        let floats: &Vec<Vec<SRgb>> = &value.0.0;
        let maxval: u16 = value.1;
        PPM {
            width: floats[0].len(),
            height: floats.len(),
            maxval,
            raster: match maxval {
                0..256 => {
                    let mut integers: Vec<Vec<(u8, u8, u8)>> = Vec::with_capacity(floats.len());
                    for row in 0..floats.len() {
                        integers.push(Vec::with_capacity(floats[row].len()));
                        for pixel in 0..floats[row].len() {
                            integers[row].push((
                                (floats[row][pixel].r * (maxval as f64)).round() as u8,
                                (floats[row][pixel].g * (maxval as f64)).round() as u8,
                                (floats[row][pixel].b * (maxval as f64)).round() as u8,
                            ));
                        }
                    }
                    PPMRaster::PPM8(integers)
                }
                _ => {
                    let mut integers: Vec<Vec<(u16, u16, u16)>> = Vec::with_capacity(floats.len());
                    for row in 0..floats.len() {
                        integers.push(Vec::with_capacity(floats[row].len()));
                        for pixel in 0..floats[row].len() {
                            integers[row].push((
                                (floats[row][pixel].r * (maxval as f64)).round() as u16,
                                (floats[row][pixel].g * (maxval as f64)).round() as u16,
                                (floats[row][pixel].b * (maxval as f64)).round() as u16,
                            ));
                        }
                    }
                    PPMRaster::PPM16(integers)
                }
            },
        }
    }
}

macro_rules! color {
    ($color_space:ident { $first_component:ident , $second_component:ident , $third_component:ident }) => {
        #[derive(Debug, Clone, Copy)]
        struct $color_space {
            $first_component: f64,
            $second_component: f64,
            $third_component: f64,
        }

        impl From<$color_space> for (f64, f64, f64) {
            fn from(value: $color_space) -> Self {
                (
                    value.$first_component,
                    value.$second_component,
                    value.$third_component,
                )
            }
        }

        impl From<(f64, f64, f64)> for $color_space {
            fn from(value: (f64, f64, f64)) -> Self {
                Self {
                    $first_component: value.0,
                    $second_component: value.1,
                    $third_component: value.2,
                }
            }
        }
    };
}

color! {Xyz { x, y, z }}
color! {Rgb { r, g, b }}
color! {SRgb { r, g, b }}
color! {Lms { l, m, s }}

#[derive(Debug)]
struct Raster<C>(Vec<Vec<C>>);

impl<C> Raster<C> {
    fn apply<I, F: Fn(&C) -> I>(&self, function: F) -> Raster<I> {
        Raster(
            self.0
                .iter()
                .map(|row| row.iter().map(|pixel| function(pixel)).collect())
                .collect(),
        )
    }

    fn convert<I: for<'a> From<&'a C>>(&self) -> Raster<I> {
        self.apply(|pixel| pixel.into())
    }
}

/// https://en.wikipedia.org/wiki/SRGB#Transfer_function_(%22gamma%22)
impl From<&SRgb> for Rgb {
    fn from(value: &SRgb) -> Self {
        fn transfer(channel: f64) -> f64 {
            if channel <= 0.04045 {
                channel / 12.92
            } else {
                ((channel + 0.055) / 1.055).powf(2.4)
            }
        }
        Self {
            r: transfer(value.r),
            g: transfer(value.g),
            b: transfer(value.b),
        }
    }
}

/// https://en.wikipedia.org/wiki/SRGB#Transfer_function_(%22gamma%22)
impl From<&Rgb> for SRgb {
    fn from(value: &Rgb) -> Self {
        fn inverse_transfer(channel: f64) -> f64 {
            if channel < 0. {
                -inverse_transfer(-channel)
            } else if channel <= 0.0031308 {
                12.92 * channel
            } else {
                1.055 * channel.powf(1. / 2.4) - 0.055
            }
        }
        Self {
            r: inverse_transfer(value.r),
            g: inverse_transfer(value.g),
            b: inverse_transfer(value.b),
        }
    }
}

impl From<&Rgb> for Xyz {
    fn from(value: &Rgb) -> Self {
        Self {
            x: 0.4124 * value.r + 0.3576 * value.g + 0.1805 * value.b,
            y: 0.2126 * value.r + 0.7152 * value.g + 0.0722 * value.b,
            z: 0.0193 * value.r + 0.1192 * value.g + 0.9505 * value.b,
        }
    }
}

impl From<&Xyz> for Lms {
    fn from(value: &Xyz) -> Self {
        Self {
            l: 0.4002 * value.x + 0.7076 * value.y + -0.0808 * value.z,
            m: -0.2263 * value.x + 1.1653 * value.y + 0.0457 * value.z,
            s: 0.9182 * value.z,
        }
    }
}

impl From<&Lms> for Rgb {
    fn from(value: &Lms) -> Self {
        Self {
            r: 5.47250449 * value.l + -4.64219699 * value.m + 0.16956890 * value.s,
            g: -1.12470958 * value.l + 2.29262899 * value.m + -0.16786338 * value.s,
            b: 0.02992745 * value.l + -0.19325300 * value.m + 1.16341292 * value.s,
        }
    }
}

fn chromatic_adaption(pixel: &Lms, source: &Lms, target: &Lms) -> Lms {
    let d: f64 = F * (1. - (1. / 3.6) * f64::exp((-L_A - 42.) / 92.));
    Lms {
        l: ((target.l / source.l) * d + 1. - d) * pixel.l,
        m: ((target.m / source.m) * d + 1. - d) * pixel.m,
        s: ((target.s / source.s) * d + 1. - d) * pixel.s,
    }
}

/// Perform chromatic adaption on an LMS image
/// Takes source and target illuminants in LMS form as inputs
/// https://en.wikipedia.org/wiki/CIECAM02#CAT02
fn chromatic_adaption_raster(lms: &Raster<Lms>, source: &Lms, target: &Lms) -> Raster<Lms> {
    lms.apply(|pixel| chromatic_adaption(pixel, source, target))
}

/// Compute LMS coordinates coordinate of the D illuminant of the given temperature (in K)
/// Color temperature is rectified (e.g. 6500K -> 6503.51K).
/// Standard value of 1 for Y is used
fn standard_illuminant_d(temperature: f64) -> Result<Lms, &'static str> {
    // Adjust temperature (you know, Planck's constant sometime changes)
    let t: f64 = temperature * (C_2 / 1.4380);

    // Compute xy (CIE 1931) coordinates of the illuminant
    let x_d: f64;
    if temperature < 1667. {
        return Err("No D illuminant below 1667K.");
    } else if temperature <= 4000. {
        // /!\ Planckian locus approximation
        x_d = -0.2661239 * (1e9 / t.powf(3.)) - 0.2343589 * (1e6 / t.powf(2.))
            + 0.8776956 * (1e3 / t)
            + 0.179910
    } else if temperature <= 7000. {
        x_d = 0.244063 + (0.09911 * (1e3 / t)) + (2.9678 * (1e6 / t.powf(2.)))
            - (4.6070 * (1e9 / t.powf(3.)));
    } else if temperature <= 25000. {
        x_d = 0.237040 + (0.24748 * (1e3 / t)) + (1.9018 * (1e6 / t.powf(2.)))
            - (2.0064 * (1e9 / t.powf(3.)));
    } else {
        return Err("No D illuminant above 25000K");
    }
    let y_d: f64;
    if temperature <= 2222. {
        y_d = -1.1063814 * x_d.powf(3.) - 1.34811020 * x_d.powf(2.) + 2.18555832 * x_d - 0.20219683
    } else if temperature <= 4000. {
        y_d = -0.9549476 * x_d.powf(3.) - 1.37418593 * x_d.powf(2.) + 2.09137015 * x_d - 0.16748867;
    } else {
        y_d = (-3.000 * (x_d.powf(2.))) + (2.870 * x_d) - 0.275;
    }

    // Assuming Y = 1, convert xy (to xyY) to XYZ
    let xyz: Xyz = Xyz {
        x: (1. / y_d) * x_d,
        y: 1.,
        z: (1. / y_d) * (1. - x_d - y_d),
    };

    // Convert to LMS
    let lms: Lms = Lms::from(&xyz);

    Ok(lms)
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut args: Args = std::env::args();
    args.next();
    let input_path: &str = &args
        .next()
        .ok_or("First argument must be the path to the input file")?;
    let output_path: &str = &args
        .next()
        .ok_or("Second argument must be the path to the output file")?;

    // Target color temperature
    let target_illuminant: Lms = standard_illuminant_d(
        args.next()
            .map(|temperature| temperature.parse::<f64>().unwrap_or(4000.))
            .unwrap_or(4000.),
    )?;
    // sRGB encoding illuminant
    let source_illuminant: Lms = standard_illuminant_d(
        args.next()
            .map(|temperature| temperature.parse::<f64>().unwrap_or(6500.))
            .unwrap_or(6500.),
    )?;

    let path: &Path = Path::new(input_path);
    let file: File = File::open(&path)?;

    let ppm: PPM = PPM::read(file)?;
    let s_rgb_raster: Raster<SRgb> = Raster::from(&ppm);

    // Multiple functions version
    // Caution: memory intensive!
    /*
    let rgb_raster: Raster<Rgb> = s_rgb_raster.convert::<Rgb>();
    let xyz_raster: Raster<Xyz> = rgb_raster.convert::<Xyz>();
    let lms_raster: Raster<Lms> = xyz_raster.convert::<Lms>();
    let lms_raster_adapt: Raster<Lms> =
        chromatic_adaption_raster(&lms_raster, &source_illuminant, &target_illuminant);
    let rgb_raster_adapt: Raster<Rgb> = lms_raster_adapt.convert::<Rgb>();
    let s_rgb_raster_adapt: Raster<SRgb> = rgb_raster_adapt.convert::<SRgb>();
    */

    // Single function version
    let s_rgb_raster_adapt: Raster<SRgb> = s_rgb_raster.apply(|pixel| {
        SRgb::from(&Rgb::from(&chromatic_adaption(
            &Lms::from(&Xyz::from(&Rgb::from(pixel))),
            &source_illuminant,
            &target_illuminant,
        )))
    });

    let output: PPM = PPM::from((&s_rgb_raster_adapt, ppm.maxval));
    output.write(File::create(Path::new(output_path))?)?;

    Ok(())
}