#include "opencv2/opencv.hpp"
#include "opencv2/cuda.hpp"
#include "opencv2\cudaarithm.hpp"

#include <iostream>

using namespace std;
using namespace cv;

//TBB need for using this
class Parallel_process : public cv::ParallelLoopBody
{

private:
	cv::Mat& inImg;
	cv::Mat& outImg;
	int widhStep;
	int m_stride;
	cv::Scalar scalar; //B,G,R

public:
	Parallel_process(cv::Mat& inputImgage, Mat& outImage, Scalar& inScalar)
		: inImg(inputImgage), outImg(outImage), scalar(inScalar){

		widhStep = inputImgage.size().width * 3;
		m_stride = inputImgage.size().width * 2;


	}

	virtual void operator()(const cv::Range& range) const
	{
		//thread
		for (int i = range.start; i < range.end; i++)
		{

			int s1 = i*widhStep;

			for (int iw = 0; iw< inImg.size().width; iw++)
			{
				int s2 = iw * 3;
				int mc = s1 + s2;

				unsigned char B1 = (unsigned char)(inImg.data[mc + 0]);
				unsigned char G1 = (unsigned char)(inImg.data[mc + 1]);
				unsigned char R1 = (unsigned char)(inImg.data[mc + 2]);

				int B2 = B1 + scalar[0];
				int G2 = G1 + scalar[1];
				int R2 = R1 + scalar[2];

				if (B2 > 255)
					B2 = 255;
				if (G2 > 255)
					G2 = 255;
				if (R2 > 255)
					R2 = 255;

				if (B2 < 0)
					B2 = 0;
				if (G2 < 0)
					G2 = 0;
				if (R2 < 0)
					R2 = 0;


				outImg.data[mc + 0] = B2;
				outImg.data[mc + 1] = G2;
				outImg.data[mc + 2] = R2;


			}
		}
	}
};





int main(int, char)
{

	Mat img = imread("scret.jpg");
	Mat img_add;
	Mat img_absdiff;
	Mat img_subtract;
	Mat img_mul;
	Mat img_div;
	Mat img_parallel;

	unsigned long AAtime = 0, BBtime = 0; //check processing time


	//cpu add
	AAtime = getTickCount();
	add(img, Scalar(200, 200, 200), img_add); //Value is between 0 and 255
	BBtime = getTickCount();
	printf("add cpu %.2lf sec \n", (BBtime - AAtime) / getTickFrequency()); //check processing time


	//cpu subtraction
	AAtime = getTickCount();
	subtract(img, Scalar(200, 200, 200), img_subtract); //Value is between 0 and 255
	BBtime = getTickCount();
	printf("subtract %.2lf sec \n", (BBtime - AAtime) / getTickFrequency()); //check processing time


	//cpu absdiff
	AAtime = getTickCount();
	absdiff(img, Scalar(200, 200, 200), img_absdiff); //Value is between 0 and 255
	BBtime = getTickCount();
	printf("absdiff %.2lf sec \n", (BBtime - AAtime) / getTickFrequency()); //check processing time


	//cpu *, /
	img_mul = img * 20;
	img_div = img / 20;




	cuda::GpuMat gimg;
	cuda::GpuMat gout1, gout2;
	//gpu add
	gimg.upload(img);
	cuda::absdiff(gimg, Scalar(10, 2, 100), gout1);
	cuda::add(gimg, Scalar(-200, -200, -200), gout2);


	//tbb
	AAtime = getTickCount();
	img_parallel = Mat(img.size(), img.type());
	cv::parallel_for_(cv::Range(0, img.rows), Parallel_process(img, img_parallel, Scalar(-200, -200, -200)));
	BBtime = getTickCount();
	printf("parallel %.2lf sec \n", (BBtime - AAtime) / getTickFrequency()); //check processing time


	imshow("img", img);
	imshow("img_add", img_add);
	imshow("img_absdiff", img_absdiff);
	imshow("img_subtract", img_subtract);
	imshow("img_mul", img_mul);
	imshow("img_div", img_div);
	imshow("img_parallel", img_parallel);


	waitKey(0);


	return 0;
}