use dcmnorm_core::{ops::AttributeOp, value::C};
use snafu::Snafu;
use std::borrow::Cow;
#[derive(Debug, Snafu)]
#[non_exhaustive]
#[snafu(visibility(pub), module)]
pub enum DecodeError {
#[snafu(whatever, display("{}", message))]
Custom {
message: String,
#[snafu(source(from(Box<dyn std::error::Error + Send + Sync + 'static>, Some)))]
source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
},
NotEncapsulated,
FrameRangeOutOfBounds,
#[snafu(display("Missing required attribute `{}`", name))]
MissingAttribute { name: &'static str },
}
#[derive(Debug, Snafu)]
#[non_exhaustive]
#[snafu(visibility(pub), module)]
pub enum EncodeError {
#[snafu(whatever, display("{}", message))]
Custom {
message: String,
#[snafu(source(from(Box<dyn std::error::Error + Send + Sync + 'static>, Some)))]
source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
},
NotNative,
FrameRangeOutOfBounds,
#[snafu(display("Missing required attribute `{}`", name))]
MissingAttribute { name: &'static str },
}
pub type DecodeResult<T, E = DecodeError> = Result<T, E>;
pub type EncodeResult<T, E = EncodeError> = Result<T, E>;
#[derive(Debug)]
pub struct RawPixelData {
pub fragments: C<Vec<u8>>,
pub offset_table: C<u32>,
}
pub trait PixelDataObject {
fn transfer_syntax_uid(&self) -> &str;
fn rows(&self) -> Option<u16>;
fn cols(&self) -> Option<u16>;
fn samples_per_pixel(&self) -> Option<u16>;
fn bits_allocated(&self) -> Option<u16>;
fn bits_stored(&self) -> Option<u16>;
fn photometric_interpretation(&self) -> Option<&str>;
fn number_of_frames(&self) -> Option<u32>;
fn number_of_fragments(&self) -> Option<u32>;
fn fragment(&self, fragment: usize) -> Option<Cow<'_, [u8]>>;
fn offset_table(&self) -> Option<Cow<'_, [u32]>>;
fn raw_pixel_data(&self) -> Option<RawPixelData>;
}
#[derive(Debug, Default, Clone)]
#[non_exhaustive]
pub struct EncodeOptions {
pub quality: Option<u8>,
pub effort: Option<u8>,
}
impl EncodeOptions {
pub fn new() -> Self {
Self::default()
}
}
pub trait PixelDataReader {
fn decode(&self, src: &dyn PixelDataObject, dst: &mut Vec<u8>) -> DecodeResult<()> {
let frames = src.number_of_frames().unwrap_or(1);
for frame in 0..frames {
self.decode_frame(src, frame, dst)?;
}
Ok(())
}
fn decode_frame(
&self,
src: &dyn PixelDataObject,
frame: u32,
dst: &mut Vec<u8>,
) -> DecodeResult<()>;
}
pub trait PixelDataWriter {
fn encode(
&self,
src: &dyn PixelDataObject,
options: EncodeOptions,
dst: &mut Vec<Vec<u8>>,
offset_table: &mut Vec<u32>,
) -> EncodeResult<Vec<AttributeOp>> {
let frames = src.number_of_frames().unwrap_or(1);
let mut out = Vec::new();
let mut frame_offset = 0;
let mut basic_offset = true;
let prev_offset_table_len = offset_table.len();
for frame in 0..frames {
let mut frame_data = Vec::new();
out = self.encode_frame(src, frame, options.clone(), &mut frame_data)?;
if basic_offset {
offset_table.push(frame_offset);
if frame < frames - 1 {
let written_len = frame_data.len() + (frame_data.len() & 1);
let new_frame_offset =
<u32 as std::convert::TryFrom<usize>>::try_from(written_len)
.ok()
.and_then(|delta| delta.checked_add(8))
.and_then(|delta| frame_offset.checked_add(delta));
if let Some(v) = new_frame_offset {
frame_offset = v;
} else {
offset_table.truncate(prev_offset_table_len);
basic_offset = false;
}
}
}
dst.push(frame_data);
}
Ok(out)
}
fn encode_frame(
&self,
src: &dyn PixelDataObject,
frame: u32,
options: EncodeOptions,
dst: &mut Vec<u8>,
) -> EncodeResult<Vec<AttributeOp>>;
}
pub type DynPixelDataReader = Box<dyn PixelDataReader + Send + Sync + 'static>;
pub type DynPixelDataWriter = Box<dyn PixelDataWriter + Send + Sync + 'static>;
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum NeverPixelAdapter {}
impl PixelDataReader for NeverPixelAdapter {
fn decode(&self, _src: &dyn PixelDataObject, _dst: &mut Vec<u8>) -> DecodeResult<()> {
unreachable!()
}
fn decode_frame(
&self,
_src: &dyn PixelDataObject,
_frame: u32,
_dst: &mut Vec<u8>,
) -> DecodeResult<()> {
unreachable!()
}
}
impl PixelDataWriter for NeverPixelAdapter {
fn encode(
&self,
_src: &dyn PixelDataObject,
_options: EncodeOptions,
_dst: &mut Vec<Vec<u8>>,
_offset_table: &mut Vec<u32>,
) -> EncodeResult<Vec<AttributeOp>> {
unreachable!()
}
fn encode_frame(
&self,
_src: &dyn PixelDataObject,
_frame: u32,
_options: EncodeOptions,
_dst: &mut Vec<u8>,
) -> EncodeResult<Vec<AttributeOp>> {
unreachable!()
}
}
impl PixelDataReader for crate::transfer_syntax::NeverAdapter {
fn decode(&self, _src: &dyn PixelDataObject, _dst: &mut Vec<u8>) -> DecodeResult<()> {
unreachable!()
}
fn decode_frame(
&self,
_src: &dyn PixelDataObject,
_frame: u32,
_dst: &mut Vec<u8>,
) -> DecodeResult<()> {
unreachable!()
}
}
impl PixelDataWriter for crate::transfer_syntax::NeverAdapter {
fn encode(
&self,
_src: &dyn PixelDataObject,
_options: EncodeOptions,
_dst: &mut Vec<Vec<u8>>,
_offset_table: &mut Vec<u32>,
) -> EncodeResult<Vec<AttributeOp>> {
unreachable!()
}
fn encode_frame(
&self,
_src: &dyn PixelDataObject,
_frame: u32,
_options: EncodeOptions,
_dst: &mut Vec<u8>,
) -> EncodeResult<Vec<AttributeOp>> {
unreachable!()
}
}
#[cfg(test)]
mod tests {
use super::{EncodeOptions, EncodeResult, PixelDataObject, PixelDataWriter, RawPixelData};
use dcmnorm_core::ops::AttributeOp;
use std::borrow::Cow;
struct Frames(u32);
impl PixelDataObject for Frames {
fn transfer_syntax_uid(&self) -> &str {
"1.2.840.10008.1.2.1"
}
fn rows(&self) -> Option<u16> {
Some(1)
}
fn cols(&self) -> Option<u16> {
Some(1)
}
fn samples_per_pixel(&self) -> Option<u16> {
Some(1)
}
fn bits_allocated(&self) -> Option<u16> {
Some(8)
}
fn bits_stored(&self) -> Option<u16> {
Some(8)
}
fn photometric_interpretation(&self) -> Option<&str> {
Some("MONOCHROME2")
}
fn number_of_frames(&self) -> Option<u32> {
Some(self.0)
}
fn number_of_fragments(&self) -> Option<u32> {
Some(1)
}
fn fragment(&self, _fragment: usize) -> Option<Cow<'_, [u8]>> {
None
}
fn offset_table(&self) -> Option<Cow<'_, [u32]>> {
None
}
fn raw_pixel_data(&self) -> Option<RawPixelData> {
None
}
}
struct FixedLengths(Vec<usize>);
impl PixelDataWriter for FixedLengths {
fn encode_frame(
&self,
_src: &dyn PixelDataObject,
frame: u32,
_options: EncodeOptions,
dst: &mut Vec<u8>,
) -> EncodeResult<Vec<AttributeOp>> {
dst.resize(dst.len() + self.0[frame as usize], 0xAB);
Ok(Vec::new())
}
}
#[test]
fn default_encode_builds_cumulative_basic_offset_table() {
let writer = FixedLengths(vec![6865, 314, 1000, 7]);
let mut fragments = Vec::new();
let mut offset_table = Vec::new();
writer
.encode(
&Frames(4),
EncodeOptions::default(),
&mut fragments,
&mut offset_table,
)
.unwrap();
assert_eq!(
fragments.iter().map(Vec::len).collect::<Vec<_>>(),
vec![6865, 314, 1000, 7]
);
assert_eq!(
offset_table,
vec![
0,
6866 + 8, 6866 + 8 + 314 + 8,
6866 + 8 + 314 + 8 + 1000 + 8, ]
);
}
#[test]
fn default_encode_of_a_single_frame_has_a_single_zero_offset() {
let mut fragments = Vec::new();
let mut offset_table = Vec::new();
FixedLengths(vec![101])
.encode(
&Frames(1),
EncodeOptions::default(),
&mut fragments,
&mut offset_table,
)
.unwrap();
assert_eq!(offset_table, vec![0]);
assert_eq!(fragments.len(), 1);
}
}