123 lines
3.6 KiB
Rust
123 lines
3.6 KiB
Rust
pub mod decoder;
|
|
pub mod demosaicing;
|
|
pub mod metadata;
|
|
pub mod postprocessing;
|
|
pub mod preprocessing;
|
|
pub mod tiff;
|
|
|
|
use crate::metadata::identify::CameraModel;
|
|
|
|
use tag_derive::Tag;
|
|
use tiff::file::TiffRead;
|
|
use tiff::tags::{Compression, ImageLength, ImageWidth, Orientation, StripByteCounts, SubIfd, Tag};
|
|
use tiff::values::Transform;
|
|
use tiff::{Ifd, TiffError};
|
|
|
|
use std::io::{Read, Seek};
|
|
use thiserror::Error;
|
|
|
|
pub enum SubtractBlack {
|
|
None,
|
|
Value(u16),
|
|
CfaGrid([u16; 4]),
|
|
}
|
|
|
|
pub struct RawImage {
|
|
pub data: Vec<u16>,
|
|
pub width: usize,
|
|
pub height: usize,
|
|
pub cfa_pattern: [u8; 4],
|
|
pub transform: Transform,
|
|
pub maximum: u16,
|
|
pub black: SubtractBlack,
|
|
pub camera_model: Option<CameraModel>,
|
|
pub camera_white_balance_multiplier: Option<[f64; 4]>,
|
|
pub white_balance_multiplier: Option<[f64; 4]>,
|
|
pub camera_to_rgb: Option<[[f64; 3]; 3]>,
|
|
pub rgb_to_camera: Option<[[f64; 3]; 3]>,
|
|
}
|
|
|
|
pub struct Image<T> {
|
|
pub data: Vec<T>,
|
|
pub width: usize,
|
|
pub height: usize,
|
|
/// We can assume this will be 3 for all non-obscure, modern cameras.
|
|
/// See <https://github.com/GraphiteEditor/Graphite/pull/1923#discussion_r1725070342> for more information.
|
|
pub channels: u8,
|
|
pub transform: Transform,
|
|
pub rgb_to_camera: Option<[[f64; 3]; 3]>,
|
|
pub(crate) histogram: Option<[[usize; 0x2000]; 3]>,
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(Tag)]
|
|
struct ArwIfd {
|
|
image_width: ImageWidth,
|
|
image_height: ImageLength,
|
|
compression: Compression,
|
|
strip_byte_counts: StripByteCounts,
|
|
}
|
|
|
|
pub fn decode<R: Read + Seek>(reader: &mut R) -> Result<RawImage, DecoderError> {
|
|
let mut file = TiffRead::new(reader)?;
|
|
let ifd = Ifd::new_first_ifd(&mut file)?;
|
|
|
|
let camera_model = metadata::identify::identify_camera_model(&ifd, &mut file).unwrap();
|
|
let transform = ifd.get_value::<Orientation, _>(&mut file)?;
|
|
|
|
let mut raw_image = if camera_model.model == "DSLR-A100" {
|
|
decoder::arw1::decode_a100(ifd, &mut file)
|
|
} else {
|
|
let sub_ifd = ifd.get_value::<SubIfd, _>(&mut file)?;
|
|
let arw_ifd = sub_ifd.get_value::<ArwIfd, _>(&mut file)?;
|
|
|
|
if arw_ifd.compression == 1 {
|
|
decoder::uncompressed::decode(sub_ifd, &mut file)
|
|
} else if arw_ifd.strip_byte_counts[0] == arw_ifd.image_width * arw_ifd.image_height {
|
|
decoder::arw2::decode(sub_ifd, &mut file)
|
|
} else {
|
|
// TODO: implement for arw 1.
|
|
todo!()
|
|
}
|
|
};
|
|
|
|
raw_image.camera_model = Some(camera_model);
|
|
raw_image.transform = transform;
|
|
|
|
Ok(raw_image)
|
|
}
|
|
|
|
pub fn process_8bit(raw_image: RawImage) -> Image<u8> {
|
|
let image = process_16bit(raw_image);
|
|
|
|
Image {
|
|
channels: image.channels,
|
|
data: image.data.iter().map(|x| (x >> 8) as u8).collect(),
|
|
width: image.width,
|
|
height: image.height,
|
|
transform: image.transform,
|
|
rgb_to_camera: image.rgb_to_camera,
|
|
histogram: image.histogram,
|
|
}
|
|
}
|
|
|
|
pub fn process_16bit(raw_image: RawImage) -> Image<u16> {
|
|
let raw_image = crate::preprocessing::camera_data::calculate_conversion_matrices(raw_image);
|
|
let raw_image = crate::preprocessing::subtract_black::subtract_black(raw_image);
|
|
let raw_image = crate::preprocessing::scale_colors::scale_colors(raw_image);
|
|
let image = crate::demosaicing::linear_demosaicing::linear_demosaic(raw_image);
|
|
let image = crate::postprocessing::convert_to_rgb::convert_to_rgb(image);
|
|
let image = crate::postprocessing::transform::transform(image);
|
|
crate::postprocessing::gamma_correction::gamma_correction(image)
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum DecoderError {
|
|
#[error("An error occurred when trying to parse the TIFF format")]
|
|
TiffError(#[from] TiffError),
|
|
#[error("An error occurred when converting integer from one type to another")]
|
|
ConversionError(#[from] std::num::TryFromIntError),
|
|
#[error("An IO Error ocurred")]
|
|
IoError(#[from] std::io::Error),
|
|
}
|