use std::io::Write;
use crate::error::{Result, Tm25Error};
use crate::header::{
columns_from_flags, FluxKind, Header, KnownDataFlags, SpectralId, SpectralTable,
};
use crate::ray::Ray;
pub const LT_MAGIC: [u8; 4] = *b"LTRF";
pub const LT_END: [u8; 7] = *b"LTRFEND";
pub const LT_HEADER_SIZE: usize = 44;
pub const LIGHTTOOLS_VERSION_TAG: i32 = 2;
pub fn is_lighttools(bytes: &[u8]) -> bool {
bytes.len() >= 4 && bytes[..4] == LT_MAGIC
}
#[derive(Clone, Debug, PartialEq)]
pub struct LightToolsHeader {
pub major_version: u32,
pub minor_version: u32,
pub flux_kind: FluxKind,
pub far_field: bool,
pub per_ray_wavelength: bool,
pub length_unit: u32,
pub origin: [f32; 3],
pub total_flux: f32,
}
impl LightToolsHeader {
pub fn from_tm25(h: &Header) -> Result<Self> {
let (flux_kind, total_flux) = if h.flags.radiant_flux {
(FluxKind::Radiometric, h.radiant_flux_w)
} else if h.flags.luminous_flux {
(FluxKind::Photometric, h.luminous_flux_lm)
} else {
return Err(Tm25Error::InvalidHeader(
"no flux column to export to LightTools".into(),
));
};
let per_ray_wavelength =
h.flags.wavelength && h.spectral_id == SpectralId::PerRayWavelength;
if per_ray_wavelength && flux_kind == FluxKind::Photometric {
return Err(Tm25Error::InvalidHeader(
"LightTools does not combine a wavelength per ray with photometric flux".into(),
));
}
Ok(Self {
major_version: 2,
minor_version: 0,
flux_kind,
far_field: false,
per_ray_wavelength,
length_unit: 1,
origin: [0.0; 3],
total_flux,
})
}
pub fn ray_count_for_size(&self, file_size: u64) -> u64 {
file_size.saturating_sub((LT_HEADER_SIZE + LT_END.len()) as u64) / self.record_size() as u64
}
pub fn file_size_for(&self, n_rays: u64) -> u64 {
LT_HEADER_SIZE as u64 + n_rays * self.record_size() as u64 + LT_END.len() as u64
}
pub fn to_tm25_header(&self, name: &str, file_size: Option<u64>) -> Header {
let mut flags = KnownDataFlags::radiometric();
if self.flux_kind == FluxKind::Photometric {
flags.radiant_flux = false;
flags.luminous_flux = true;
}
flags.wavelength = self.per_ray_wavelength;
let mut h = Header::new(flags);
h.version = LIGHTTOOLS_VERSION_TAG;
h.creation_method = -1;
match self.flux_kind {
FluxKind::Photometric => h.luminous_flux_lm = self.total_flux,
_ => h.radiant_flux_w = self.total_flux,
}
h.spectral_id = if self.per_ray_wavelength {
SpectralId::PerRayWavelength
} else {
SpectralId::None
};
h.text.raw[0] = name.to_string();
h.text.raw[3] = "LightTools binary ray file".to_string();
h.text.raw[8] = format!(
"LightTools ray file v{}.{}, length unit {}, origin ({}, {}, {})",
self.major_version,
self.minor_version,
match self.length_unit {
0 => "system",
1 => "mm",
2 => "cm",
3 => "m",
4 => "inch",
5 => "ft",
6 => "µm",
7 => "nm",
_ => "?",
},
self.origin[0],
self.origin[1],
self.origin[2]
);
h.columns = columns_from_flags(&flags, 0);
h.ray_start = LT_HEADER_SIZE;
h.n_rays = file_size.map(|s| self.ray_count_for_size(s)).unwrap_or(0);
h
}
pub fn record_size(&self) -> usize {
if self.per_ray_wavelength {
32
} else {
28
}
}
pub fn encode(&self) -> [u8; LT_HEADER_SIZE] {
let mut out = [0u8; LT_HEADER_SIZE];
let mut p = 0;
let mut put = |b: [u8; 4]| {
out[p..p + 4].copy_from_slice(&b);
p += 4;
};
put(LT_MAGIC);
put(self.major_version.to_le_bytes());
put(self.minor_version.to_le_bytes());
put(((self.flux_kind == FluxKind::Photometric) as u32).to_le_bytes());
put((self.far_field as u32).to_le_bytes());
put((if self.per_ray_wavelength { 2u32 } else { 0 }).to_le_bytes());
put(self.length_unit.to_le_bytes());
put(self.origin[0].to_le_bytes());
put(self.origin[1].to_le_bytes());
put(self.origin[2].to_le_bytes());
put(self.total_flux.to_le_bytes());
out
}
pub fn parse(bytes: &[u8]) -> Result<Self> {
if bytes.len() < LT_HEADER_SIZE {
return Err(Tm25Error::Truncated {
needed: LT_HEADER_SIZE,
have: bytes.len(),
});
}
let u32_at =
|i: usize| u32::from_le_bytes([bytes[i], bytes[i + 1], bytes[i + 2], bytes[i + 3]]);
let f32_at = |i: usize| f32::from_bits(u32_at(i));
let magic = [bytes[0], bytes[1], bytes[2], bytes[3]];
if magic != LT_MAGIC {
return Err(Tm25Error::BadMagic(magic));
}
let major_version = u32_at(4);
if major_version != 2 {
return Err(Tm25Error::UnsupportedVersion(major_version as i32));
}
let flux_kind = match u32_at(12) {
0 => FluxKind::Radiometric,
1 => FluxKind::Photometric,
v => {
return Err(Tm25Error::InvalidHeader(format!(
"LightTools data type {v}"
)))
}
};
let per_ray_wavelength = match u32_at(20) {
0 => false,
2 => true,
v => {
return Err(Tm25Error::InvalidHeader(format!(
"LightTools colour info {v}"
)))
}
};
Ok(Self {
major_version,
minor_version: u32_at(8),
flux_kind,
far_field: u32_at(16) != 0,
per_ray_wavelength,
length_unit: u32_at(24),
origin: [f32_at(28), f32_at(32), f32_at(36)],
total_flux: f32_at(40),
})
}
}
fn put_f32(out: &mut Vec<u8>, v: f32) {
out.extend_from_slice(&v.to_le_bytes());
}
fn encode_ray(lt: &LightToolsHeader, ray: &Ray, out: &mut Vec<u8>) {
put_f32(out, ray.x);
put_f32(out, ray.y);
put_f32(out, ray.z);
put_f32(out, ray.kx);
put_f32(out, ray.ky);
put_f32(out, ray.kz);
let flux = match lt.flux_kind {
FluxKind::Photometric => ray.luminous_flux_lm.unwrap_or(0.0),
_ => ray.radiant_flux_w.unwrap_or(0.0),
};
put_f32(out, flux);
if lt.per_ray_wavelength {
put_f32(out, ray.wavelength_nm.unwrap_or(0.0));
}
}
pub fn write_lighttools<W: Write, I: IntoIterator<Item = Ray>>(
mut w: W,
header: &LightToolsHeader,
rays: I,
) -> Result<u64> {
w.write_all(&header.encode())?;
let mut buf = Vec::with_capacity(header.record_size() * 4096);
let mut n = 0u64;
for ray in rays {
encode_ray(header, &ray, &mut buf);
n += 1;
if buf.len() >= header.record_size() * 4096 {
w.write_all(&buf)?;
buf.clear();
}
}
w.write_all(&buf)?;
w.write_all(<_END)?;
w.flush()?;
Ok(n)
}
pub fn to_lighttools_bytes(h: &Header, rays: &[Ray]) -> Result<Vec<u8>> {
let lt = LightToolsHeader::from_tm25(h)?;
let mut out = Vec::with_capacity(LT_HEADER_SIZE + rays.len() * lt.record_size() + LT_END.len());
write_lighttools(&mut out, <, rays.iter().copied())?;
Ok(out)
}
#[derive(Clone, Debug, PartialEq)]
pub struct LightToolsFile {
pub header: LightToolsHeader,
pub rays: Vec<Ray>,
}
impl LightToolsFile {
pub fn to_tm25(&self, name: &str) -> (Header, Vec<Ray>) {
let size = self.header.file_size_for(self.rays.len() as u64);
(
self.header.to_tm25_header(name, Some(size)),
self.rays.clone(),
)
}
pub fn parse(bytes: &[u8]) -> Result<Self> {
let header = LightToolsHeader::parse(bytes)?;
if header.far_field {
return Err(Tm25Error::InvalidHeader(
"LightTools far-field file without start points".into(),
));
}
let rec = header.record_size();
let body = bytes.get(LT_HEADER_SIZE..).unwrap_or(&[]);
let Some(end) = body.len().checked_sub(LT_END.len()) else {
return Err(Tm25Error::Truncated {
needed: LT_HEADER_SIZE + LT_END.len(),
have: bytes.len(),
});
};
if body[end..] != LT_END {
return Err(Tm25Error::InvalidHeader("missing LTRFEND trailer".into()));
}
if end % rec != 0 {
return Err(Tm25Error::SizeMismatch {
ray_start: LT_HEADER_SIZE,
expected: (end / rec * rec) as u64,
actual: end as u64,
});
}
let f = |r: &[u8], i: usize| {
f32::from_le_bytes([r[4 * i], r[4 * i + 1], r[4 * i + 2], r[4 * i + 3]])
};
let rays = body[..end]
.chunks_exact(rec)
.map(|r| {
let mut ray = Ray::new([f(r, 0), f(r, 1), f(r, 2)], [f(r, 3), f(r, 4), f(r, 5)]);
match header.flux_kind {
FluxKind::Photometric => ray.luminous_flux_lm = Some(f(r, 6)),
_ => ray.radiant_flux_w = Some(f(r, 6)),
}
if header.per_ray_wavelength {
ray.wavelength_nm = Some(f(r, 7));
}
ray
})
.collect();
Ok(Self { header, rays })
}
}
pub fn write_sre(t: &SpectralTable, name: &str) -> String {
let peak = t.values.iter().cloned().fold(0.0f32, f32::max);
let scale = if peak > 0.0 { 1.0 / peak } else { 1.0 };
let name = name.replace(['\r', '\n', '\t'], " ");
let mut s = String::with_capacity(64 + t.len() * 18);
s.push_str(&format!(
"#\t{name}\r\ndfat 1.0\t\r\ndataname:\t{name}\r\ncontinuous\t\r\nradiometric\t\r\n"
));
for (w, v) in t.wavelengths_nm.iter().zip(&t.values) {
s.push_str(&format!("{w:.4}\t{:.4}\r\n", v * scale));
}
s
}
pub fn spectrum_from_rays<'a, I: IntoIterator<Item = &'a Ray>>(
rays: I,
kind: FluxKind,
bin_nm: f32,
) -> Option<SpectralTable> {
let bin = if bin_nm > 0.0 { bin_nm } else { 5.0 };
let mut sums: std::collections::BTreeMap<i64, f64> = std::collections::BTreeMap::new();
for r in rays {
let Some(w) = r.wavelength_nm else { continue };
if !w.is_finite() {
continue;
}
*sums.entry((w / bin).floor() as i64).or_default() += r.flux(kind) as f64;
}
let (&lo, _) = sums.first_key_value()?;
let (&hi, _) = sums.last_key_value()?;
let mut t = SpectralTable::default();
for k in lo..=hi {
t.wavelengths_nm.push((k as f32 + 0.5) * bin);
t.values.push(sums.get(&k).copied().unwrap_or(0.0) as f32);
}
Some(t)
}
#[derive(Clone, Debug)]
pub struct SpectrumSampler {
w: Vec<f64>,
v: Vec<f64>,
cdf: Vec<f64>,
}
impl SpectrumSampler {
pub fn new(t: &SpectralTable) -> Option<Self> {
if t.len() < 2 || t.wavelengths_nm.len() != t.values.len() {
return None;
}
let w: Vec<f64> = t.wavelengths_nm.iter().map(|x| *x as f64).collect();
let v: Vec<f64> = t.values.iter().map(|x| (*x as f64).max(0.0)).collect();
let mut cdf = Vec::with_capacity(w.len() - 1);
let mut acc = 0.0;
for i in 0..w.len() - 1 {
acc += (v[i] + v[i + 1]) * 0.5 * (w[i + 1] - w[i]).max(0.0);
cdf.push(acc);
}
if acc <= 0.0 {
return None;
}
for c in &mut cdf {
*c /= acc;
}
Some(Self { w, v, cdf })
}
pub fn sample(&self, u: f64) -> f32 {
let u = u.clamp(0.0, 1.0 - 1e-12);
let i = self
.cdf
.partition_point(|c| *c <= u)
.min(self.cdf.len() - 1);
let c0 = if i == 0 { 0.0 } else { self.cdf[i - 1] };
let span = (self.cdf[i] - c0).max(1e-300);
let t = ((u - c0) / span).clamp(0.0, 1.0);
let (a, b) = (self.v[i], self.v[i + 1]);
let x = if (a - b).abs() < 1e-12 * (a + b).max(1e-300) {
t
} else {
let s = (a + b) * 0.5;
let disc = (a * a + 2.0 * (b - a) * s * t).max(0.0);
((disc.sqrt() - a) / (b - a)).clamp(0.0, 1.0)
};
(self.w[i] + (self.w[i + 1] - self.w[i]) * x) as f32
}
}
pub fn write_lighttools_sampled<W: Write, I: IntoIterator<Item = Ray>>(
w: W,
h: &Header,
rays: I,
seed: u64,
) -> Result<u64> {
let table = h.shared_spectrum().ok_or_else(|| {
Tm25Error::InvalidHeader("no shared spectral table to sample from".into())
})?;
let sampler = SpectrumSampler::new(table)
.ok_or_else(|| Tm25Error::InvalidHeader("spectral table has no usable values".into()))?;
if !h.flags.radiant_flux {
return Err(Tm25Error::InvalidHeader(
"LightTools takes a wavelength per ray only with radiant flux".into(),
));
}
let lt = LightToolsHeader {
per_ray_wavelength: true,
..LightToolsHeader::from_tm25(h)?
};
let mut rng = crate::sample::Rng64::new(seed);
write_lighttools(
w,
<,
rays.into_iter()
.map(move |r| r.with_wavelength(sampler.sample(rng.next_f64()))),
)
}
pub fn to_lighttools_bytes_sampled(h: &Header, rays: &[Ray], seed: u64) -> Result<Vec<u8>> {
let mut out = Vec::with_capacity(LT_HEADER_SIZE + rays.len() * 32 + LT_END.len());
write_lighttools_sampled(&mut out, h, rays.iter().copied(), seed)?;
Ok(out)
}