Deleted vendor folder

1 files changed, 0 insertions, 1326 deletions

diff --git a/vendor/exr/src/image/mod.rs b/vendor/exr/src/image/mod.rs
deleted file mode 100644
index db75050..0000000
--- a/vendor/exr/src/image/mod.rs
+++ /dev/null
@@ -1,1326 +0,0 @@
-
-//! Data structures that represent a complete exr image.
-//! Contains generic structs that must be nested to obtain a complete image type.
-//!
-//!
-//! For example, an rgba image containing multiple layers
-//! can be represented using `Image<Layers<SpecificChannels<MyPixelStorage>>>`.
-//! An image containing a single layer with arbitrary channels and no deep data
-//! can be represented using `Image<Layer<AnyChannels<FlatSamples>>>`.
-//!
-//!
-//! These and other predefined types are included in this module as
-//! 1. `PixelImage`: A single layer, fixed set of arbitrary channels.
-//! 1. `PixelLayersImage`: Multiple layers, fixed set of arbitrary channels.
-//! 1. `RgbaImage`: A single layer, fixed set of channels: rgb, optional a.
-//! 1. `RgbaLayersImage`: Multiple layers, fixed set of channels: rgb, optional a.
-//! 1. `FlatImage`: Multiple layers, any channels, no deep data.
-//! 1. `AnyImage`: All supported data (multiple layers, arbitrary channels, no deep data yet)
-//!
-//! You can also use your own types inside an image,
-//! for example if you want to use a custom sample storage.
-//!
-//! This is the high-level interface for the pixels of an image.
-//! See `exr::blocks` module for a low-level interface.
-
-pub mod read;
-pub mod write;
-pub mod crop;
-pub mod pixel_vec;
-pub mod recursive;
-// pub mod channel_groups;
-
-
-use crate::meta::header::{ImageAttributes, LayerAttributes};
-use crate::meta::attribute::{Text, LineOrder};
-use half::f16;
-use crate::math::{Vec2, RoundingMode};
-use crate::compression::Compression;
-use smallvec::{SmallVec};
-use crate::error::Error;
-
-/// Don't do anything
-pub(crate) fn ignore_progress(_progress: f64){}
-
-/// This image type contains all supported exr features and can represent almost any image.
-/// It currently does not support deep data yet.
-pub type AnyImage = Image<Layers<AnyChannels<Levels<FlatSamples>>>>;
-
-/// This image type contains the most common exr features and can represent almost any plain image.
-/// Does not contain resolution levels. Does not support deep data.
-pub type FlatImage = Image<Layers<AnyChannels<FlatSamples>>>;
-
-/// This image type contains multiple layers, with each layer containing a user-defined type of pixels.
-pub type PixelLayersImage<Storage, Channels> = Image<Layers<SpecificChannels<Storage, Channels>>>;
-
-/// This image type contains a single layer containing a user-defined type of pixels.
-pub type PixelImage<Storage, Channels> = Image<Layer<SpecificChannels<Storage, Channels>>>;
-
-/// This image type contains multiple layers, with each layer containing a user-defined type of rgba pixels.
-pub type RgbaLayersImage<Storage> = PixelLayersImage<Storage, RgbaChannels>;
-
-/// This image type contains a single layer containing a user-defined type of rgba pixels.
-pub type RgbaImage<Storage> = PixelImage<Storage, RgbaChannels>;
-
-/// Contains information about the channels in an rgba image, in the order `(red, green, blue, alpha)`.
-/// The alpha channel is not required. May be `None` if the image did not contain an alpha channel.
-pub type RgbaChannels = (ChannelDescription, ChannelDescription, ChannelDescription, Option<ChannelDescription>);
-
-/// Contains information about the channels in an rgb image, in the order `(red, green, blue)`.
-pub type RgbChannels = (ChannelDescription, ChannelDescription, ChannelDescription);
-
-/// The complete exr image.
-/// `Layers` can be either a single `Layer` or `Layers`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Image<Layers> {
-
-    /// Attributes that apply to the whole image file.
-    /// These attributes appear in each layer of the file.
-    /// Excludes technical meta data.
-    /// Each layer in this image also has its own attributes.
-    pub attributes: ImageAttributes,
-
-    /// The layers contained in the image file.
-    /// Can be either a single `Layer` or a list of layers.
-    pub layer_data: Layers,
-}
-
-/// A list of layers. `Channels` can be `SpecificChannels` or `AnyChannels`.
-pub type Layers<Channels> = SmallVec<[Layer<Channels>; 2]>;
-
-/// A single Layer, including fancy attributes and compression settings.
-/// `Channels` can be either `SpecificChannels` or `AnyChannels`
-#[derive(Debug, Clone, PartialEq)]
-pub struct Layer<Channels> {
-
-    /// The actual pixel data. Either `SpecificChannels` or `AnyChannels`
-    pub channel_data: Channels,
-
-    /// Attributes that apply to this layer.
-    /// May still contain attributes that should be considered global for an image file.
-    /// Excludes technical meta data: Does not contain data window size, line order, tiling, or compression attributes.
-    /// The image also has attributes, which do not differ per layer.
-    pub attributes: LayerAttributes,
-
-    /// The pixel resolution of this layer.
-    /// See `layer.attributes` for more attributes, like for example layer position.
-    pub size: Vec2<usize>,
-
-    /// How the pixels are split up and compressed.
-    pub encoding: Encoding
-}
-
-/// How the pixels are split up and compressed.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct Encoding {
-
-    /// How the pixel data of all channels in this layer is compressed. May be `Compression::Uncompressed`.
-    /// See `layer.attributes` for more attributes.
-    pub compression: Compression,
-
-    /// Describes how the pixels of this layer are divided into smaller blocks.
-    /// Either splits the image into its scan lines or splits the image into tiles of the specified size.
-    /// A single block can be loaded without processing all bytes of a file.
-    pub blocks: Blocks,
-
-    /// In what order the tiles of this header occur in the file.
-    /// Does not change any actual image orientation.
-    /// See `layer.attributes` for more attributes.
-    pub line_order: LineOrder,
-}
-
-/// How the image pixels are split up into separate blocks.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum Blocks {
-
-    /// The image is divided into scan line blocks.
-    /// The number of scan lines in a block depends on the compression method.
-    ScanLines,
-
-    /// The image is divided into tile blocks.
-    /// Also specifies the size of each tile in the image
-    /// and whether this image contains multiple resolution levels.
-    ///
-    /// The inner `Vec2` describes the size of each tile.
-    /// Stays the same number of pixels across all levels.
-    Tiles (Vec2<usize>)
-}
-
-
-/// A grid of pixels. The pixels are written to your custom pixel storage.
-/// `PixelStorage` can be anything, from a flat `Vec<f16>` to `Vec<Vec<AnySample>>`, as desired.
-/// In order to write this image to a file, your `PixelStorage` must implement [`GetPixel`].
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SpecificChannels<Pixels, ChannelsDescription> {
-
-    /// A description of the channels in the file, as opposed to the channels in memory.
-    /// Should always be a tuple containing `ChannelDescription`s, one description for each channel.
-    pub channels: ChannelsDescription, // TODO this is awkward. can this be not a type parameter please? maybe vec<option<chan_info>> ??
-
-    /// Your custom pixel storage
-    // TODO should also support `Levels<YourStorage>`, where levels are desired!
-    pub pixels: Pixels, // TODO rename to "pixels"?
-}
-
-
-/// A dynamic list of arbitrary channels.
-/// `Samples` can currently only be `FlatSamples` or `Levels<FlatSamples>`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct AnyChannels<Samples> {
-
-    /// This list must be sorted alphabetically, by channel name.
-    /// Use `AnyChannels::sorted` for automatic sorting.
-    pub list: SmallVec<[AnyChannel<Samples>; 4]>
-}
-
-/// A single arbitrary channel.
-/// `Samples` can currently only be `FlatSamples` or `Levels<FlatSamples>`
-#[derive(Debug, Clone, PartialEq)]
-pub struct AnyChannel<Samples> {
-
-    /// One of "R", "G", or "B" most of the time.
-    pub name: Text,
-
-    /// The actual pixel data.
-    /// Can be `FlatSamples` or `Levels<FlatSamples>`.
-    pub sample_data: Samples,
-
-    /// This attribute only tells lossy compression methods
-    /// whether this value should be quantized exponentially or linearly.
-    ///
-    /// Should be `false` for red, green, blue and luma channels, as they are not perceived linearly.
-    /// Should be `true` for hue, chroma, saturation, and alpha channels.
-    pub quantize_linearly: bool,
-
-    /// How many of the samples are skipped compared to the other channels in this layer.
-    ///
-    /// Can be used for chroma subsampling for manual lossy data compression.
-    /// Values other than 1 are allowed only in flat, scan-line based images.
-    /// If an image is deep or tiled, the sampling rates for all of its channels must be 1.
-    pub sampling: Vec2<usize>,
-}
-
-/// One or multiple resolution levels of the same image.
-/// `Samples` can be `FlatSamples`.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Levels<Samples> {
-
-    /// A single image without smaller versions of itself.
-    /// If you only want to handle exclusively this case, use `Samples` directly, and not `Levels<Samples>`.
-    Singular(Samples),
-
-    /// Contains uniformly scaled smaller versions of the original.
-    Mip
-    {
-        /// Whether to round up or down when calculating Mip/Rip levels.
-        rounding_mode: RoundingMode,
-
-        /// The smaller versions of the original.
-        level_data: LevelMaps<Samples>
-    },
-
-    /// Contains any possible combination of smaller versions of the original.
-    Rip
-    {
-        /// Whether to round up or down when calculating Mip/Rip levels.
-        rounding_mode: RoundingMode,
-
-        /// The smaller versions of the original.
-        level_data: RipMaps<Samples>
-    },
-}
-
-/// A list of resolution levels. `Samples` can currently only be `FlatSamples`.
-// or `DeepAndFlatSamples` (not yet implemented).
-pub type LevelMaps<Samples> = Vec<Samples>;
-
-/// In addition to the full resolution image,
-/// this layer also contains smaller versions,
-/// and each smaller version has further versions with varying aspect ratios.
-/// `Samples` can currently only be `FlatSamples`.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RipMaps<Samples> {
-
-    /// A flattened list containing the individual levels
-    pub map_data: LevelMaps<Samples>,
-
-    /// The number of levels that were generated along the x-axis and y-axis.
-    pub level_count: Vec2<usize>,
-}
-
-
-// TODO deep data
-/*#[derive(Clone, PartialEq)]
-pub enum DeepAndFlatSamples {
-    Deep(DeepSamples),
-    Flat(FlatSamples)
-}*/
-
-/// A vector of non-deep values (one value per pixel per channel).
-/// Stores row after row in a single vector.
-/// The precision of all values is either `f16`, `f32` or `u32`.
-///
-/// Since this is close to the pixel layout in the byte file,
-/// this will most likely be the fastest storage.
-/// Using a different storage, for example `SpecificChannels`,
-/// will probably be slower.
-#[derive(Clone, PartialEq)] // debug is implemented manually
-pub enum FlatSamples {
-
-    /// A vector of non-deep `f16` values.
-    F16(Vec<f16>),
-
-    /// A vector of non-deep `f32` values.
-    F32(Vec<f32>),
-
-    /// A vector of non-deep `u32` values.
-    U32(Vec<u32>),
-}
-
-
-/*#[derive(Clone, PartialEq)]
-pub enum DeepSamples {
-    F16(Vec<Vec<f16>>),
-    F32(Vec<Vec<f32>>),
-    U32(Vec<Vec<u32>>),
-}*/
-
-use crate::block::samples::*;
-use crate::meta::attribute::*;
-use crate::error::Result;
-use crate::block::samples::Sample;
-use crate::image::write::channels::*;
-use crate::image::write::layers::WritableLayers;
-use crate::image::write::samples::{WritableSamples};
-use crate::meta::{mip_map_levels, rip_map_levels};
-use crate::io::Data;
-use crate::image::recursive::{NoneMore, Recursive, IntoRecursive};
-use std::marker::PhantomData;
-use std::ops::Not;
-use crate::image::validate_results::{ValidationOptions};
-
-
-impl<Channels> Layer<Channels> {
-    /// Sometimes called "data window"
-    pub fn absolute_bounds(&self) -> IntegerBounds {
-        IntegerBounds::new(self.attributes.layer_position, self.size)
-    }
-}
-
-
-impl<SampleStorage, Channels> SpecificChannels<SampleStorage, Channels> {
-    /// Create some pixels with channel information.
-    /// The `Channels` must be a tuple containing either `ChannelDescription` or `Option<ChannelDescription>`.
-    /// The length of the tuple dictates the number of channels in the sample storage.
-    pub fn new(channels: Channels, source_samples: SampleStorage) -> Self
-        where
-            SampleStorage: GetPixel,
-            SampleStorage::Pixel: IntoRecursive,
-            Channels: Sync + Clone + IntoRecursive,
-            <Channels as IntoRecursive>::Recursive: WritableChannelsDescription<<SampleStorage::Pixel as IntoRecursive>::Recursive>,
-    {
-        SpecificChannels { channels, pixels: source_samples }
-    }
-}
-
-/// Convert this type into one of the known sample types.
-/// Also specify the preferred native type, which dictates the default sample type in the image.
-pub trait IntoSample: IntoNativeSample {
-
-    /// The native sample types that this type should be converted to.
-    const PREFERRED_SAMPLE_TYPE: SampleType;
-}
-
-impl IntoSample for f16 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::F16; }
-impl IntoSample for f32 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::F32; }
-impl IntoSample for u32 { const PREFERRED_SAMPLE_TYPE: SampleType = SampleType::U32; }
-
-/// Used to construct a `SpecificChannels`.
-/// Call `with_named_channel` as many times as desired,
-/// and then call `with_pixels` to define the colors.
-#[derive(Debug)]
-pub struct SpecificChannelsBuilder<RecursiveChannels, RecursivePixel> {
-    channels: RecursiveChannels,
-    px: PhantomData<RecursivePixel>
-}
-
-/// This check can be executed at compile time
-/// if the channel names are `&'static str` and the compiler is smart enough.
-pub trait CheckDuplicates {
-
-    /// Check for duplicate channel names.
-    fn already_contains(&self, name: &Text) -> bool;
-}
-
-impl CheckDuplicates for NoneMore {
-    fn already_contains(&self, _: &Text) -> bool { false }
-}
-
-impl<Inner: CheckDuplicates> CheckDuplicates for Recursive<Inner, ChannelDescription> {
-    fn already_contains(&self, name: &Text) -> bool {
-        &self.value.name == name || self.inner.already_contains(name)
-    }
-}
-
-impl SpecificChannels<(),()>
-{
-    /// Start building some specific channels. On the result of this function,
-    /// call `with_named_channel` as many times as desired,
-    /// and then call `with_pixels` to define the colors.
-    pub fn build() -> SpecificChannelsBuilder<NoneMore, NoneMore> {
-        SpecificChannelsBuilder { channels: NoneMore, px: Default::default() }
-    }
-}
-
-impl<RecursiveChannels: CheckDuplicates, RecursivePixel> SpecificChannelsBuilder<RecursiveChannels, RecursivePixel>
-{
-    /// Add another channel to this image. Does not add the actual pixels,
-    /// but instead only declares the presence of the channel.
-    /// Panics if the name contains unsupported characters.
-    /// Panics if a channel with the same name already exists.
-    /// Use `Text::new_or_none()` to manually handle these cases.
-    /// Use `with_channel_details` instead if you want to specify more options than just the name of the channel.
-    /// The generic parameter can usually be inferred from the closure in `with_pixels`.
-    pub fn with_channel<Sample: IntoSample>(self, name: impl Into<Text>)
-                                            -> SpecificChannelsBuilder<Recursive<RecursiveChannels, ChannelDescription>, Recursive<RecursivePixel, Sample>>
-    {
-        self.with_channel_details::<Sample>(ChannelDescription::named(name, Sample::PREFERRED_SAMPLE_TYPE))
-    }
-
-    /// Add another channel to this image. Does not add the actual pixels,
-    /// but instead only declares the presence of the channel.
-    /// Use `with_channel` instead if you only want to specify the name of the channel.
-    /// Panics if a channel with the same name already exists.
-    /// The generic parameter can usually be inferred from the closure in `with_pixels`.
-    pub fn with_channel_details<Sample: Into<Sample>>(self, channel: ChannelDescription)
-        -> SpecificChannelsBuilder<Recursive<RecursiveChannels, ChannelDescription>, Recursive<RecursivePixel, Sample>>
-    {
-        // duplicate channel names are checked later, but also check now to make sure there are no problems with the `SpecificChannelsWriter`
-        assert!(self.channels.already_contains(&channel.name).not(), "channel name `{}` is duplicate", channel.name);
-
-        SpecificChannelsBuilder {
-            channels: Recursive::new(self.channels, channel),
-            px: PhantomData::default()
-        }
-    }
-
-    /// Specify the actual pixel contents of the image.
-    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> Pixel`),
-    /// or you can pass your own image if it implements `GetPixel`.
-    /// The pixel type must be a tuple with the correct number of entries, depending on the number of channels.
-    /// The tuple entries can be either `f16`, `f32`, `u32` or `Sample`.
-    /// Use `with_pixel_fn` instead of this function, to get extra type safety for your pixel closure.
-    pub fn with_pixels<Pixels>(self, get_pixel: Pixels) -> SpecificChannels<Pixels, RecursiveChannels>
-        where Pixels: GetPixel, <Pixels as GetPixel>::Pixel: IntoRecursive<Recursive=RecursivePixel>,
-    {
-        SpecificChannels {
-            channels: self.channels,
-            pixels: get_pixel
-        }
-    }
-
-    /// Specify the contents of the image.
-    /// The pixel type must be a tuple with the correct number of entries, depending on the number of channels.
-    /// The tuple entries can be either `f16`, `f32`, `u32` or `Sample`.
-    /// Use `with_pixels` instead of this function, if you want to pass an object that is not a closure.
-    ///
-    /// Usually, the compiler can infer the type of the pixel (for example, `f16,f32,f32`) from the closure.
-    /// If that's not possible, you can specify the type of the channels
-    /// when declaring the channel (for example, `with_named_channel::<f32>("R")`).
-    pub fn with_pixel_fn<Pixel, Pixels>(self, get_pixel: Pixels) -> SpecificChannels<Pixels, RecursiveChannels>
-        where Pixels: Sync + Fn(Vec2<usize>) -> Pixel, Pixel: IntoRecursive<Recursive=RecursivePixel>,
-    {
-        SpecificChannels {
-            channels: self.channels,
-            pixels: get_pixel
-        }
-    }
-}
-
-impl<SampleStorage> SpecificChannels<
-    SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription, ChannelDescription)
->
-{
-
-    /// Create an image with red, green, blue, and alpha channels.
-    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> (R,G,B,A)`),
-    /// or you can pass your own image if it implements `GetPixel<Pixel=(R,G,B,A)>`.
-    /// Each of `R`, `G`, `B` and `A` can be either `f16`, `f32`, `u32`, or `Sample`.
-    pub fn rgba<R, G, B, A>(source_samples: SampleStorage) -> Self
-        where R: IntoSample, G: IntoSample,
-              B: IntoSample, A: IntoSample,
-              SampleStorage: GetPixel<Pixel=(R, G, B, A)>
-    {
-        SpecificChannels {
-            channels: (
-                ChannelDescription::named("R", R::PREFERRED_SAMPLE_TYPE),
-                ChannelDescription::named("G", G::PREFERRED_SAMPLE_TYPE),
-                ChannelDescription::named("B", B::PREFERRED_SAMPLE_TYPE),
-                ChannelDescription::named("A", A::PREFERRED_SAMPLE_TYPE),
-            ),
-            pixels: source_samples
-        }
-    }
-}
-
-impl<SampleStorage> SpecificChannels<
-    SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription)
->
-{
-
-    /// Create an image with red, green, and blue channels.
-    /// You can pass a closure that returns a color for each pixel (`Fn(Vec2<usize>) -> (R,G,B)`),
-    /// or you can pass your own image if it implements `GetPixel<Pixel=(R,G,B)>`.
-    /// Each of `R`, `G` and `B` can be either `f16`, `f32`, `u32`, or `Sample`.
-    pub fn rgb<R, G, B>(source_samples: SampleStorage) -> Self
-        where R: IntoSample, G: IntoSample, B: IntoSample,
-              SampleStorage: GetPixel<Pixel=(R, G, B)>
-    {
-        SpecificChannels {
-            channels: (
-                ChannelDescription::named("R", R::PREFERRED_SAMPLE_TYPE),
-                ChannelDescription::named("G", G::PREFERRED_SAMPLE_TYPE),
-                ChannelDescription::named("B", B::PREFERRED_SAMPLE_TYPE),
-            ),
-            pixels: source_samples
-        }
-    }
-}
-
-
-/// A list of samples representing a single pixel.
-/// Does not heap allocate for images with 8 or fewer channels.
-pub type FlatSamplesPixel = SmallVec<[Sample; 8]>;
-
-// TODO also deep samples?
-impl Layer<AnyChannels<FlatSamples>> {
-
-    /// Use `samples_at` if you can borrow from this layer
-    pub fn sample_vec_at(&self, position: Vec2<usize>) -> FlatSamplesPixel {
-        self.samples_at(position).collect()
-    }
-
-    /// Lookup all channels of a single pixel in the image
-    pub fn samples_at(&self, position: Vec2<usize>) -> FlatSampleIterator<'_> {
-        FlatSampleIterator {
-            layer: self,
-            channel_index: 0,
-            position
-        }
-    }
-}
-
-/// Iterate over all channels of a single pixel in the image
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct FlatSampleIterator<'s> {
-    layer: &'s Layer<AnyChannels<FlatSamples>>,
-    channel_index: usize,
-    position: Vec2<usize>,
-}
-
-impl Iterator for FlatSampleIterator<'_> {
-    type Item = Sample;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.channel_index < self.layer.channel_data.list.len() {
-            let channel = &self.layer.channel_data.list[self.channel_index];
-            let sample = channel.sample_data.value_by_flat_index(self.position.flat_index_for_size(self.layer.size));
-            self.channel_index += 1;
-            Some(sample)
-        }
-        else { None }
-    }
-
-    fn nth(&mut self, pos: usize) -> Option<Self::Item> {
-        self.channel_index += pos;
-        self.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remaining = self.layer.channel_data.list.len().saturating_sub(self.channel_index);
-        (remaining, Some(remaining))
-    }
-}
-
-impl ExactSizeIterator for FlatSampleIterator<'_> {}
-
-impl<SampleData> AnyChannels<SampleData>{
-
-    /// A new list of arbitrary channels. Sorts the list to make it alphabetically stable.
-    pub fn sort(mut list: SmallVec<[AnyChannel<SampleData>; 4]>) -> Self {
-        list.sort_unstable_by_key(|channel| channel.name.clone()); // TODO no clone?
-        Self { list }
-    }
-}
-
-// FIXME check content size of layer somewhere??? before writing?
-impl<LevelSamples> Levels<LevelSamples> {
-
-    /// Get a resolution level by index, sorted by size, decreasing.
-    pub fn get_level(&self, level: Vec2<usize>) -> Result<&LevelSamples> {
-        match self {
-            Levels::Singular(block) => {
-                debug_assert_eq!(level, Vec2(0,0), "singular image cannot write leveled blocks bug");
-                Ok(block)
-            },
-
-            Levels::Mip { level_data, .. } => {
-                debug_assert_eq!(level.x(), level.y(), "mip map levels must be equal on x and y bug");
-                level_data.get(level.x()).ok_or(Error::invalid("block mip level index"))
-            },
-
-            Levels::Rip { level_data, .. } => {
-                level_data.get_by_level(level).ok_or(Error::invalid("block rip level index"))
-            }
-        }
-    }
-
-    /// Get a resolution level by index, sorted by size, decreasing.
-    // TODO storage order for RIP maps?
-    pub fn get_level_mut(&mut self, level: Vec2<usize>) -> Result<&mut LevelSamples> {
-        match self {
-            Levels::Singular(ref mut block) => {
-                debug_assert_eq!(level, Vec2(0,0), "singular image cannot write leveled blocks bug");
-                Ok(block)
-            },
-
-            Levels::Mip { level_data, .. } => {
-                debug_assert_eq!(level.x(), level.y(), "mip map levels must be equal on x and y bug");
-                level_data.get_mut(level.x()).ok_or(Error::invalid("block mip level index"))
-            },
-
-            Levels::Rip { level_data, .. } => {
-                level_data.get_by_level_mut(level).ok_or(Error::invalid("block rip level index"))
-            }
-        }
-    }
-
-    /// Get a slice of all resolution levels, sorted by size, decreasing.
-    pub fn levels_as_slice(&self) -> &[LevelSamples] {
-        match self {
-            Levels::Singular(data) => std::slice::from_ref(data),
-            Levels::Mip { level_data, .. } => level_data,
-            Levels::Rip { level_data, .. } => &level_data.map_data,
-        }
-    }
-
-    /// Get a mutable slice of all resolution levels, sorted by size, decreasing.
-    pub fn levels_as_slice_mut(&mut self) -> &mut [LevelSamples] {
-        match self {
-            Levels::Singular(data) => std::slice::from_mut(data),
-            Levels::Mip { level_data, .. } => level_data,
-            Levels::Rip { level_data, .. } => &mut level_data.map_data,
-        }
-    }
-
-    // TODO simplify working with levels in general! like level_size_by_index and such
-
-    /*pub fn levels_with_size(&self, rounding: RoundingMode, max_resolution: Vec2<usize>) -> Vec<(Vec2<usize>, &S)> {
-        match self {
-            Levels::Singular(ref data) => vec![ (max_resolution, data) ],
-            Levels::Mip(ref maps) => mip_map_levels(rounding, max_resolution).map(|(_index, size)| size).zip(maps).collect(),
-            Levels::Rip(ref rip_maps) => rip_map_levels(rounding, max_resolution).map(|(_index, size)| size).zip(&rip_maps.map_data).collect(),
-        }
-    }*/
-
-    /// Whether this stores multiple resolution levels.
-    pub fn level_mode(&self) -> LevelMode {
-        match self {
-            Levels::Singular(_) => LevelMode::Singular,
-            Levels::Mip { .. } => LevelMode::MipMap,
-            Levels::Rip { .. } => LevelMode::RipMap,
-        }
-    }
-}
-
-impl<Samples> RipMaps<Samples> {
-
-    /// Flatten the 2D level index to a one dimensional index.
-    pub fn get_level_index(&self, level: Vec2<usize>) -> usize {
-        level.flat_index_for_size(self.level_count)
-    }
-
-    /// Return a level by level index. Level `0` has the largest resolution.
-    pub fn get_by_level(&self, level: Vec2<usize>) -> Option<&Samples> {
-        self.map_data.get(self.get_level_index(level))
-    }
-
-    /// Return a mutable level reference by level index. Level `0` has the largest resolution.
-    pub fn get_by_level_mut(&mut self, level: Vec2<usize>) -> Option<&mut Samples> {
-        let index = self.get_level_index(level);
-        self.map_data.get_mut(index)
-    }
-}
-
-impl FlatSamples {
-
-    /// The number of samples in the image. Should be the width times the height.
-    /// Might vary when subsampling is used.
-    pub fn len(&self) -> usize {
-        match self {
-            FlatSamples::F16(vec) => vec.len(),
-            FlatSamples::F32(vec) => vec.len(),
-            FlatSamples::U32(vec) => vec.len(),
-        }
-    }
-
-    /// Views all samples in this storage as f32.
-    /// Matches the underlying sample type again for every sample,
-    /// match yourself if performance is critical! Does not allocate.
-    pub fn values_as_f32<'s>(&'s self) -> impl 's + Iterator<Item = f32> {
-        self.values().map(|sample| sample.to_f32())
-    }
-
-    /// All samples in this storage as iterator.
-    /// Matches the underlying sample type again for every sample,
-    /// match yourself if performance is critical! Does not allocate.
-    pub fn values<'s>(&'s self) -> impl 's + Iterator<Item = Sample> {
-        (0..self.len()).map(move |index| self.value_by_flat_index(index))
-    }
-
-    /// Lookup a single value, by flat index.
-    /// The flat index can be obtained using `Vec2::flatten_for_width`
-    /// which computes the index in a flattened array of pixel rows.
-    pub fn value_by_flat_index(&self, index: usize) -> Sample {
-        match self {
-            FlatSamples::F16(vec) => Sample::F16(vec[index]),
-            FlatSamples::F32(vec) => Sample::F32(vec[index]),
-            FlatSamples::U32(vec) => Sample::U32(vec[index]),
-        }
-    }
-}
-
-
-impl<'s, ChannelData:'s> Layer<ChannelData> {
-
-    /// Create a layer with the specified size, attributes, encoding and channels.
-    /// The channels can be either `SpecificChannels` or `AnyChannels`.
-    pub fn new(
-        dimensions: impl Into<Vec2<usize>>,
-        attributes: LayerAttributes,
-        encoding: Encoding,
-        channels: ChannelData
-    ) -> Self
-        where ChannelData: WritableChannels<'s>
-    {
-        Layer { channel_data: channels, attributes, size: dimensions.into(), encoding }
-    }
-
-    // TODO test pls wtf
-    /// Panics for images with Scanline encoding.
-    pub fn levels_with_resolution<'l, L>(&self, levels: &'l Levels<L>) -> Box<dyn 'l + Iterator<Item=(&'l L, Vec2<usize>)>> {
-        match levels {
-            Levels::Singular(level) => Box::new(std::iter::once((level, self.size))),
-
-            Levels::Mip { rounding_mode, level_data } => Box::new(level_data.iter().zip(
-                mip_map_levels(*rounding_mode, self.size)
-                    .map(|(_index, size)| size)
-            )),
-
-            Levels::Rip { rounding_mode, level_data } => Box::new(level_data.map_data.iter().zip(
-                rip_map_levels(*rounding_mode, self.size)
-                    .map(|(_index, size)| size)
-            )),
-        }
-    }
-}
-
-impl Encoding {
-
-    /// No compression. Massive space requirements.
-    /// Fast, because it minimizes data shuffling and reallocation.
-    pub const UNCOMPRESSED: Encoding = Encoding {
-        compression: Compression::Uncompressed,
-        blocks: Blocks::ScanLines, // longest lines, faster memcpy
-        line_order: LineOrder::Increasing // presumably fastest?
-    };
-
-    /// Run-length encoding with tiles of 64x64 pixels. This is the recommended default encoding.
-    /// Almost as fast as uncompressed data, but optimizes single-colored areas such as mattes and masks.
-    pub const FAST_LOSSLESS: Encoding = Encoding {
-        compression: Compression::RLE,
-        blocks: Blocks::Tiles(Vec2(64, 64)), // optimize for RLE compression
-        line_order: LineOrder::Unspecified
-    };
-
-    /// ZIP compression with blocks of 16 lines. Slow, but produces small files without visible artefacts.
-    pub const SMALL_LOSSLESS: Encoding = Encoding {
-        compression: Compression::ZIP16,
-        blocks: Blocks::ScanLines, // largest possible, but also with high probability of parallel workers
-        line_order: LineOrder::Increasing
-    };
-
-    /// PIZ compression with tiles of 256x256 pixels. Small images, not too slow.
-    pub const SMALL_FAST_LOSSLESS: Encoding = Encoding {
-        compression: Compression::PIZ,
-        blocks: Blocks::Tiles(Vec2(256, 256)),
-        line_order: LineOrder::Unspecified
-    };
-}
-
-impl Default for Encoding {
-    fn default() -> Self { Encoding::FAST_LOSSLESS }
-}
-
-impl<'s, LayerData: 's> Image<LayerData> where LayerData: WritableLayers<'s> {
-    /// Create an image with one or multiple layers. The layer can be a `Layer`, or `Layers` small vector, or `Vec<Layer>` or `&[Layer]`.
-    pub fn new(image_attributes: ImageAttributes, layer_data: LayerData) -> Self {
-        Image { attributes: image_attributes, layer_data }
-    }
-}
-
-// explorable constructor alias
-impl<'s, Channels: 's> Image<Layers<Channels>> where Channels: WritableChannels<'s> {
-    /// Create an image with multiple layers. The layer can be a `Vec<Layer>` or `Layers` (a small vector).
-    pub fn from_layers(image_attributes: ImageAttributes, layer_data: impl Into<Layers<Channels>>) -> Self {
-        Self::new(image_attributes, layer_data.into())
-    }
-}
-
-
-impl<'s, ChannelData:'s> Image<Layer<ChannelData>> where ChannelData: WritableChannels<'s> {
-
-    /// Uses the display position and size to the channel position and size of the layer.
-    pub fn from_layer(layer: Layer<ChannelData>) -> Self {
-        let bounds = IntegerBounds::new(layer.attributes.layer_position, layer.size);
-        Self::new(ImageAttributes::new(bounds), layer)
-    }
-
-    /// Uses empty attributes.
-    pub fn from_encoded_channels(size: impl Into<Vec2<usize>>, encoding: Encoding, channels: ChannelData) -> Self {
-        // layer name is not required for single-layer images
-        Self::from_layer(Layer::new(size, LayerAttributes::default(), encoding, channels))
-    }
-
-    /// Uses empty attributes and fast compression.
-    pub fn from_channels(size: impl Into<Vec2<usize>>, channels: ChannelData) -> Self {
-        Self::from_encoded_channels(size, Encoding::default(), channels)
-    }
-}
-
-
-impl Image<NoneMore> {
-
-    /// Create an empty image, to be filled with layers later on. Add at least one layer to obtain a valid image.
-    /// Call `with_layer(another_layer)` for each layer you want to add to this image.
-    pub fn empty(attributes: ImageAttributes) -> Self { Self { attributes, layer_data: NoneMore } }
-}
-
-impl<'s, InnerLayers: 's> Image<InnerLayers> where
-    InnerLayers: WritableLayers<'s>,
-{
-    /// Add another layer to this image. The layer type does
-    /// not have to equal the existing layers in this image.
-    pub fn with_layer<NewChannels>(self, layer: Layer<NewChannels>)
-        -> Image<Recursive<InnerLayers, Layer<NewChannels>>>
-        where NewChannels: 's + WritableChannels<'s>
-    {
-        Image {
-            attributes: self.attributes,
-            layer_data: Recursive::new(self.layer_data, layer)
-        }
-    }
-}
-
-
-impl<'s, SampleData: 's> AnyChannel<SampleData> {
-
-    /// Create a new channel without subsampling.
-    ///
-    /// Automatically flags this channel for specialized compression
-    /// if the name is "R", "G", "B", "Y", or "L",
-    /// as they typically encode values that are perceived non-linearly.
-    /// Construct the value yourself using `AnyChannel { .. }`, if you want to control this flag.
-    pub fn new(name: impl Into<Text>, sample_data: SampleData) -> Self where SampleData: WritableSamples<'s> {
-        let name: Text = name.into();
-
-        AnyChannel {
-            quantize_linearly: ChannelDescription::guess_quantization_linearity(&name),
-            name, sample_data,
-            sampling: Vec2(1, 1),
-        }
-    }
-
-    /*/// This is the same as `AnyChannel::new()`, but additionally ensures that the closure type is correct.
-    pub fn from_closure<V>(name: Text, sample_data: S) -> Self
-        where S: Sync + Fn(Vec2<usize>) -> V, V: InferSampleType + Data
-    {
-        Self::new(name, sample_data)
-    }*/
-}
-
-impl std::fmt::Debug for FlatSamples {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.len() <= 6 {
-            match self {
-                FlatSamples::F16(vec) => vec.fmt(formatter),
-                FlatSamples::F32(vec) => vec.fmt(formatter),
-                FlatSamples::U32(vec) => vec.fmt(formatter),
-            }
-        }
-        else {
-            match self {
-                FlatSamples::F16(vec) => write!(formatter, "[f16; {}]", vec.len()),
-                FlatSamples::F32(vec) => write!(formatter, "[f32; {}]", vec.len()),
-                FlatSamples::U32(vec) => write!(formatter, "[u32; {}]", vec.len()),
-            }
-        }
-    }
-}
-
-
-
-/// Compare the result of a round trip test with the original method.
-/// Supports lossy compression methods.
-// #[cfg(test)] TODO do not ship this code
-pub mod validate_results {
-    use crate::prelude::*;
-    use smallvec::Array;
-    use crate::prelude::recursive::*;
-    use crate::image::write::samples::WritableSamples;
-    use std::ops::Not;
-    use crate::block::samples::IntoNativeSample;
-
-
-    /// Compare two objects, but with a few special quirks.
-    /// Intended mainly for unit testing.
-    pub trait ValidateResult {
-
-        /// Compare self with the other. Panics if not equal.
-        ///
-        /// Exceptional behaviour:
-        /// This does not work the other way around! This method is not symmetrical!
-        /// Returns whether the result is correct for this image.
-        /// For lossy compression methods, uses approximate equality.
-        /// Intended for unit testing.
-        ///
-        /// Warning: If you use `SpecificChannels`, the comparison might be inaccurate
-        /// for images with mixed compression methods. This is to be used with `AnyChannels` mainly.
-        fn assert_equals_result(&self, result: &Self) {
-            self.validate_result(result, ValidationOptions::default(), || String::new()).unwrap();
-        }
-
-        /// Compare self with the other.
-        /// Exceptional behaviour:
-        /// - Any two NaN values are considered equal, regardless of bit representation.
-        /// - If a `lossy` is specified, any two values that differ only by a small amount will be considered equal.
-        /// - If `nan_to_zero` is true, and __self is NaN/Infinite and the other value is zero, they are considered equal__
-        ///   (because some compression methods replace nan with zero)
-        ///
-        /// This does not work the other way around! This method is not symmetrical!
-        fn validate_result(
-            &self, lossy_result: &Self,
-            options: ValidationOptions,
-            // this is a lazy string, because constructing a string is only necessary in the case of an error,
-            // but eats up memory and allocation time every time. this was measured.
-            context: impl Fn() -> String
-        ) -> ValidationResult;
-    }
-
-    /// Whether to do accurate or approximate comparison.
-    #[derive(Default, Debug, Eq, PartialEq, Hash, Copy, Clone)]
-    pub struct ValidationOptions {
-        allow_lossy: bool,
-        nan_converted_to_zero: bool,
-    }
-
-    /// If invalid, contains the error message.
-    pub type ValidationResult = std::result::Result<(), String>;
-
-
-    impl<C> ValidateResult for Image<C> where C: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self.attributes != other.attributes { Err(location() + "| image > attributes") }
-            else { self.layer_data.validate_result(&other.layer_data, options, || location() + "| image > layer data") }
-        }
-    }
-
-    impl<S> ValidateResult for Layer<AnyChannels<S>>
-        where AnyChannel<S>: ValidateResult, S: for<'a> WritableSamples<'a>
-    {
-        fn validate_result(&self, other: &Self, _overridden: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            let location = || format!("{} (layer `{:?}`)", location(), self.attributes.layer_name);
-            if self.attributes != other.attributes { Err(location() + " > attributes") }
-            else if self.encoding != other.encoding { Err(location() + " > encoding") }
-            else if self.size != other.size { Err(location() + " > size") }
-            else if self.channel_data.list.len() != other.channel_data.list.len() { Err(location() + " > channel count") }
-            else {
-                for (own_chan, other_chan) in self.channel_data.list.iter().zip(other.channel_data.list.iter()) {
-                    own_chan.validate_result(
-                        other_chan,
-
-                        ValidationOptions {
-                            // no tolerance for lossless channels
-                            allow_lossy: other.encoding.compression
-                                .is_lossless_for(other_chan.sample_data.sample_type()).not(),
-
-                            // consider nan and zero equal if the compression method does not support nan
-                            nan_converted_to_zero: other.encoding.compression.supports_nan().not()
-                        },
-
-                        || format!("{} > channel `{}`", location(), own_chan.name)
-                    )?;
-                }
-                Ok(())
-            }
-        }
-    }
-
-    impl<Px, Desc> ValidateResult for Layer<SpecificChannels<Px, Desc>>
-        where SpecificChannels<Px, Desc>: ValidateResult
-    {
-        /// This does an approximate comparison for all channels,
-        /// even if some channels can be compressed without loss.
-        fn validate_result(&self, other: &Self, _overridden: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            let location = || format!("{} (layer `{:?}`)", location(), self.attributes.layer_name);
-
-            // TODO dedup with above
-            if self.attributes != other.attributes { Err(location() + " > attributes") }
-            else if self.encoding != other.encoding { Err(location() + " > encoding") }
-            else if self.size != other.size { Err(location() + " > size") }
-            else {
-                let options = ValidationOptions {
-                    // no tolerance for lossless channels
-                    // pxr only looses data for f32 values, B44 only for f16, not other any other types
-                    allow_lossy: other.encoding.compression.may_loose_data(),// TODO check specific channels sample types
-
-                    // consider nan and zero equal if the compression method does not support nan
-                    nan_converted_to_zero: other.encoding.compression.supports_nan().not()
-                };
-
-                self.channel_data.validate_result(&other.channel_data, options, || location() + " > channel_data")?;
-                Ok(())
-            }
-        }
-    }
-
-    impl<S> ValidateResult for AnyChannels<S> where S: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.list.validate_result(&other.list, options, location)
-        }
-    }
-
-    impl<S> ValidateResult for AnyChannel<S> where S: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self.name != other.name { Err(location() + " > name") }
-            else if self.quantize_linearly != other.quantize_linearly { Err(location() + " > quantize_linearly") }
-            else if self.sampling != other.sampling { Err(location() + " > sampling") }
-            else {
-                self.sample_data.validate_result(&other.sample_data, options, || location() + " > sample_data")
-            }
-        }
-    }
-
-    impl<Pxs, Chans> ValidateResult for SpecificChannels<Pxs, Chans> where Pxs: ValidateResult, Chans: Eq {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self.channels != other.channels { Err(location() + " > specific channels") }
-            else { self.pixels.validate_result(&other.pixels, options, || location() + " > specific pixels") }
-        }
-    }
-
-    impl<S> ValidateResult for Levels<S> where S: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.levels_as_slice().validate_result(&other.levels_as_slice(), options, || location() + " > levels")
-        }
-    }
-
-    impl ValidateResult for FlatSamples {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            use FlatSamples::*;
-            match (self, other) {
-                (F16(values), F16(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > f16 samples"),
-                (F32(values), F32(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > f32 samples"),
-                (U32(values), U32(other_values)) => values.as_slice().validate_result(&other_values.as_slice(), options, ||location() + " > u32 samples"),
-                (own, other) => Err(format!("{}: samples type mismatch. expected {:?}, found {:?}", location(), own.sample_type(), other.sample_type()))
-            }
-        }
-    }
-
-    impl<T> ValidateResult for &[T] where T: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self.len() != other.len() { Err(location() + " count") }
-            else {
-                for (index, (slf, other)) in self.iter().zip(other.iter()).enumerate() {
-                    slf.validate_result(other, options, ||format!("{} element [{}] of {}", location(), index, self.len()))?;
-                }
-                Ok(())
-            }
-        }
-    }
-
-    impl<A: Array> ValidateResult for SmallVec<A> where A::Item: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.as_slice().validate_result(&other.as_slice(), options, location)
-        }
-    }
-
-    impl<A> ValidateResult for Vec<A> where A: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.as_slice().validate_result(&other.as_slice(), options, location)
-        }
-    }
-
-    impl<A,B,C,D> ValidateResult for (A, B, C, D) where A: Clone+ ValidateResult, B: Clone+ ValidateResult, C: Clone+ ValidateResult, D: Clone+ ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.clone().into_recursive().validate_result(&other.clone().into_recursive(), options, location)
-        }
-    }
-
-    impl<A,B,C> ValidateResult for (A, B, C) where A: Clone+ ValidateResult, B: Clone+ ValidateResult, C: Clone+ ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.clone().into_recursive().validate_result(&other.clone().into_recursive(), options, location)
-        }
-    }
-
-    // // (low priority because it is only used in the tests)
-    /*TODO
-    impl<Tuple> SimilarToLossy for Tuple where
-        Tuple: Clone + IntoRecursive,
-        <Tuple as IntoRecursive>::Recursive: SimilarToLossy,
-    {
-        fn similar_to_lossy(&self, other: &Self, max_difference: f32) -> bool {
-            self.clone().into_recursive().similar_to_lossy(&other.clone().into_recursive(), max_difference)
-        } // TODO no clone?
-    }*/
-
-
-    // implement for recursive types
-    impl ValidateResult for NoneMore {
-        fn validate_result(&self, _: &Self, _: ValidationOptions, _: impl Fn()->String) -> ValidationResult { Ok(()) }
-    }
-
-    impl<Inner, T> ValidateResult for Recursive<Inner, T> where Inner: ValidateResult, T: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            self.value.validate_result(&other.value, options, &location).and_then(|()|
-                self.inner.validate_result(&other.inner, options, &location)
-            )
-        }
-    }
-
-    impl<S> ValidateResult for Option<S> where S: ValidateResult {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            match (self, other) {
-                (None, None) => Ok(()),
-                (Some(value), Some(other)) => value.validate_result(other, options, location),
-                _ => Err(location() + ": option mismatch")
-            }
-        }
-    }
-
-    impl ValidateResult for f32 {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self == other || (self.is_nan() && other.is_nan()) || (options.nan_converted_to_zero && !self.is_normal() && *other == 0.0) {
-                return Ok(());
-            }
-
-            if options.allow_lossy {
-                let epsilon = 0.06;
-                let max_difference = 0.1;
-
-                let adaptive_threshold = epsilon * (self.abs() + other.abs());
-                let tolerance = adaptive_threshold.max(max_difference);
-                let difference = (self - other).abs();
-
-                return if difference <= tolerance { Ok(()) }
-                else { Err(format!("{}: expected ~{}, found {} (adaptive tolerance {})", location(), self, other, tolerance)) };
-            }
-
-            Err(format!("{}: expected exactly {}, found {}", location(), self, other))
-        }
-    }
-
-    impl ValidateResult for f16 {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self.to_bits() == other.to_bits() { Ok(()) } else {
-                self.to_f32().validate_result(&other.to_f32(), options, location)
-            }
-        }
-    }
-
-    impl ValidateResult for u32 {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            if self == other { Ok(()) } else { // todo to float conversion resulting in nan/infinity?
-                self.to_f32().validate_result(&other.to_f32(), options, location)
-            }
-        }
-    }
-
-    impl ValidateResult for Sample {
-        fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn()->String) -> ValidationResult {
-            use Sample::*;
-            match (self, other) {
-                (F16(a), F16(b)) => a.validate_result(b, options, ||location() + " (f16)"),
-                (F32(a), F32(b)) => a.validate_result(b, options, ||location() + " (f32)"),
-                (U32(a), U32(b)) => a.validate_result(b, options, ||location() + " (u32)"),
-                (_,_) => Err(location() + ": sample type mismatch")
-            }
-        }
-    }
-
-
-    #[cfg(test)]
-    mod test_value_result {
-        use std::f32::consts::*;
-        use std::io::Cursor;
-        use crate::image::pixel_vec::PixelVec;
-        use crate::image::validate_results::{ValidateResult, ValidationOptions};
-        use crate::meta::attribute::LineOrder::Increasing;
-        use crate::image::{FlatSamples};
-
-        fn expect_valid<T>(original: &T, result: &T, allow_lossy: bool, nan_converted_to_zero: bool) where T: ValidateResult {
-            original.validate_result(
-                result,
-                ValidationOptions { allow_lossy, nan_converted_to_zero },
-                || String::new()
-            ).unwrap();
-        }
-
-        fn expect_invalid<T>(original: &T, result: &T, allow_lossy: bool, nan_converted_to_zero: bool) where T: ValidateResult {
-            assert!(original.validate_result(
-                result,
-                ValidationOptions { allow_lossy, nan_converted_to_zero },
-                || String::new()
-            ).is_err());
-        }
-
-        #[test]
-        fn test_f32(){
-            let original:&[f32] = &[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, -20.4, f32::NAN];
-            let lossy:&[f32] = &[0.0, 0.2, 0.2, 0.3, 0.4, 0.5, -20.5, f32::NAN];
-
-            expect_valid(&original, &original, true, true);
-            expect_valid(&original, &original, true, false);
-            expect_valid(&original, &original, false, true);
-            expect_valid(&original, &original, false, false);
-
-            expect_invalid(&original, &lossy, false, false);
-            expect_valid(&original, &lossy, true, false);
-
-            expect_invalid(&original, &&original[..original.len()-2], true, true);
-
-            // test relative comparison with some large values
-            expect_valid(&1_000_f32, &1_001_f32, true, false);
-            expect_invalid(&1_000_f32, &1_200_f32, true, false);
-
-            expect_valid(&10_000_f32, &10_100_f32, true, false);
-            expect_invalid(&10_000_f32, &12_000_f32, true, false);
-
-            expect_valid(&33_120_f32, &30_120_f32, true, false);
-            expect_invalid(&33_120_f32, &20_120_f32, true, false);
-        }
-
-        #[test]
-        fn test_nan(){
-            let original:&[f32] = &[ 0.0, f32::NAN, f32::NAN ];
-            let lossy:&[f32] = &[ 0.0, f32::NAN, 0.0 ];
-
-            expect_valid(&original, &lossy, true, true);
-            expect_invalid(&lossy, &original, true, true);
-
-            expect_valid(&lossy, &lossy, true, true);
-            expect_valid(&lossy, &lossy, false, true);
-        }
-
-        #[test]
-        fn test_error(){
-
-            fn print_error<T: ValidateResult>(original: &T, lossy: &T, allow_lossy: bool){
-                let message = original
-                    .validate_result(
-                        &lossy,
-                        ValidationOptions { allow_lossy, .. Default::default() },
-                        || String::new() // type_name::<T>().to_string()
-                    )
-                    .unwrap_err();
-
-                println!("message: {}", message);
-            }
-
-            let original:&[f32] = &[ 0.0, f32::NAN, f32::NAN ];
-            let lossy:&[f32] = &[ 0.0, f32::NAN, 0.0 ];
-            print_error(&original, &lossy, false);
-
-            print_error(&2.0, &1.0, true);
-            print_error(&2.0, &1.0, false);
-
-            print_error(&FlatSamples::F32(vec![0.1,0.1]), &FlatSamples::F32(vec![0.1,0.2]), false);
-            print_error(&FlatSamples::U32(vec![0,0]), &FlatSamples::F32(vec![0.1,0.2]), false);
-
-            {
-                let image = crate::prelude::read_all_data_from_file("tests/images/valid/openexr/MultiResolution/Kapaa.exr").unwrap();
-
-                let mut mutated = image.clone();
-                let samples = mutated.layer_data.first_mut().unwrap()
-                    .channel_data.list.first_mut().unwrap().sample_data.levels_as_slice_mut().first_mut().unwrap();
-
-                match samples {
-                    FlatSamples::F16(vals) => vals[100] = vals[1],
-                    FlatSamples::F32(vals) => vals[100] = vals[1],
-                    FlatSamples::U32(vals) => vals[100] = vals[1],
-                }
-
-                print_error(&image, &mutated, false);
-            }
-
-            // TODO check out more nested behaviour!
-        }
-
-        #[test]
-        fn test_uncompressed(){
-            use crate::prelude::*;
-
-            let original_pixels: [(f32,f32,f32); 4] = [
-                (0.0, -1.1, PI),
-                (0.0, -1.1, TAU),
-                (0.0, -1.1, f32::EPSILON),
-                (f32::NAN, 10000.1, -1024.009),
-            ];
-
-            let mut file_bytes = Vec::new();
-            let original_image = Image::from_encoded_channels(
-                (2,2),
-                Encoding {
-                    compression: Compression::Uncompressed,
-                    line_order: Increasing, // FIXME unspecified may be optimized to increasing, which destroys test eq
-                    .. Encoding::default()
-                },
-                SpecificChannels::rgb(PixelVec::new(Vec2(2,2), original_pixels.to_vec()))
-            );
-
-            original_image.write().to_buffered(Cursor::new(&mut file_bytes)).unwrap();
-
-            let lossy_image = read().no_deep_data().largest_resolution_level()
-                .rgb_channels(PixelVec::<(f32,f32,f32)>::constructor, PixelVec::set_pixel)
-                .first_valid_layer().all_attributes().from_buffered(Cursor::new(&file_bytes)).unwrap();
-
-            original_image.assert_equals_result(&original_image);
-            lossy_image.assert_equals_result(&lossy_image);
-            original_image.assert_equals_result(&lossy_image);
-            lossy_image.assert_equals_result(&original_image);
-        }
-
-        #[test]
-        fn test_compiles(){
-            use crate::prelude::*;
-
-            fn accepts_validatable_value(_: &impl ValidateResult){}
-
-            let object: Levels<FlatSamples> = Levels::Singular(FlatSamples::F32(Vec::default()));
-            accepts_validatable_value(&object);
-
-            let object: AnyChannels<Levels<FlatSamples>> = AnyChannels::sort(SmallVec::default());
-            accepts_validatable_value(&object);
-
-            let layer: Layer<AnyChannels<Levels<FlatSamples>>> = Layer::new((0,0), Default::default(), Default::default(), object);
-            accepts_validatable_value(&layer);
-
-            let layers: Layers<AnyChannels<Levels<FlatSamples>>> = Default::default();
-            accepts_validatable_value(&layers);
-
-            let object: Image<Layer<AnyChannels<Levels<FlatSamples>>>> = Image::from_layer(layer);
-            object.assert_equals_result(&object);
-        }
-    }
-}
-
-