CWICZENIE_NR_3_DETEKCJA_KRAWEDZI

#include "stdafx.h" //CWICZENIE NR 3 DETEKCJA KRAWEDZI
#include <opencv2/imgproc/imgproc.hpp>  // Gaussian Blur
#include <opencv2/core/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
#include <math.h>
#include <iostream>
using namespace std;
using namespace cv;

void detectEdges(Mat_<uchar> &peppersPixels, Mat_<uchar> &handEdgesMergedPixels, int centerX, int centerY);
int _tmain(int argc, _TCHAR* argv[])
{
    // Stworzenie okna w którym przechwycone obrazy będą wyświetlane
    cvNamedWindow("Wykrywanie krawędzi", CV_WINDOW_AUTOSIZE);
    // Pobranie obrazu ZADANIE NR 1 Wczytać do pamięci obraz JPEG hand.jpg
    Mat imagePeppers = imread("hand.jpg",CV_LOAD_IMAGE_GRAYSCALE);
    // Utworzenie obiektu przechowującego obraz z wyznaczonymi krawędziami
    Mat handEdgesMerged = imagePeppers.clone();
    // Uzyskanie macierzy pikseli na podstawie obiektów Mat
    Mat_<uchar> handPixels = imagePeppers;
    Mat_<uchar> handEdgesMergedPixels = handEdgesMerged;
    // Wyznaczenie wpółrzędnych środa obrazu
    int centerX = handPixels.cols/2;
    int centerY = handPixels.rows/2;
    // Obracanie obrazu
    detectEdges(handPixels, handEdgesMergedPixels, centerX, centerY);
    // Wyświetlanie obrazu
    imshow("Wykrywanie krawędzi", handEdgesMerged);
    // Oczekiwanie na wciśnięcie klawisza Esc lub Enter
    char key;
    do  key = cvWaitKey(1);
    while(key != 27 && key != 13);
    // Niszczenie okna
    cvDestroyWindow("Wykrywanie krawędzi");
    return 0;
}

void detectEdges(Mat_<uchar> &handPixels, Mat_<uchar> &handEdgesMergedPixels, int centerX, int centerY)
{
    /* Funkcja wyznaczająca krawędzie za pomocą maski morfologicznej podanej przez prowadzącego.
    Wyznaczane są najpierw krawędzie pionowe, później poziome. Następnie wykonywane jest scalenie
    krawędzi pionowych i poziomych, przeskalowanie obrazu scalonego do zakresu 0-255 oraz binaryzacja
    z eksperymentalnie dobranym progiem.
    Wynikowy obraz zostaje zapisany w handEdgesMergedPixels.*/
    //handEdgesHorizontal = ;
    //handEdgesMergedPixels = handEdgesHorizontal;
    // Utworzenie obiektów przechowujących obrazy z wyznaczonymi krawędziami: pionowymi i poziomymi
    Mat handEdgesVertical = handPixels.clone();
    Mat handEdgesHorizontal = handPixels.clone();
    // Uzyskanie macierzy pikseli na podstawie obiektów Mat
    Mat_<int> handEdgesVerticalPixels = handEdgesVertical;
    Mat_<int> handEdgesHorizontalPixels = handEdgesHorizontal;// TODO
    /*static int sobel_horizontal[3][3]=
    {
        {1,1,1},
        {0,0,0},
        {-1,-1,-1}

    };*/
    /*static int sobel_horizontal[3][3]=
    {
        {1,2,1},
        {0,0,0},
        {-1,-2,-1}

    };*/
    static int sobel_vertical[3][3]=
    {
        {1,0,-1},
        {2,0,-2},
        {1,0,-1}
    };
    static int sobel_horizontal[3][3]=
    {
        {1,2,1},
        {0,0,0},
        {-1,-2,-1}
    };
    //HORIZONTAL (POZIOMO)
    for(int y = 1; y < handEdgesHorizontalPixels.rows - 1; y++)
    {
        for(int x = 1; x < handEdgesHorizontalPixels.cols - 1; x++)
        {
            int suma =
            handPixels[y-1][x-1]* sobel_horizontal[0][0] +
            handPixels[y-1][x]* sobel_horizontal[0][1] +
            handPixels[y-1][x+1]* sobel_horizontal[0][2] +
            handPixels[y][x-1]* sobel_horizontal[1][0] +
            handPixels[y][x]* sobel_horizontal[1][1] +
            handPixels[y][x+1]* sobel_horizontal[1][2] +
            handPixels[y+1][x-1]* sobel_horizontal[2][0] +
            handPixels[y+1][x]* sobel_horizontal[2][1] +
            handPixels[y+1][x+1]* sobel_horizontal[2][2];
            handEdgesHorizontalPixels[y][x] = abs(suma);
        }
    }
    int minimum = handEdgesHorizontalPixels[0][0];
    int maximum = handEdgesHorizontalPixels[0][0];
    for(int i=0; i < handEdgesHorizontalPixels.rows; i++)
    {
        for (int j=0; j < handEdgesHorizontalPixels.cols; j++)
        {
            if (handEdgesHorizontalPixels[i][j] < minimum)
            {
                minimum = handEdgesHorizontalPixels[i][j];
            }
            if (handEdgesHorizontalPixels[i][j] > maximum)
            {
                maximum = handEdgesHorizontalPixels[i][j];
            }
        }
    }
    for(int y=1; y < handEdgesHorizontalPixels.rows - 1; y++)
    {
        for (int x=1; x < handEdgesHorizontalPixels.cols - 1; x++)
        {
            handEdgesHorizontalPixels[y][x] = ((handEdgesHorizontalPixels[y][x]-minimum)*255)/(maximum-minimum);
        }
    }
    //VERTICAL (PIONOWO)
    for(int y = 1; y < handEdgesVerticalPixels.rows - 1; y++)
    {
        for(int x = 1; x < handEdgesVerticalPixels.cols - 1; x++)
        {
            int suma =
            handPixels[y-1][x-1]* sobel_vertical[0][0] +
            handPixels[y-1][x]* sobel_vertical[0][1] +
            handPixels[y-1][x+1]* sobel_vertical[0][2] +
            handPixels[y][x-1]* sobel_vertical[1][0] +
            handPixels[y][x]* sobel_vertical[1][1] +
            handPixels[y][x+1]* sobel_vertical[1][2] +
            handPixels[y+1][x-1]* sobel_vertical[2][0] +
            handPixels[y+1][x]* sobel_vertical[2][1] +
            handPixels[y+1][x+1]* sobel_vertical[2][2];
            handEdgesVerticalPixels[y][x] = abs(suma);
        }
    }
    for(int i=0; i < handEdgesVerticalPixels.rows; i++)
    {
        for (int j=0; j < handEdgesVerticalPixels.cols; j++)
        {
            if (handEdgesVerticalPixels[i][j] < minimum)
            {
                minimum = handEdgesVerticalPixels[i][j];
            }
            if (handEdgesVerticalPixels[i][j] > maximum)
            {
                maximum = handEdgesVerticalPixels[i][j];
            }
        }
    }
    for(int y=0; y < handEdgesVerticalPixels.rows - 1; y++)
    {
        for (int x=0; x < handEdgesVerticalPixels.cols - 1; x++)
        {
            handEdgesVerticalPixels[y][x] = ((handEdgesVerticalPixels[y][x]-minimum)*255)/(maximum-minimum);
        }
    }
    int minscale = handEdgesVerticalPixels[0][0]+handEdgesHorizontalPixels[0][0],
        maxscale = handEdgesVerticalPixels[0][0]+handEdgesHorizontalPixels[0][0];
    for(int i=0; i < handEdgesVerticalPixels.rows; i++)
    {
        for(int j = 0; j < handEdgesVerticalPixels.cols; j++)
        {
            if(handEdgesVerticalPixels[i][j] + handEdgesHorizontalPixels[i][j] > maxscale)
                maxscale = handEdgesVerticalPixels[i][j] + handEdgesHorizontalPixels[i][j];
            if(handEdgesVerticalPixels[i][j] + handEdgesHorizontalPixels[i][j] < minscale)
                minscale = handEdgesVerticalPixels[i][j] + handEdgesHorizontalPixels[i][j];
        }
    }
    Mat_<int> mat = handEdgesVertical;
    for(int y=0;y< handEdgesVerticalPixels.rows; y++)
    {
        for(int x = 0; x < handEdgesVerticalPixels.cols; x++)
        {
            mat[y][x]=((handEdgesHorizontalPixels[y][x]+handEdgesVerticalPixels[y][x]-minscale)*255)/(maxscale-minscale);
        }
    }
    handEdgesMergedPixels = handEdgesHorizontalPixels;
}