Canny

int sx[3][3] = { { -1, 0, 1 },{ -2, 0, 2 },{ -1, 0, 1 } };
int sy[3][3] = { { 1, 2, 1 },{ 0, 0, 0 },{ -1, -2, -1 } };

Mat modDir(Mat src, int kernelX[3][3], int kernelY[3][3], int kernelSize, bool print = false)
{
    Mat dst = src.clone();
    int height = src.rows, width = src.cols, range = kernelSize / 2;

    for (int i = 1; i < height - 1; i++) {
        for (int j = 1; j < width - 1; j++) {
            double sumPixelX = 0.0f;
            double sumPixelY = 0.0f;
            double total = 0.0f;

            for (int k = 0; k < kernelSize; k++) {
                for (int l = 0; l < kernelSize; l++) {
                    int x = i + k - range, y = j + l - range;
                    if (x >= 0 && x < height && y >= 0 && y < width) {
                        uchar pixel = src.at<uchar>(x, y);
                        sumPixelX += pixel * kernelX[k][l];
                        sumPixelY += pixel * kernelY[k][l];
                    }
                }
            }
            dst.at<uchar>(i, j) = (uchar)(sqrt((sumPixelX * sumPixelX) + (sumPixelY * sumPixelY)) / (4 * sqrt(2.0)));

        }
    }
    if (print) {
        imshow("Imagine original", src);
        imshow("Imagine modul", dst);
        waitKey();
    }
    return dst;
}

Mat dirMod(Mat src, int kernelX[3][3], int kernelY[3][3], int kernelSize, bool print = false)
{
    //Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC1);
    Mat dst = src.clone();
    int height = src.rows, width = src.cols, range = kernelSize / 2;

    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            double sumPixelX = 0.0f;
            double sumPixelY = 0.0f;
            double total = 0.0f;

            for (int k = 0; k < kernelSize; k++) {
                for (int l = 0; l < kernelSize; l++) {
                    int x = i + k - range, y = j + l - range;
                    if (x >= 0 && x < height && y >= 0 && y < width) {
                        uchar pixel = src.at<uchar>(x, y);
                        sumPixelX += pixel * kernelX[k][l];
                        sumPixelY += pixel * kernelY[k][l];
                    }
                }
            }
            float x = atan2((float)sumPixelY, (float)sumPixelX);
            if ((x >= (3 * PI) / 8 && x <= (5 * PI) / 8) || (x >= -(5 * PI) / 8 && x <= -(3 * PI) / 8))
                dst.at<uchar>(i, j) = 0;
            else if ((x >= (PI) / 8 && x <= (3 * PI) / 8) || (x >= -(7 * PI) / 8 && x <= -(5 * PI) / 8))
                dst.at<uchar>(i, j) = 1;
            else if ((x >= -(PI) / 8 && x <= (PI) / 8) || (x >= (7 * PI) / 8) || (x <= -(7 * PI) / 8))
                dst.at<uchar>(i, j) = 2;
            else if ((x >= (5 * PI) / 8 && x <= (7 * PI) / 8) || (x >= -(3 * PI) / 8 && x <= -(PI) / 8))
                dst.at<uchar>(i, j) = 3;

        }
    }
    if (print) {
        imshow("Imagine original", src);
        imshow("Imagine directie", dst);
        waitKey();
    }
    return dst;
}



Mat cannyAlgorithm(Mat src)
{
    int height = src.rows;
    int width = src.cols;
    Mat dst = Mat(height, width, CV_8UC1);
    Mat dst1 = Mat(height, width, CV_8UC1);
    Mat dst2 = Mat(height, width, CV_8UC1);

    //pas 1
    //dst = GaussFil(src, 3);

    //pas 2
    dst1 = modDir(src, sx, sy, 3);
    dst2 = dirMod(src, sx, sy, 3); // cadranele sunt 100% bune ca am verificat de pe net
    Mat dst3 = dst1.clone();
    Mat dst4 = dst1.clone();

    //pas 3 - inca nu e okkkkk!!!
    //i-urile si j-urile de mai jos sunt bune ca le-am verificat
    for (int i = 1; i<height - 1; i++)
    {
        for (int j = 1; j<width - 1; j++)
        {
            if (dst2.at<uchar>(i, j) == 0)
            {
                if ((dst1.at<uchar>(i, j) < dst1.at<uchar>(i + 1, j)) || (dst1.at<uchar>(i, j) < dst1.at<uchar>(i - 1, j)))
                {
                    dst3.at<uchar>(i, j) = 0;
                }
            }
            else if (dst2.at<uchar>(i, j) == 1)
            {
                if ((dst1.at<uchar>(i, j) < dst1.at<uchar>(i + 1, j - 1)) || (dst1.at<uchar>(i, j) < dst1.at<uchar>(i - 1, j + 1)))
                {
                    dst3.at<uchar>(i, j) = 0;
                }
            }
            else if (dst2.at<uchar>(i, j) == 2)
            {
                if ((dst1.at<uchar>(i, j) < dst1.at<uchar>(i, j - 1)) || (dst1.at<uchar>(i, j) < dst1.at<uchar>(i, j + 1)))
                {
                    dst3.at<uchar>(i, j) = 0;
                }
            }
            else if (dst2.at<uchar>(i, j) == 3)
            {
                if ((dst1.at<uchar>(i, j) < dst1.at<uchar>(i - 1, j - 1)) || (dst1.at<uchar>(i, j) < dst1.at<uchar>(i + 1, j + 1)))
                {
                    dst3.at<uchar>(i, j) = 0;
                }
            }
        }
    }

    //pas 4

    int histo[256];

    for (int i = 0; i < 256; i++) {
        histo[i] = 0;
    }

    for (int i = 1; i < src.rows - 1; i++)
    {
        for (int j = 1; j < src.cols - 1; j++)
        {
            int index = dst3.at<uchar>(i, j);
            histo[index]++;
        }
    }

    //showHistogram("Histograma", histo, 256, 256);

    long nrNonMuchie = 0;
    float p = 0.1;       //p are valori intre 0.01 si 0.1, in lab zice ca e 0.1
    float k = 0.4;

    nrNonMuchie = (1 - p)*((height - 2)*(width - 2) - histo[0]);

    int sum = 0;
    int prag = -1;
    int i = 1;
    while (i < 256 && prag == -1)
    {
        sum += histo[i];
        if (sum > nrNonMuchie)
        {
            prag = i;
        }
        i++;
    }

    int pragInalt = prag;
    int pragCoborat = k*prag;

    for (int i = 1; i < dst3.rows - 1; i++)
    {
        for (int j = 1; j < dst3.cols - 1; j++)
        {
            if (dst3.at<uchar>(i, j) < pragCoborat)
                dst4.at<uchar>(i, j) = 0;
            else if (dst3.at<uchar>(i, j) > pragInalt)
                dst4.at<uchar>(i, j) = 255;
            else
                dst4.at<uchar>(i, j) = 128;
        }
    }

    // pas 5
    int neighb = 8;
    int di[8] = { -1, 0, 1, 0, -1, -1, 1, 1 };
    int dj[8] = { 0, -1, 0, 1, -1, 1, -1, 1 };
    //int di[24] = { -2, -1, 0, 1, 2, -2, -1, 0, 1, 2, -2, -1, 1, 2, -2, -1, 0, 1, 2, -2, -1, 0, 1, 2 };
    //int dj[24] = { -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 };
    Mat dstExtend = dst4.clone();
    Mat visited = Mat::zeros(dstExtend.rows, dstExtend.cols, CV_8UC1);
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            uchar pixel = dst4.at<uchar>(i, j);
            if (pixel == 255) {
                std::queue<Point2i> Q;
                Q.push(Point2i(i, j));
                while (!Q.empty()) {
                    Point2i point = Q.front();  //Luam primul element din coada, fara a-l sterge
                    Q.pop();    //Stergem primul element din coada
                                //Parcurgem vecinii
                    for (int k = 0; k < neighb; k++) {
                        int x = point.x + di[k],
                            y = point.y + dj[k];
                        if (x > 0 && x < height && y > 0 && y < width) {
                            if (dst4.at<uchar>(x, y) == 128 && visited.at<uchar>(x, y) == 0) {
                                dstExtend.at<uchar>(x, y) = 255;
                                visited.at<uchar>(x, y) = 1;
                                Q.push(Point2i(x, y));  //Adaugam vecinii in coada
                                                        //printf("Added to queue\n");
                            }
                        }
                    }
                }
            }
        }
    }
    //Parcurgere pentru eliminarea muchiilor slabe ramase
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            uchar pixel = dstExtend.at<uchar>(i, j);
            if (pixel == 128)
                dstExtend.at<uchar>(i, j) = 0;
        }
    }


    /*imshow("Imagine originala", src);
    imshow("Imagine Canny maxime", dst3);
    imshow("Imagine Canny binarizare", dst4);
    imshow("Canny final", dstExtend);
    waitKey();*/
    return dstExtend;
}