#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>

cv::Mat& perform(cv::Mat& I){
  CV_Assert(I.depth() != sizeof(uchar));
  switch(I.channels())  {
  case 1:
    for( int i = 0; i < I.rows; ++i)
        for( int j = 0; j < I.cols; ++j )
            I.at<uchar>(i,j) = (I.at<uchar>(i,j)/32)*32;
    break;
  case 3:
    cv::Mat_<cv::Vec3b> _I = I;
    for( int i = 0; i < I.rows; ++i)
        for( int j = 0; j < I.cols; ++j ){
            _I(i,j)[0] = (_I(i,j)[0]/32)*32;
            _I(i,j)[1] = (_I(i,j)[1]/32)*32;
            _I(i,j)[2] = (_I(i,j)[2]/32)*32;
        }
    I = _I;
    break;
  }
  return I;
}

uchar cutToRange(int value){
	if (value > 255)
		value = 255;
	if (value < 0)
		value = 0;
	return (uchar)value;
}

cv::Mat& substractRed(cv::Mat& I){
	CV_Assert(I.depth() != sizeof(uchar));
	switch (I.channels())  {
	case 1:
		break;
	case 3:
		cv::Mat_<cv::Vec3b> _I = I;
		for (int i = 0; i < I.rows; ++i)
			for (int j = 0; j < I.cols; ++j){
			int brightness = _I(i, j)[0] - (_I(i, j)[0] + _I(i, j)[1] + _I(i, j)[2]) / 3;
			_I(i, j)[0] = cutToRange((int)_I(i, j)[2] - brightness);
			_I(i, j)[1] = cutToRange((int)_I(i, j)[2] - brightness);
			_I(i, j)[2] = cutToRange((int)_I(i, j)[2] - brightness);
			}
		I = _I;
		break;
	}
	return I;
}



cv::Mat& changeBrightness(cv::Mat& I, int changeValue){
	CV_Assert(changeValue <= 100 && changeValue >= -100);
	switch (I.channels())  {
	case 1:
		break;
	case 3:
		cv::Mat_<cv::Vec3b> _I = I;
		for (int i = 0; i < I.rows; ++i)
			for (int j = 0; j < I.cols; ++j){
			_I(i, j)[0] = cutToRange((int)_I(i, j)[0] + changeValue);
			_I(i, j)[1] = cutToRange((int)_I(i, j)[1] + changeValue);
			_I(i, j)[2] = cutToRange((int)_I(i, j)[2] + changeValue);
			}
		I = _I;
		break;
	}
	return I;
}

cv::Mat& changeContrast(cv::Mat& I, int changeValue){
	CV_Assert(changeValue <= 100 && changeValue >= -100);
	switch (I.channels())  {
	case 1:
		break;
	case 3:
		cv::Mat_<cv::Vec3b> _I = I;
		for (int i = 0; i < I.rows; ++i)
			for (int j = 0; j < I.cols; ++j){
			_I(i, j)[0] = cutToRange((int)_I(i, j)[0] * (1 + changeValue / 100));
			_I(i, j)[1] = cutToRange((int)_I(i, j)[1] * (1 + changeValue / 100));
			_I(i, j)[2] = cutToRange((int)_I(i, j)[2] * (1 + changeValue / 100));
			}
		I = _I;
		break;
	}
	return I;
}

cv::Mat selectMax(cv::Mat& I){
    CV_Assert(I.depth() != sizeof(uchar));
    cv::Mat  res(I.rows,I.cols, CV_8UC3);
    switch(I.channels())  {
    case 3:
        cv::Mat_<cv::Vec3b> _I = I;
        cv::Mat_<cv::Vec3b> _R = res;
        for( int i = 0; i < I.rows; ++i)
            for( int j = 0; j < I.cols; ++j ){
                int sel = (_I(i,j)[0] < _I(i,j)[1])?1:0;
                sel = _I(i,j)[sel] < _I(i,j)[2]?2:sel;
                _R(i,j)[0] = sel==0?255:0;
                _R(i,j)[1] = sel==1?255:0;
                _R(i,j)[2] = sel==2?255:0;
            }
        res = _R;
        break;
    }
    return res;
}

cv::Mat shallowCopy(cv::Mat& I){
	CV_Assert(I.depth() != sizeof(uchar));
	cv::Mat  res(I.rows, I.cols, CV_8UC3);
	switch (I.channels())  {
	case 3:
		cv::Mat_<cv::Vec3b> _I = I;
		cv::Mat_<cv::Vec3b> _R = res;
		for (int i = 0; i < I.rows; ++i)
			for (int j = 0; j < I.cols; ++j){
			_R(i, j)[0] = _I(i, j)[0];
			_R(i, j)[1] = _I(i, j)[1];
			_R(i, j)[2] = _I(i, j)[2];
			}
		res = _R;
		break;
	}
	return res;
}


cv::Vec3b determinePixelValueByConv(cv::Mat& neigbourhood, int edgeValue){
	int coeffs1[3][3] = { { -1, -1, -1 }, { -1, 9, -1 }, { -1, -1, -1 } };
	int coeffs2[3][3] = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };
	float coeffs1sum = 1.;
	float coeffs2sum = 9.;
	cv::Mat_<cv::Vec3b> _neigbourhood = neigbourhood;
	cv::Vec3b centralPixel = _neigbourhood(1, 1);
	cv::Vec3b outputPixel = cv::Vec3b();
	if ((centralPixel[0] + centralPixel[1] + centralPixel[2])/3 < edgeValue){
		for (int k = 0; k < 3; k++){
			int product_sum = 0;
			for (int i = 0; i < _neigbourhood.rows; ++i){
				for (int j = 0; j < _neigbourhood.cols; ++j){
					product_sum += (_neigbourhood(i, j)[k] * coeffs1[i][j]);
				}
			}
			outputPixel[k] = cutToRange((int)(product_sum / coeffs1sum));
		}
	}

	else{
		for (int k = 0; k < 3; k++){
			float coeffs_sum = 0;
			int product_sum = 0;
			for (int i = 0; i < _neigbourhood.rows; ++i){
				for (int j = 0; j < _neigbourhood.cols; ++j){
					product_sum += (_neigbourhood(i, j)[k] * coeffs2[i][j]);
					coeffs_sum += coeffs2[i][j];
				}
			}
			outputPixel[k] = cutToRange((int)(product_sum / coeffs2sum));
		}
	}
	return outputPixel;

}



cv::Mat specialConv(cv::Mat& I, int edgeValue){
	cv::Mat imageCopy = shallowCopy(I);
	cv::Mat_<cv::Vec3b> _I = I;

	for (int i = 1; i < I.rows-2; i++){
		for (int j = 1; j < I.cols-2; j++){
			cv::Mat neigbourhood = imageCopy(cv::Rect(j - 1, i - 1, 3, 3));
			cv::Vec3b outputPixel = determinePixelValueByConv(neigbourhood, edgeValue);
			_I(i, j)[0] = outputPixel[0];
			_I(i, j)[1] = outputPixel[1];
			_I(i, j)[2] = outputPixel[2];	
		}
	}
	I = _I;
	return I;

}


void printHistogram(cv::Mat& I){
	cv::Mat_<cv::Vec3b> _I = I;
	int histTable[8] = {};
	for (int i = 0; i < I.rows; ++i)
		for (int j = 0; j < I.cols; ++j){
			int basket = (_I(i, j)[0] + _I(i, j)[1] + _I(i, j)[2]) / (3 * 32);
			histTable[basket] += 1;
		}
	for (int i = 0; i < 8; i++){
		std::cout << histTable[i];
		std::cout << " ";
	}
}

int main(int, char *[]) {
    std::cout << "Start ..." << std::endl;
    cv::Mat image = cv::imread("Lena.png");

    //cv::Mat max = selectMax(image);
	
    cv::imshow("Lena",image);
	cv::Mat image2 = specialConv(image, 255);
	cv::imshow("Lena2", image2);
    //cv::imshow("Max",max);
    //std::cout << image2.isContinuous() << max.isContinuous() << std::endl;
    //cv::imwrite("Max.png",max);
    cv::waitKey(-1);
    return 0;
}