This issue lists several task that attempt to fix

• #1

• #3
• (following list ordered by "highest estimated possibility of root-cause")
• #7
  • #9
• #10
• #8
• #6
• (convenience stuff, but essentially a must have)
• #4
• #11

Note: There is a $500.00USD bounty on this issue

Apparently, there are black stripes in the denoised image:

Currently, the root cause for this is unclear. I opened a question about this on StackOverflow with no success so far.

I document also some of my doings and findings in some Medium posts:

• Bazelizing Open Image Denoise — Part 1: The journey begins
• Bazelizing Open Image Denoise — Part 2: More details about the bazelization
• Bazelizing Open Image Denoise — Part 3: A failing unit test

How to reproduce

git clone https://github.com/Vertexwahn/rules_oidn.git
cd rules_oidn
cd tests

Run example with Ubuntu 22.04:

bazel run --config=gcc11 //:example

Run example with Visual Studio 2022:

bazel run --config=vs2022 //:example

The example takes a noisy image and denoises it.

...
int main() {
    cout << "Simple denoising example" << endl;

    Image3f color = load_image_openexr("data/cornel_box.naive_diffuse.box_filter.spp128.embree.exr");
    ...
    Image3f out{color.width(), color.height()};

    ...

    float* colorPtr = color.data();
    ...
    float* outputPtr = out.data();
    int width = out.width();
    int height = out.height();

    oidn::DeviceRef device = oidn::newDevice();
    device.set("verbose", 1);
    device.commit();

    // Create a filter for denoising a beauty (color) image using optional auxiliary images too
    oidn::FilterRef filter = device.newFilter("RT"); // generic ray tracing filter
    filter.setImage("color",  colorPtr,  oidn::Format::Float3, width, height); // beauty
    ...
    filter.setImage("output", outputPtr, oidn::Format::Float3, width, height); // denoised beauty
    filter.set("hdr", true); // beauty image is HDR
    filter.commit();

    // Filter the image
    filter.execute();

    // Check for errors
    const char* errorMessage;
    if (device.getError(errorMessage) != oidn::Error::None) {
        std::cout << "Error: " << errorMessage << std::endl;
    }

    store_open_exr("denoised.exr", out);

    return 0;
}

Unfortunately, the denoised image contains black stripes.

I tested the same input with https://github.com/DeclanRussell/IntelOIDenoiser and got the expected result (without black stripes). Therefore, the problem must be within my bazalization of OIDN or my supporting around it.

If I choose a constant color image, e.g.

// for debug reasons the color image can be initialized with a const color
if(true) { 
    for (int x = 0; x < color.width(); ++x) {
        for (int y = 0; y < color.height(); ++y) {
            color.set_pixel(x,y,.5f, .5f, .5f);
        }
    }
}

I also get black stripes.

I also created a branch of oidn that contains a "direct"
bazelization of oidn which is almost similar to rules_oidn: https://github.com/Vertexwahn/oidn/tree/add-bazel-support. In this branch I bazelized oidnTest which contains a few test cases which all pass with success. I bazelized also oidnDenoiser. You can run it via:

# the_cornell_box.pfm is in data folder in the oidn repo
bazel run --config=gcc11 //:oidnDenoise -- --hdr /home/vertexwahn/Desktop/the_cornell_box.pfm -o /home/vertexwahn/Desktop/denoised.pfm

The generated file denoised.pfm shows the same black stripes. It seems that the black stripes are always 5 pixel wide followed by 3 correct looking color stripes.

Not sure if there are any problems with handing over memory to ISPC, or doing the Filter Operation, etc. Since I tested different image formats (OpenEXR, PFM), I assume that the error is not within my way of storing images.

Expected fix

The expected fix should identify the root cause (maybe ispc_rules, some memory layout somewhere, etc.) and provide PRs to fix it. The denoised image should look identical to the CMake build. Could be that the fix will be less than 10 lines in code - maybe single line change. In the end rules_oidn should work out of the box on Windows and Ubuntut 22.04 (as it does currently - but without the black stripes) - macOS is not expected to work since this requires a different version of oneDNN which is out of the scope of this issue.

• The solution should be a pure Bazel solution without the use of CMake. The use of rules_foreign_cc should be avoided.
• It is expected that oneDNN is used

The release workflow is failing:

Not sure why...

Just to be sure: use the toolchain that the oidn project recommends:

• clang

macOS build does currently not work since oneDNN build must be modified here a bit...

• remove bug description
• consider removal of https://github.com/Vertexwahn/rules_oidn#other-projects-related-to-this

Most Important

• State clearly that the current status of the rules_oidn does not produce a result compatible to the cmake build
• mention the main differences of the build

(priority: low)

Status

--input=${HOME}/rules_oidn/tests/data/cornell_box.naive_diffuse.box_filter.spp64.embree.exr --output=${HOME}/denoised_spp64.exr

Expected / Standard

--input=./data/cornell_box.naive_diffuse.box_filter.spp64.embree.exr --output=denoised_spp64.exr

The weights need to be of the exact same version, extracted by the exact same way.

It seems that this is currently not the case.

Workaround

If applicable, use a copy the extracted weights files and fetch them from the bazel build.

• https://github.com/abebeos/weights

Error-source:

• oidn uses "mkl-dnn FORK(!!!) 2.2.4"
  • oidn uses a customized version of mkl-dnn
• bazel build uses "oneDNN-2.7.1"

Confirmed

• version 2.7.1 does not compile within original oidn source-code

Tasks

• Use mkl-dnn branch oidn f53274c9fef211396655fc4340cb838452334089
  • https://github.com/OpenImageDenoise/mkl-dnn/commits/oidn
• Attempt to update the existent bazel template to build an earlier version
  • https://github.com/tensorflow/tensorflow/blob/9159209df2b25da5393e457a7c57f9882e60ab69/third_party/mkl_dnn/mkldnn_v1.BUILD
• rewrite bazel build template for mkldnn for 2.2.4
• ... (workout an alternative solution)

Add support for Bzlmod

(this is in context of the bounty https://app.bountysource.com/issues/117458567-black-stripes-in-denoised-image)

Article

https://medium.com/@Vertexwahn/bazelizing-open-image-denoise-part-1-the-journey-begins-a16c78ea1b88

Requirement "Bazel"

Open Image Denoise: From CMake to Bazel
The build system of Open Image Denoise is CMake. Instead of CMake I want to use Open Image Denoise using Bazel. This requires to bazelize Open Image Denoise first.

• Is this a hard requirement (e.g. "absolutely non-disputable requirement) ?
• what are the main 3 reasons to use bazel / to not use Cmake?

Feasibility

• The effort to use a non-supported (by the core team) build-system for a C++ application can be excessive
  • Achieving the initial port can become a full-time problem
  • Maintenance (update to new versions) can become non-feasible

Whys is mkl_dnn submodule-directory not used directly?

Instead , this patch is applied.

https://github.com/Vertexwahn/rules_oidn/blob/main/0001-Bazel-support.patch

(the source-tree/behaviour should be as close as possible to the original repo)

At least initially, until #1 is fixed, drop the build-in ispc (ispc_cc_library) and rely on an externally install ispc (as documented within

https://github.com/OpenImageDenoise/oidn#prerequisites

The reproducer mentioned within #1 runs fine, but is looks that it does not produce any files:

PS P:\bounty\oidn\tests> bazel run --config=vs2022 //:example
[...]
Simple denoising example

Intel(R) Open Image Denoise 1.4.3@
  Compiler: Visual C++ Compiler 19.33.3163.0
  Build   : Debug
  Platform: Windows (64-bit)
  Tasking : TBB2021.9 TBB_header_interface_12090 TBB_lib_interface_12090
  Threads : 8 (affinitized)
  ISA     : AVX2
  Neural  : DNNL (oneDNN) 2.7.1

Filter: RT

It should produce "denoised.exr", but it does not.

No other file is produced.

Workaround

as a quick workaround I used ub 22.04, the file is produced there, though not at the location expected.

EDIT: same on windows

Task

(this is essentially a bug, should be fixed. At minimum, document the location)

(this would be more an issue for the https://github.com/Vertexwahn/oidn repo)

The current rules_oidn builds an oidn in a different manner than the original cmake build (versions, call style).

The bazel build of oidn should be as close to the original cmake build as possible.

Rationales

• This is standard-procedure
  • Alternative build systems should not introduce changes (versions, link etc.)
• The possibility that this can be merged to https://github.com/OpenImageDenoise/oidn is higher

Execution

The existent build is refined.

This was started in context of

• #5

Some more elaborations within #1 (comment)

Provide a denoising that functions, based on the original oidn cmake build.

This should be as reproducible cli instructions (ideally ubuntu and windows).