[Resolved] Error when reading from Nuke: Reader did not set bounding box

[jaimervq]

Hi everyone!

First, thanks for this amazing crate. I am trying to merge 2 exr images into one and getting errors when trying to read the result in Nuke.

I have pinpointed the origin of this problem: when both images have same resolution in all layers, the merge works fine. When one of the images has a smaller layer, with less pixels, the result cannot be read and I get Reader did not set bounding box

I am trying to make sure the "smaller" layers are properly aligned with

 let mut new_layer = extra_layer.clone();
 new_layer.attributes.layer_position =  extra_layer.attributes.layer_position.clone();

What am I missing?
Thanks!

[johannesvollmer]

Hi! Thanks for opening this issue.

The library should not produce images that cannot be opened. We should probably add a check for this such that it would return an error.

Could you perhaps provide a full code example that leads to an error in nuke?

[johannesvollmer]

Perhaps Layer::size might be what you are looking for, but they should be set automatically.

But then there is also Image::display_window which could also be missing. If you merge two images, you should decide how to place the display window: take it from the first file, or take the union of the display window of both files?

[jaimervq]

Thanks johannes, this is a full example:

#![allow(unsafe_op_in_unsafe_fn)]

use exr::prelude::*;
use pyo3::prelude::*;
use std::collections::HashMap;

#[pyfunction]
fn merge_exr_layers(
    base_path: &str,
    extra_path: &str,
    output_path: &str,
    layers_to_copy: Vec<String>,
) -> PyResult<()> {
    // Read the base image
    if !std::path::Path::new(base_path).exists() {
        return Err(pyo3::exceptions::PyFileNotFoundError::new_err(format!(
            "Base image file not found: {}",
            base_path
        )));
    }
    let mut base_image = exr::image::read::read_all_data_from_file(base_path).unwrap();
    println!("Base image layers: {:?}", base_image.layer_data.len());

    // Read the extra image
    if !std::path::Path::new(extra_path).exists() {
        return Err(pyo3::exceptions::PyFileNotFoundError::new_err(format!(
            "Extra image file not found: {}",
            extra_path
        )));
    }
    let extra_image = exr::image::read::read_all_data_from_file(extra_path).unwrap();
    println!("Extra image layers: {:?}", extra_image.layer_data.len());

    // Map of base layer names to indices
    let mut base_layer_map: HashMap<String, usize> = HashMap::new();
    for (i, layer) in base_image.layer_data.iter().enumerate() {
        let name = match &layer.attributes.layer_name {
            Some(text) => text.to_string(),
            _ => "<unnamed>".to_string(),
        };
        base_layer_map.insert(name, i);
    }

    for extra_layer in &extra_image.layer_data {
        if let Some(l_name) = &extra_layer.attributes.layer_name {
            if base_layer_map.contains_key(&l_name.to_string()) {
                continue; // Skip if layer already exists in base
            } else {
                if layers_to_copy
                    .iter()
                    .any(|prefix| l_name.to_string().starts_with(prefix))
                {
                    let mut new_layer = extra_layer.clone();
                    new_layer.channel_data.list.clear(); // Clear channels to avoid duplicates
                    println!(
                        "Cloned layer: name={} size={:?} attributes={:?}",
                        l_name, new_layer.size, new_layer.attributes
                    );
                    for c in &extra_layer.channel_data.list {
                        let new_channel = c.clone();
                        println!("Cloned channel: name={} ", new_channel.name,);
                        new_layer.channel_data.list.push(new_channel);
                    }
                    new_layer.encoding = extra_layer.encoding.clone();
                    new_layer.size = extra_layer.size.clone();
                    new_layer.attributes.layer_position =
                        extra_layer.attributes.layer_position.clone();
                    base_image.layer_data.push(new_layer);
                    let new_index = base_image.layer_data.len() - 1;
                    base_layer_map.insert(l_name.to_string().clone(), new_index);
                    println!(" -> Adding new layer: {} at index {}", l_name, new_index);
                }
            }
        };
    }

    // Write result
    base_image.attributes = extra_image.attributes.clone();
    base_image.write().to_file(output_path).unwrap();
    println!("Merged image written to: {}", output_path);
    Ok(())
}

#[pymodule]
fn exr_merger(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(merge_exr_layers, m)?)?;
    Ok(())
}

Where:
base_path: the exr image to use as base and add layers to
extra_path: the exr image with extra layers
output_path: where to write the result
layers_to_copy: a list of "prefixes" to use when searching the layers we want from extra_path

The described problem arises when the layers copied from extra_path are smaller than the rest in base_path

[jaimervq]

And it is wrapped with pyo3 so we can use this method from python

[johannesvollmer]

What's the reason to clone all attributes of the layer manually? First, you clone the extra_layer completely. But then, you delete the channels, and clone the same channels from the extra_layer individually, and the attributes. What is the reason for this? Were they not cloned correctly by simply calling extra_layer.clone()?

[jaimervq]

Hi @johannesvollmer , thanks for your quick reply.

The whole thing of re-setting and re-cloning the channels and attributes manually was just me trying to make double-sure everything was properly set (as I could not pinpoint the origin of the error), surely the .clone() is enough.

The good news is, I was able to reproduce this same issue by merging exr files with python's wrapper of OpenImageIO. Same error in Nuke. In the end, I saw that Nuke does not like layers with different sizes. By taking the "base file" size and cropping the extra layers to this size (via a oiio .cut) I was able to write an .exr readable by Nuke.

Let me try now with your crate, by using the crop methods available and get back to you. In the meantime we can pause this ticket.

Best
Jaime

[johannesvollmer]

Huh, interesting! Good to know. Thanks for investigating further. Please let me know if the cropping functionality is nice to use in exrs, or if the cropping API could be improved :)

[jaimervq]

Thanks a lot Johannes, will keep in touch! :)