The pixel intensity in the fig (a) shows that the values for several pixels are uneven and not normalized. Thus, in order to process the intensity value of each pixels corresponding to one another they need to perform bi-cubic interpolation to normalize the unevenness so that a proper association between pixel intensities can be achieved (as shown in normalized 3d plane from fig(b)).

if you are using opencv then pass your pixel intensity of the images as img (mxn matrix) use this command:

bicubic_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_CUBIC)

Also visit this link for better undertsanding of math concept: https://www.youtube.com/watch?v=yej8Nq0Kgio&ab_channel=Dr.CarlosMontalvo

Thank you Ankush Rai and Wolfgang Reichl

> "fig (a) shows that the values for several pixels are uneven and not normalized"

Are you referring to the white specs everywhere (maybe plot visualization artifact), or are you referring to the black spikes at the top of the intensity range?

> "in order to process the intensity value of each pixels corresponding to one another"

So this is basically saying: "if we want to use a process on a pixel where that process takes into account it's neighbors"? Is that it's 8-surrounding neighbors, or a larger neighborhood?

> "they need to perform bi-cubic interpolation to normalize the unevenness so that a proper association between pixel intensities can be achieved"

I understand how bicubic interpolation is used to get the pixel intensities in between pixels, but I'm unsure how you would use those interpolated pixel intensities to normalize a pixel value. Suppose you want to normalize a pixel, would you try to interpolate at the pixel itself?

Wolfgang Reichl

https://en.wikipedia.org/wiki/Bicubic_interpolation#/media/File:Comparison_of_1D_and_2D_interpolation.svg

It has the cubic splines going through each point. Thus, in this graphic, interpolating at one of those points would be pointless since it would be "fixed" as you said (I'm assuming "fixed" here means the interpolated value at the point of choice will be the same value prior to interpolation).

>"This happens with some versions of linear interpolation". The Wikipedia page gives the different versions of bicubic interpolation: "Bicubic interpolation can be accomplished using either Lagrange polynomials, cubic splines, or cubic convolution algorithm". So I suppose the graphic gives a version of "fixed interpolation" so to speak. I will try other versions of interpolation until I find an "unfixed" version.

Wolfgang Reichl

The whole image is split into 30x30 sub-regions and, using bicubic interpolation, a second plot is obtained representing the intensity level of the local background (Fig. 3b)

Basically, for each pixel I create a representation of the local background. If you see the attached image, the brown dots show the relative location of each pixel that make up the representation of the local background. Then, using these 16 pixels, I bicubic interpolate at the location of the pixel of interest.

This method ensures that the new pixel value is a representation of the local background reached by using bicubic interpolation. What do you guys think? Reasonable? Logical?

You are quite there...but there is some misunderstanding....say they aren't performing interpolation in each 30 x 30 patch... but instead using the average pixel intensity of each patch with its 4 corners to interpolate it with other endpoint (avg pixel intensity of other neighboring patches and its 4 corners). Which latter gives the pixel intensity of each pixels between these endpoints. (if you do interpolation between each patch then it will not smooth out the results shown in fig(b).. as each patch will be smoothed out internally but the pixel intensity of neighboring patches will vary...)

i'll just add simple explanation of the process.

First Objective at hand is that we need to remove the peaks (smooth out) and trough of pixel intensity at every pixel in the given image. (fig a).

Why we need to interpolate...? Because interpolation gives the crisp transitional values between values between two or more endpoints (in this case it is feed as a matrix).

How can it be done over an image with m rows and n columns?

1. It can be done by dividing this image into patches of size 30 x 30 pixels.

2. Get the average pixel intensity of each of the divided patches of 30 x 30 pixels and pixel intensity of 4 corners of the patch

3. Now each patch has an average pixel intensity and 4 corners of each patch is taken in account (rest of the pixels in each patch are treated as local background.) which is treated as an endpoint to be interpolated with average pixel intensity with other patches + pixel intensity of other patch's 4 corners during interpolation. (filling of the gaps is achieved by bicubic interpolation plz refer... https://www.youtube.com/watch?v=AqscP7rc8_M&ab_channel=Computerphile & https://www.youtube.com/watch?v=poY_nGzEEWM&ab_channel=Computerphile )

3. later the interpolated pixel intensity of each patch is used to set the intensity of each pixels in that patch..Thereby smoothing the peaks and trough from the overall image.

Note: We are dealing with interpolation of pixel intensity not the pixel value..

Hope this helps..

Ankush Rai Thank you so much for that explanation! It helped out tremendously. A visual of my current understanding is attached. So, you're saying to do the following:

1) Divide image into patches

2) Calculate the average intensity of the patch (denote this as i_avg). The i_avg value is then placed at the center of each respective patch (red in attached image).

3) Find the corner pixels of each patch.

4) With these 5 points per patch (4 corner pixels and 1 centralized average pixel), you have 60 points total for the entire example image. The last step is that you use these 60 points to interpolate (using bicubic) to get the new values for all of the local background points.

This would in theory produce a "smoother" surface than the original image. Is this what you're suggesting? Thanks again for discussing, sorry if I missed something.

yeah..that's it....

Hi anyone who comes to this page! Thanks again for the responses. My final solution was to break the image into 30x30 patches and then create a 4x4 grid of points that represent the patch. These points are evenly spaced out inside the patch. I then interpolate at the middle of the patch using those 16 points, and the reason I did 16 and not 4 as suggested earlier is that scipy's bicubic interpolate function requires 16 points. If the interpolated value was outside of 0-255 range then it was set to 0 or 255. Then I made a new 1024x1024 image that was made up of patches where each patch was a constant value equal to the interpolated value. This seems to work well and gives a result similar as seen in the images from the paper.