use std::io::Write;
use crate::error::{Result, Tm25Error};
use crate::header::{FluxKind, Header, SpectralId};
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;
#[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 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 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 })
}
}