use std::collections::BTreeMap;
use std::env;
use std::fmt::Write as _;
use std::fs;
use std::path::PathBuf;
const GRID_LEN: usize = 71;
const MAGIC: &[u8; 8] = b"KALOFILM";
const PAPER_MAGIC: &[u8; 8] = b"KALOPAPR";
fn main() {
let mut films: Vec<Film> = kallo_data::FILMS
.iter()
.map(|source| read(source.name, source.bytes))
.filter(|film| film.kind == Kind::Film)
.collect();
let mut papers: Vec<Film> = kallo_data::PAPERS
.iter()
.map(|source| read(source.name, source.bytes))
.filter(|film| film.kind == Kind::Paper)
.collect();
assert!(!films.is_empty(), "the data crate carries no films");
films.sort_by(|a, b| a.header.get("", "id").cmp(b.header.get("", "id")));
papers.sort_by(|a, b| a.header.get("", "id").cmp(b.header.get("", "id")));
let mut code = String::new();
code.push_str("// @generated by build.rs from the `.kalofilm` files. Do not edit.\n\n");
code.push_str("/// A zero mask: a reversal has no orange mask, and the format says so by\n");
code.push_str("/// omitting the table.\n");
code.push_str("pub(crate) const NO_MASK: [f64; GRID_LEN] = [0.0; GRID_LEN];\n\n");
code.push_str(
"/// The VISION3 500T digitisation, the dye and mask set every negative without\n",
);
code.push_str("/// its own borrows. Read from that film's own file.\n");
code.push_str("pub(crate) const FILM_DYES: [[f64; GRID_LEN]; 3] = DYES_VISION3_500T;\n");
code.push_str("pub(crate) const FILM_MASK: [f64; GRID_LEN] = MASK_VISION3_500T;\n\n");
code.push_str("/// The paper spectra the same way: the metallic sheet's set is the\n");
code.push_str("/// compiled default, and E-4021's set is the one its two papers share.\n");
code.push_str(
"pub(crate) const PAPER_DYES: [[f64; GRID_LEN]; 3] = DYES_ENDURA_PREMIER_METALLIC;\n",
);
code.push_str(
"pub(crate) const PAPER_LAYERS: [[f64; GRID_LEN]; 3] = LAYERS_ENDURA_PREMIER_METALLIC;\n",
);
code.push('\n');
for (index, film) in films.iter().enumerate() {
film.emit_tables(&mut code, index);
}
code.push_str("/// Every film stock, in id order.\n");
code.push_str("#[allow(clippy::approx_constant)] // a measurement can sit near pi\n");
code.push_str("pub static FILM_STOCKS: &[FilmStock] = &[\n");
for (index, film) in films.iter().enumerate() {
film.emit_stock(&mut code, index);
}
code.push_str("];\n");
for (index, paper) in papers.iter().enumerate() {
paper.emit_paper_tables(&mut code, index);
}
code.push_str("/// Every paper stock, in id order.\n");
code.push_str("pub static PAPER_STOCKS: &[PaperStock] = &[\n");
for (index, paper) in papers.iter().enumerate() {
paper.emit_paper(&mut code, index);
}
code.push_str("];\n");
let out = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR")).join("film_stocks.rs");
fs::write(&out, code).expect("write the generated film table");
println!("cargo:rerun-if-changed=build.rs");
}
struct Header {
sections: BTreeMap<String, BTreeMap<String, String>>,
}
fn escaped(text: &str) -> String {
text.replace('\\', "\\\\").replace('"', "\\\"")
}
const MEASURED_ORDER: [&str; 7] = [
"curves", "layers", "dyes", "mask", "mtf", "grain", "cl_layer",
];
impl Header {
fn get(&self, section: &str, key: &str) -> &str {
let value = self
.sections
.get(section)
.and_then(|values| values.get(key))
.map(String::as_str)
.unwrap_or_else(|| panic!("header has no `{section}.{key}`"));
value.trim_matches('"')
}
fn number(&self, section: &str, key: &str) -> f64 {
self.get(section, key)
.parse()
.unwrap_or_else(|_| panic!("`{section}.{key}` is not a number"))
}
fn numbers(&self, section: &str, key: &str) -> Vec<f64> {
let text = self.get(section, key);
let inner = text
.strip_prefix('[')
.and_then(|rest| rest.strip_suffix(']'))
.unwrap_or_else(|| panic!("`{section}.{key}` is not an array"));
inner
.split(',')
.map(str::trim)
.filter(|part| !part.is_empty())
.map(|part| part.parse().expect("an array of numbers"))
.collect()
}
fn optional(&self, section: &str, key: &str) -> Option<&str> {
self.sections
.get(section)
.and_then(|values| values.get(key))
.map(String::as_str)
}
fn maybe(&self, section: &str, key: &str) -> Option<&str> {
self.optional(section, key)
.map(|value| value.trim_matches('"'))
}
}
struct Film {
header: Header,
tables: BTreeMap<String, Vec<Vec<f64>>>,
kind: Kind,
}
fn read(name: &str, bytes: &[u8]) -> Film {
assert!(bytes.len() >= 16, "{name}: shorter than a header");
let magic = &bytes[..8];
assert!(
magic == MAGIC || magic == PAPER_MAGIC,
"{name}: neither a kalofilm nor a kalopaper"
);
let kind = if magic == PAPER_MAGIC {
Kind::Paper
} else {
Kind::Film
};
let header_length = u32::from_le_bytes(bytes[12..16].try_into().expect("four bytes")) as usize;
let header_text = std::str::from_utf8(&bytes[16..16 + header_length]).expect("utf-8 header");
let header = parse_header(header_text, name);
let mut tables = BTreeMap::new();
let mut offset = 16 + header_length;
let names = header.get("", "tables");
let names = names
.strip_prefix('[')
.and_then(|rest| rest.strip_suffix(']'))
.unwrap_or(names);
for name in names.split(',') {
let name = name.trim().trim_matches('"').to_string();
let rows = if name == "mask" || name == "cl_sensitivity" {
1
} else {
3
};
let bytes_needed = rows * GRID_LEN * 8;
let mut table = Vec::with_capacity(rows);
for row in 0..rows {
let mut values = Vec::with_capacity(GRID_LEN);
for column in 0..GRID_LEN {
let start = offset + (row * GRID_LEN + column) * 8;
let value =
f64::from_le_bytes(bytes[start..start + 8].try_into().expect("eight bytes"));
values.push(value);
}
table.push(values);
}
offset += bytes_needed;
tables.insert(name, table);
}
Film {
header,
tables,
kind,
}
}
#[derive(PartialEq, Eq, Clone, Copy)]
enum Kind {
Film,
Paper,
}
fn parse_header(text: &str, name: &str) -> Header {
let mut sections: BTreeMap<String, BTreeMap<String, String>> = BTreeMap::new();
sections.insert(String::new(), BTreeMap::new());
let mut current = String::new();
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
if let Some(name) = line
.strip_prefix('[')
.and_then(|rest| rest.strip_suffix(']'))
{
current = name.trim().to_string();
sections.entry(current.clone()).or_default();
continue;
}
let (key, value) = line
.split_once('=')
.unwrap_or_else(|| panic!("{name}: unparseable header line {line:?}"));
sections
.entry(current.clone())
.or_default()
.insert(key.trim().to_string(), value.trim().to_string());
}
Header { sections }
}
impl Film {
fn id(&self) -> &str {
self.header.get("", "id")
}
fn ident(&self) -> String {
self.id()
.chars()
.map(|c| {
if c.is_ascii_alphanumeric() {
c.to_ascii_uppercase()
} else {
'_'
}
})
.collect()
}
fn table(&self, name: &str) -> Option<&Vec<Vec<f64>>> {
self.tables.get(name)
}
fn emit_tables(&self, code: &mut String, index: usize) {
let ident = self.ident();
if let Some(layers) = self.table("layers") {
emit_matrix(code, &format!("LAYERS_{ident}"), layers);
}
if let Some(dyes) = self.table("dyes") {
emit_matrix(code, &format!("DYES_{ident}"), dyes);
}
if let Some(mask) = self.table("mask") {
emit_row(code, &format!("MASK_{ident}"), &mask[0]);
}
if let Some(cl) = self.table("cl_sensitivity") {
emit_row(code, &format!("CL_{ident}"), &cl[0]);
}
let _ = index;
}
fn emit_stock(&self, code: &mut String, index: usize) {
let ident = self.ident();
let process = match self.header.get("", "process") {
"negative" => "FilmProcess::Negative",
"reversal" => "FilmProcess::Reversal",
"monochrome" => "FilmProcess::Monochrome",
other => panic!("unknown process {other:?}"),
};
let label = self.header.get("", "label");
let short = escaped(self.header.maybe("", "short").unwrap_or(label));
let note = escaped(self.header.get("provenance", "note"));
let sigma = self.header.numbers("character", "sigma_um");
let sigma = if sigma.iter().all(|value| *value == 0.0) {
"None".to_string()
} else {
format!("Some([{:.5}, {:.5}, {:.5}])", sigma[0], sigma[1], sigma[2])
};
let base = self.header.numbers("character", "base_density");
let grains = self.header.numbers("character", "grains_per_um2");
let time = self.header.number("development", "reference_time_min");
let temp = self.header.number("development", "reference_temp_c");
writeln!(code, " FilmStock {{").unwrap();
writeln!(code, " id: \"{}\",", self.id()).unwrap();
writeln!(code, " short: \"{short}\",").unwrap();
writeln!(code, " process: {process},").unwrap();
writeln!(code, " extra_cyan: None,").unwrap();
match self.table("cl_sensitivity") {
Some(_) => {
writeln!(
code,
" cl_layer: Some(crate::dye::InhibitorLayer {{ sensitivity: &CL_{ident} }}),"
)
.unwrap();
}
None => writeln!(code, " cl_layer: None,").unwrap(),
}
writeln!(code, " label: \"{label}\",").unwrap();
writeln!(code, " note: \"{note}\",").unwrap();
writeln!(code, " channels: [").unwrap();
for channel in ["red", "green", "blue"] {
let section = format!("curve.{channel}");
let d_min = self.header.number(§ion, "d_min");
let d_max = self.header.number(§ion, "d_max");
let gamma = self.header.number(§ion, "gamma");
let log_e0 = self.header.number(§ion, "log_e0");
let shared: f64 = self
.header
.optional(§ion, "transition")
.map(|value| value.parse().expect("a number"))
.unwrap_or(4.0);
let toe: f64 = self
.header
.optional(§ion, "toe_transition")
.map_or(shared, |value| value.parse().expect("a number"));
let shoulder: f64 = self
.header
.optional(§ion, "shoulder_transition")
.map_or(shared, |value| value.parse().expect("a number"));
if (toe - shoulder).abs() < f64::EPSILON {
writeln!(
code,
" curve({d_min:.5}, {d_max:.5}, {gamma:.5}, {log_e0:.5}).with_transition({toe:.1}),"
)
.unwrap();
} else {
writeln!(
code,
" curve({d_min:.5}, {d_max:.5}, {gamma:.5}, {log_e0:.5}).with_corners({toe:.1}, {shoulder:.1}),"
)
.unwrap();
}
}
writeln!(code, " ],").unwrap();
writeln!(
code,
" base_density: [{:.4}, {:.4}, {:.4}],",
base[0], base[1], base[2]
)
.unwrap();
writeln!(
code,
" grains_per_um2: [{:.4}, {:.4}, {:.4}],",
grains[0], grains[1], grains[2]
)
.unwrap();
writeln!(code, " layers: &LAYERS_{ident},").unwrap();
writeln!(code, " dyes: &DYES_{ident},").unwrap();
match self.table("mask") {
Some(_) => writeln!(code, " mask: &MASK_{ident},").unwrap(),
None => writeln!(code, " mask: &NO_MASK,").unwrap(),
}
writeln!(code, " sigma_um: {sigma},").unwrap();
writeln!(code, " reference_time_min: {time:.4},").unwrap();
writeln!(code, " reference_temp_c: {temp:.4},").unwrap();
self.emit_provenance(code);
self.emit_measured(code);
writeln!(code, " }},").unwrap();
let _ = index;
}
fn emit_provenance(&self, code: &mut String) {
let field = |key: &str| escaped(self.header.maybe("provenance", key).unwrap_or(""));
writeln!(code, " provenance: Provenance {{").unwrap();
for name in ["publication", "page", "retrieved", "checksum"] {
writeln!(code, " {name}: \"{}\",", field(name)).unwrap();
}
writeln!(code, " }},").unwrap();
}
fn emit_measured(&self, code: &mut String) {
let Some(section) = self.header.sections.get("measured") else {
writeln!(code, " measured: &[],").unwrap();
return;
};
let mut names: Vec<&str> = MEASURED_ORDER
.iter()
.copied()
.filter(|name| section.contains_key(*name))
.collect();
for name in section.keys() {
if !names.contains(&name.as_str()) {
names.push(name.as_str());
}
}
writeln!(code, " measured: &[").unwrap();
for name in names {
let value = escaped(section[name].trim_matches('"'));
writeln!(code, " (\"{name}\", \"{value}\"),").unwrap();
}
writeln!(code, " ],").unwrap();
}
fn emit_paper_tables(&self, code: &mut String, _index: usize) {
let ident = self.ident();
if let Some(dyes) = self.table("dyes") {
emit_matrix(code, &format!("DYES_{ident}"), dyes);
}
if let Some(layers) = self.table("layers") {
emit_matrix(code, &format!("LAYERS_{ident}"), layers);
}
}
fn emit_paper(&self, code: &mut String, _index: usize) {
let ident = self.ident();
let label = self.header.get("", "label");
let short = escaped(self.header.maybe("", "short").unwrap_or(label));
let note = escaped(self.header.get("provenance", "note"));
let emulsion = match self.header.maybe("", "emulsion").unwrap_or("colour") {
"colour" => "PaperEmulsion::Colour",
"silver" => "PaperEmulsion::Silver",
other => panic!("unknown paper emulsion {other:?}"),
};
let d_min = self.header.number("curve", "d_min");
let d_max = self.header.number("curve", "d_max");
let gamma = self.header.number("curve", "gamma");
let log_e0 = self.header.number("curve", "log_e0");
let transition = self
.header
.optional("curve", "transition")
.map_or(7.0, |value| value.parse().expect("a number"));
let target = self.header.number("character", "target_mid_reflectance");
writeln!(code, " PaperStock {{").unwrap();
writeln!(code, " id: \"{}\",", self.id()).unwrap();
writeln!(code, " short: \"{short}\",").unwrap();
writeln!(code, " emulsion: {emulsion},").unwrap();
writeln!(code, " label: \"{label}\",").unwrap();
writeln!(code, " note: \"{note}\",").unwrap();
writeln!(
code,
" channel: curve({d_min:.5}, {d_max:.5}, {gamma:.5}, {log_e0:.5}).with_transition({transition:.1}),"
)
.unwrap();
writeln!(code, " target_mid_reflectance: {target:.2},").unwrap();
writeln!(code, " dyes: &DYES_{ident},").unwrap();
writeln!(code, " layers: &LAYERS_{ident},").unwrap();
self.emit_provenance(code);
self.emit_measured(code);
writeln!(code, " }},").unwrap();
}
}
fn emit_matrix(code: &mut String, name: &str, rows: &[Vec<f64>]) {
writeln!(code, "#[allow(clippy::approx_constant)]").unwrap();
writeln!(code, "const {name}: [[f64; GRID_LEN]; 3] = [").unwrap();
for row in rows {
emit_row(code, "", row);
}
writeln!(code, "];\n").unwrap();
}
fn emit_row(code: &mut String, name: &str, row: &[f64]) {
if name.is_empty() {
code.push_str(" [");
} else {
writeln!(code, "#[allow(clippy::approx_constant)]").unwrap();
write!(code, "const {name}: [f64; GRID_LEN] = [").unwrap();
}
for (index, value) in row.iter().enumerate() {
if index > 0 {
code.push_str(", ");
}
write!(code, "{value:.5}").unwrap();
}
if name.is_empty() {
code.push_str("],\n");
} else {
code.push_str("];\n\n");
}
}