Prewitt

#include "stdafx.h"

#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
    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,2,1},
        {0,0,0},
        {-1,-2,-1}
    };
    static int sobel_vertical[3][3]=
    {
        {1,0,-1},
        {2,0,-2},
        {1,0,-1}
    };

    //horizontal
    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 min = handEdgesHorizontalPixels[0][0];
    int max = handEdgesHorizontalPixels[0][0];

    for(int i=0; i < handEdgesHorizontalPixels.rows; i++)
    {
        for (int j=0; j < handEdgesHorizontalPixels.cols; j++)
        {
            if (handEdgesHorizontalPixels[i][j] < min)
            {
                min = handEdgesHorizontalPixels[i][j];
            }
            if (handEdgesHorizontalPixels[i][j] > max)
            {
                max = 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]-min)*255)/(max-min);
        }
    }

    //vertical

    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] < min)
            {
                min = handEdgesVerticalPixels[i][j];
            }
            if (handEdgesVerticalPixels[i][j] > max)
            {
                max = 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]-min)*255)/(max-min);
        }
    }

    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;
}