gfacciol / bm3d Goto Github PK

nantest.zip
I've found some images (typically mono images with mostly low pixel values and high dynamic range, such as unstretched astronomical images, when processed with BM3D, generate blocks of -nan in the output. Looking at the basic output, the -nan values appear to start off in the first stage of the algorithm usually as single pixels and then presumably get spread to a whole block in the second stage where processing of a block encounters the pixel with -nan value. An example file that creates -nan results is attached: the sigma for this file is 0.000105 (using bgnoise measurement from Siril).

            //! Threshold distances in order to keep similar patches
            for (int dj = -(int) nHW; dj <= (int) nHW; dj++)
            {
                for (int di = 0; di <= (int) nHW; di++)
                    if (sum_table[dj + nHW + di * Ns][k_r] < threshold)
                        table_distance.push_back(make_pair(
                                    sum_table[dj + nHW + di * Ns][k_r]
                                  , k_r + di * width + dj));

                for (int di = - (int) nHW; di < 0; di++)
                    if (sum_table[-dj + nHW + (-di) * Ns][k_r] < threshold)
                        table_distance.push_back(make_pair(
                                    sum_table[-dj + nHW + (-di) * Ns][k_r + di * width + dj]
                                  , k_r + di * width + dj));
            }

This is very suspicious. Since dj takes the same negative and positive values, it means the second if test is a duplicate of the first one, however it doesn't insert the same element. Wrong check ?

I am really liking the pybm3d wrapper. Thanks! Is there any motivation on your side of things to implement a pybm4d for image cubes?

Dear
Is there any error in line 1375?
for (int di = - (int) nHW; di < 0; di++)

**// if (sum_table[-dj + nHW + (-di) * Ns][k_r] < threshold) //should be

if (sum_table[-dj + nHW + (-di) * Ns][k_r + di * width + dj] < threshold)**
table_distance.push_back(make_pair(
sum_table[-dj + nHW + (-di) * Ns][k_r + di * width + dj]
, k_r + di * width + dj));

I work with large 32 bits floating point TIFF. The code works great with 1000x1000 pixels images, while with larger ones (e.g. 5000x5000, 10000x10000) it uses the 99%-100% of the RAM (32GB) making the entire system unresponsive for several hours (16+ hours) and in the end terminating the process uncompleted.
I use other noise reduction algorithms on such images, but it is the first time I've this kind of problem.
Any suggestion or indication? Perhaps some parameter to set or similar? Is the code suitable for images larger than 1000x1000?
Thank you.

In bm3d.cpp, lines 272, 304, 307 and 341 seem to do the following:

• chop the image into pieces with border 2 * nWien
• reassemble the image based on subimages with borders 2 * nHard
• chop the image into subimages with borders 2 * nHard
• reassemble the image based on subimages with borders 2 * nWien

Shouldn't the values of N for chopping the image up and reassembling it be the same? In practice it doesn't matter because nWien and nHard are both defined as the same value, but if one value was changed it seems the result would not be good. I think the parameters on those lines should respectively be 2 * nHard, 2 * nHard, 2 * nWien, 2 * nWien.

The ./bm3d executable seems to have a problem with saving an image in the JPG format. I tried to denoise this image which worked only if I set the output filename to *.png but not *.jpg. The denoising seems to work in both cases but for the latter the saved image can not be opened.

Hi, I'm little confused about the value of tauMatch (function bm3d_1st_step):
const float tauMatch = (chnls == 1 ? 3.f : 1.f) * (sigma_table[0] < 35.0f ? 2500 : 5000)
I'm just wondering why do we use tauMatch = 3\sigma when the input image has single channel?
Thank you!