theodore's profile - activity

I am trying the make the life of one of my friends easier regarding to the project that he is working. He has a bunch of images like this one:

and the purpose is to extract the white dots. I tried different kind of filters, and the best that I managed to get was by using Scharr:

and the bitwise_nor version of it:

now I the problem is that some dots are not that acute so if I apply threshold I erase quite some of them or I am not able to extract all of them. I tried to segment the image into blocks and apply different threshold to each of the blocks and then recreate the image but the result is not that good as well (actually worse). As I can see the main problem is the noise in-between. If you can think something that might help to eliminate this noise, I would be grateful. It seems so easy, but for some reason I am stuck.

I want to apply the denoising filter I named in the title which is based on the following equations:

where d is a scalar constant diffusivity parameter, I(x, y) is the initial noisy image, and u(x, y, t) is the image obtained after a diffusion time t lets say 5, 10 and 30. However, I am quite confused about which function to use and how, in order to achieve this in OpenCV. I have the feeling that it is quite simple but for some reason I am confused. Does anyone have an idea?

Here is a sample image:

UPDATE

this is the result images after following @LBerger 's code, they are in time t = 0/t = 4 and d = 1:

, is it expected to be like that?

I think that something is wrong, because I am trying also to compare it with the gaussian smoothing. And according to the following formula:

where G√2t (x, y) is the Gaussian kernel. This proves that performing isotropic linear diffusion for a time t with d = 1 is exactly equivalent to performing Gaussian smoothing with a σ = √(2t)

and applying the gaussian filter with the following code:

void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, const float sigma, const int ksize_x = 0, const int ksize_y = 0)
{
    int ksize_x_ = ksize_x, ksize_y_ = ksize_y;

    // Compute an appropriate kernel size according to the specified sigma
    if (sigma > ksize_x || sigma > ksize_y || ksize_x == 0 || ksize_y == 0)
    {
        ksize_x_ = (int)ceil(2.0f*(1.0f + (sigma - 0.8f) / (0.3f)));
        ksize_y_ = ksize_x_;
    }

    // The kernel size must be and odd number
    if ((ksize_x_ % 2) == 0)
    {
        ksize_x_ += 1;
    }

    if ((ksize_y_ % 2) == 0)
    {
        ksize_y_ += 1;
    }

    // Perform the Gaussian Smoothing
    GaussianBlur(src, dst, Size(ksize_x_, ksize_y_), sigma, sigma, BORDER_DEFAULT);

    // show result
    std::ostringstream out;
    out << std::setprecision(1) << std::fixed << sigma;
    String title = "sigma: " + out.str();
    imshow(title, dst);
    imwrite("gaussian/" + title + ".png", dst);

    waitKey(260);
}

and calling it with gaussian_2D_convolution(img, smoothed, sqrt(2*5)); the two results of gaussian smoothing and isotropic linear smoothing in time t = 5 are respectively:

which are for sure not similar :-(.

really impressive work!!! nice :-)

As the title says I want to calculate the surface normals of a given depth image by using the cross product of neighboring pixels. However, I do not really understand the procedure. Does anyone have any experience?

Lets say that we have the following image:

what are the steps to follow?

Update:

I am trying to translate the following pseudocode from this answer to opencv.

dzdx=(z(x+1,y)-z(x-1,y))/2.0;
dzdy=(z(x,y+1)-z(x,y-1))/2.0;
direction=(-dxdz,-dydz,1.0)
magnitude=sqrt(direction.x**2 + direction.y**2 + direction.z**2)
normal=direction/magnitude

where z(x,y) is my depth image. However, the output of the following does not seem correct to me:

for(int x = 0; x < depth.rows; ++x)
{
    for(int y = 0; y < depth.cols; ++y)
    {
        double dzdx = (depth.at<double>(x+1, y) - depth.at<double>(x-1, y)) / 2.0;
        double dzdy = (depth.at<double>(x, y+1) - depth.at<double>(x, y-1)) / 2.0;
        Vec3d d = (dzdx, dzdy, 1.0);
        Vec3d n = normalize(d);
    }
}

Update2:

Ok I think I am close:

Mat3d normals(depth.size(), CV_32FC3);

for(int x = 0; x < depth.rows; ++x)
{
    for(int y = 0; y < depth.cols; ++y)
    {
        double dzdx = (depth.at<double>(x+1, y) - depth.at<double>(x-1, y)) / 2.0;
        double dzdy = (depth.at<double>(x, y+1) - depth.at<double>(x, y-1)) / 2.0;

        Vec3d d;
        d[0] = -dzdx;
        d[1] = -dzdy;
        d[2] = 1.0;

        Vec3d n = normalize(d);
        normals.at<Vec3d>(x, y)[0] = n[0];
        normals.at<Vec3d>(x, y)[1] = n[1];
        normals.at<Vec3d>(x, y)[2] = n[2];
    }
}

which gives me the following image:

Update 3:

following @berak's approach:

depth.convertTo(depth, CV_64FC1); // I do not know why it is needed to be transformed to 64bit image my input is 32bit

Mat nor(depth.size(), CV_64FC3);

for(int x = 1; x < depth.cols - 1; ++x)
{
    for(int y = 1; y < depth.rows - 1; ++y)
    {
        /*double dzdx = (depth(y, x+1) - depth(y, x-1)) / 2.0;
        double dzdy = (depth(y+1, x) - depth(y-1, x)) / 2.0;
        Vec3d d = (-dzdx, -dzdy, 1.0);*/
        Vec3d t(x,y-1,depth.at<double>(y-1, x)/*depth(y-1,x)*/);
        Vec3d l(x-1,y,depth.at<double>(y, x-1)/*depth(y,x-1)*/);
        Vec3d c(x,y,depth.at<double>(y, x)/*depth(y,x)*/);
        Vec3d d = (l-c).cross(t-c);
        Vec3d n = normalize(d);
        nor.at<Vec3d>(y,x) = n;
    }
}

imshow("normals", nor);

I get this one:

which seems quite ok. However, if I use a 32bit image instead of 64bit the image is corrupted:

Hey guys, I was just wondering, there are cases where sometimes you need to plot a graph in real time within a project in order to keep track or evaluate data or for any other possible reason.

At the moment OpenCV does not support such a functionality - right? please correct me if I am wrong here, maybe the 3.x version introduced something that I am not aware - and from a thorough search that I did I only found this two libraries, [1] and [2] that somehow try to simulate such a wanna be plotting functionality with the use of OpenCV. However though I appreciate the effort of their authors, both are quite old, meaning they are using the old C api and for sure they are not something close to functional, like matlab, gnuplot, etc... So, here comes my question how do you guys do it?

I was looking also at QWT and some examples but it does not seem that convenient regarding also that you need to include Qt libraries and create a project in a form of application since you need to start a QApplication object.

My wonder was that OpenCV as a mature and really known library in computer vision and image processing fields should have such a functionality or to embed it from another external library which is specifically for that reason, since I thing such a functionality is quite some times necessary.

Moreover, I was also thinking on starting something from scratch based on the first two libraries that I pointed here, but I am not that confident that I would be able to provide a solution and reach it in such a level that I would be also able to contribute it to the main OpenCV's source code. So if someone is interested we could also arrange a group that will start such a task in our spare time and when we reach it in a good level to contribute it to OpenCV.

So I would like to hear your opinions and why not enlighten and advice me, regarding what you are using or how you do it in general or if you are interested to create something together if there is a need about it. Be aware though that I am not talking about offline plotting since this is quite easy to manage and there are a lot of tools out there that make the drill in more than a perfect way ;-).

Now in addition to the my previous thread regarding isotropic linear diffusion smoothing, I want to solve the non-linear version of it based on the Perona-Malik approach. Again we have the following formula:

(1)

, where D is not a constant but varies across the image domain. A popular choice is the Perona-Malik diffusivity which can be given as:

(2)

where λ is the contrast parameter. ∇u(x, y) is the gradient of the image at pixel (x, y). It seems that KAZE features embed this functionality, therefore I have a look at the source code. Specifically the formula (2) is implemented with the following function:

/* ************************************************************************* */
/**
 * @brief This function computes the Perona and Malik conductivity coefficient g2
 * g2 = 1 / (1 + dL^2 / k^2)
 * @Param Lx First order image derivative in X-direction (horizontal)
 * @Param Ly First order image derivative in Y-direction (vertical)
 * @Param dst Output image
 * @Param k Contrast factor parameter
 */
void pm_g2(const cv::Mat &Lx, const cv::Mat& Ly, cv::Mat& dst, float k) {

    Size sz = Lx.size();
    dst.create(sz, Lx.type());
    float k2inv = 1.0f / (k * k);

    for(int y = 0; y < sz.height; y++) {
        const float *Lx_row = Lx.ptr<float>(y);
        const float *Ly_row = Ly.ptr<float>(y);
        float* dst_row = dst.ptr<float>(y);
        for(int x = 0; x < sz.width; x++) {
            dst_row[x] = 1.0f / (1.0f + ((Lx_row[x] * Lx_row[x] + Ly_row[x] * Ly_row[x]) * k2inv));
        }
    }
}

However, while I am trying to use it regarding to what @LBerger came up in the other thread I cannot get the correct output. What do I miss again?

I see that the author apply some scalar non-linear diffusion step functionality which I do not really understand what it is about it, here is the function. I tried what @Guanta suggested in the other thread

I think in the evolution_ - Vector (KAZEFeatures.h) are the evolutions over time, so if you'd take the last element and then from that element's struct (TEvolution.h) the Lsmooth Mat should be the image which has been smoothed. To create the evolution_-vector you need to call Create_Nonlinear_Scale_Space() .

but it did not give a good output :-(.