edited_1

// ***********************************************************************
//
// Demo program for education in subject
// Computer Architectures and Paralel Systems.
// Petr Olivka, dep. of Computer Science, FEI, VSB-TU Ostrava
// email:[email protected]
//
// Example of CUDA Technology Usage.
// Image creation and its modification using CUDA.
// Image manipulation is performed by OpenCV library.
//
// ***********************************************************************

#include <stdio.h>
#include <cuda_runtime.h>
#include "opencv2/opencv.hpp"
#include "pic_type.h"

using namespace cv;

// Prototype of function in .cu file
void run_startAnimace(CUDA_Pic velky, CUDA_Pic &CUDAvelky,
					  CUDA_Pic maly, CUDA_Pic &CUDAmaly,
					  CUDA_Pic vysledek, CUDA_Pic &CUDAvysledek
					 );

void run_prubehAnimace(CUDA_Pic velky, CUDA_Pic &CUDAvelky,
		  	  	  	  CUDA_Pic maly, CUDA_Pic &CUDAmaly,
		  	  	  	  CUDA_Pic vysledek, CUDA_Pic &CUDAvysledek,
		  	  	  	  uint2 block_size, int2 pozice);

void run_konecAnimace(CUDA_Pic CUDAvelky,
					  CUDA_Pic CUDAmaly,
					  CUDA_Pic CUDAvysledek
					 );

// Image size
#define SIZEX 432 // Width of image
#define	SIZEY 322 // Heigth of image
// Block size for threads
#define BLOCKX 40 // block width
#define BLOCKY 25 // block height

int main()
{
	// Array is created to store all points from image with size SIZEX * SIZEY.
	// Image is stored line by line.
	// Creation of empty image
	Mat cv_img( SIZEY, SIZEX, CV_8UC3 );
	Mat cv_img2( SIZEY, SIZEX, CV_8UC3 );

	CUDA_Pic velky;
	velky.Size.x = SIZEX;
	velky.Size.y = SIZEY;
	velky.PData = new uchar4[ velky.Size.x * velky.Size.y ];

	CUDA_Pic CUDAvelky;
	CUDAvelky.Size.x = SIZEX;
	CUDAvelky.Size.y = SIZEY;
	CUDAvelky.PData = new uchar4[ CUDAvelky.Size.x * CUDAvelky.Size.y ];

	CUDA_Pic maly;
	maly.Size.x = SIZEX/2;
	maly.Size.y = SIZEY/2;
	maly.PData = new uchar4[ maly.Size.x * maly.Size.y ];

	CUDA_Pic CUDAmaly;
	CUDAmaly.Size.x = SIZEX/2;
	CUDAmaly.Size.y = SIZEY/2;
	CUDAmaly.PData = new uchar4[ CUDAmaly.Size.x * CUDAmaly.Size.y ];

	CUDA_Pic vysledek;
	vysledek.Size.x = SIZEX;
	vysledek.Size.y = SIZEY;
	vysledek.PData = new uchar4[ vysledek.Size.x * vysledek.Size.y ];

	CUDA_Pic CUDAvysledek;
	CUDAvysledek.Size.x = SIZEX;
	CUDAvysledek.Size.y = SIZEY;
	CUDAvysledek.PData = new uchar4[ CUDAvysledek.Size.x * CUDAvysledek.Size.y ];

	// Image filling by color gradient blue-green-red
	for ( int y = 0; y < velky.Size.y; y++ )
		for ( int x  = 0; x < velky.Size.x; x++ )
		{
			uchar4 bgr = { 0, 0, 0 }; // black
			if ( x < velky.Size.x / 2 )
			{
				bgr.y = 255 * x / ( velky.Size.x / 2 );
				bgr.x = 255 - bgr.y;
			}
			else
			{
				bgr.y = 255 * (velky.Size.x - x ) / ( velky.Size.x / 2 );
				bgr.z = 255 - bgr.y;
			}
			// store points to array for transfer to GPU device
			velky.PData[ y * velky.Size.x + x ] = bgr;
		}

	// Image filling by color gradient blue-green-red
		for ( int y = 0; y < maly.Size.y; y++ )
			for ( int x  = 0; x < maly.Size.x; x++ )
			{
				uchar4 bgr = { 0, 0, 0 }; // black
				if ( x < maly.Size.x / 2 )
				{
					bgr.y = 255 * x / ( maly.Size.x / 2 );
					bgr.x = 255 - bgr.y;
				}
				else
				{
					bgr.y = 255 * (maly.Size.x - x ) / ( maly.Size.x / 2 );
					bgr.z = 255 - bgr.y;
				}
				// store points to array for transfer to GPU device
				maly.PData[ y * maly.Size.x + x ] = bgr;
			}


	int2 pozice;
	pozice.x = 20;
	pozice.y = 20;

	// Function calling from .cu file
	uint2 block_size = { BLOCKX, BLOCKY };
	run_startAnimace(velky, CUDAvelky, maly, CUDAmaly, vysledek, CUDAvysledek);

	for(pozice.x; pozice.x <= 200; pozice.x++) {
		run_prubehAnimace(velky, CUDAvelky, maly, CUDAmaly, vysledek, CUDAvysledek, block_size, pozice);

		// Store modified data to image
		for ( int y = 0; y <  vysledek.Size.y; y++ )
			for ( int x  = 0; x < vysledek.Size.x; x++ )
			{
				uchar4 bgr =  vysledek.PData[ y *  vysledek.Size.x + x ];
				Vec3b v3bgr( bgr.x, bgr.y, bgr.z );
				cv_img2.at<Vec3b>( y, x ) = v3bgr;
			}
		// Show modified image
		imshow( "B-G-R Gradient & Color flip", cv_img2 );
		waitKey( 1 );
	}

	run_konecAnimace(CUDAvelky, CUDAmaly, CUDAvysledek);

	waitKey( 0 );
}