//Input: Saturation channel from HSV image
void imageToGpu(){
clock_t read_start = clock();
// Pre load pixel data
printf("starting pixel data filling\n");
for(int i = 0; i < MAIN_TEXTURE_HEIGHT; i++){
for(int j = 0; j < PIC_WIDTH; j++){
if (j < PIC_WIDTH/2)
pixelData[PIC_WIDTH/2*i + j] = image.at<uchar>(i, j);
else
pixelData2[PIC_WIDTH/2*i + (j - PIC_WIDTH/2)] = image.at<uchar>(i, j);
}
}
printf("after pixel data\n");
pic_data = (void*)pixelData;
pic_data2 = (void*)pixelData2;
printf("time passed for reading image: %f\n", (float)(clock() - read_start)/CLOCKS_PER_SEC );
//Pass data to texture
const uint8_t* data = (const uint8_t*)pic_data;
const uint8_t* data2 = (const uint8_t*)pic_data2;
ytexture.SetPixels(data);
ytexture2.SetPixels(data2);
}
//Only call after filling mediantexture
void gpuEdge(){
DrawSobelRect(&mediantexture,-1.f,-1.f,1.f,1.f,&greysobeltexture);
DrawSobelRect(&mediantexture2,-1.f,-1.f,1.f,1.f,&greysobeltexture2);
concat1 = greysobeltexture.Save("tex_sobel.png", "sobel", output1);
concat2 = greysobeltexture2.Save("tex_sobel2.png", "sobel", output2);
hconcat(concat1, concat2, outputImage);
}
void gpuBlur()
{
clock_t begin_proc = clock();
DrawMedianRect(&ytexture,-1.f,-1.f,1.f,1.f,&mediantexture);
printf("median time: %f\n", (float)(clock() - begin_proc)/CLOCKS_PER_SEC );
DrawMedianRect(&ytexture2,-1.f,-1.f,1.f,1.f,&mediantexture2);
printf("median time: %f\n", (float)(clock() - begin_proc)/CLOCKS_PER_SEC );
clock_t debug_time = clock();
concat1 = mediantexture.Save("tex_blur.png", "blur", output1);
concat2 = mediantexture2.Save("tex_blur2.png", "blur", output2);
hconcat(concat1, concat2, outputImage);
if (debug) imwrite("out.jpg", outputImage);
printf("concat time: %f\n", (float)(clock() - debug_time)/CLOCKS_PER_SEC );
}
void GfxGraphicsCommandList::ResourceBarrier(
GfxTexture& texture,
GfxResourceStates before,
GfxResourceStates after,
GfxResourceBarrierFlag flag)
{
m_base->ResourceBarrier(
texture.GetBaseTexture()->GetNativeResource(),
before,
after,
flag);
}
void cam_update()
{
// <------------------------------------------------ Wait for new image to appear ---------------------------------------------->
while(!cam->BeginReadFrame(0,frame_data,frame_sz)) {};
digitalWrite(PIN_TCAP, HIGH) ;
// <----------------lock the chosen frame buffer, and copy it directly into the corresponding open gl texture ---------------->
data = (const uint8_t*)frame_data;
ypitch = MAIN_TEXTURE_WIDTH;
ysize = ypitch*MAIN_TEXTURE_HEIGHT;
uvpitch = MAIN_TEXTURE_WIDTH/2;
uvsize = uvpitch*MAIN_TEXTURE_HEIGHT/2;
upos = ysize;
vpos = upos+uvsize;
ytexture.SetPixels(data);
utexture.SetPixels(data+upos);
vtexture.SetPixels(data+vpos);
cam->EndReadFrame(0);
}
int GfxGraphicsCommandList::UploadTexture(
GfxDevice& device,
GfxTexture& targetTexture,
const void* srcBuffer,
size_t srcBufferSize,
GfxResourceState before,
GfxResourceState after)
{
return m_base->UploadTexture(
*device.GetBaseDevice(),
*targetTexture.GetBaseTexture(),
srcBuffer,
srcBufferSize,
before,
after);
}
int gpuInit(){
//initialize graphics and the camera
InitGraphics();
cout << "graphics initialized" << endl;
ytexture.CreateGreyScale(PIC_WIDTH/2,MAIN_TEXTURE_HEIGHT);
ytexture2.CreateGreyScale(PIC_WIDTH/2,MAIN_TEXTURE_HEIGHT);
greysobeltexture.CreateRGBA(PIC_WIDTH/2, MAIN_TEXTURE_HEIGHT);
greysobeltexture.GenerateFrameBuffer();
greysobeltexture2.CreateRGBA(PIC_WIDTH/2, MAIN_TEXTURE_HEIGHT);
greysobeltexture2.GenerateFrameBuffer();
mediantexture.CreateRGBA(PIC_WIDTH/2, MAIN_TEXTURE_HEIGHT);
mediantexture.GenerateFrameBuffer();
mediantexture2.CreateRGBA(PIC_WIDTH/2, MAIN_TEXTURE_HEIGHT);
mediantexture2.GenerateFrameBuffer();
background = imread("background.jpg");
if (background.empty()){
cout << "reference image not found" << endl;
return LOAD_ERROR;
}
int imgSize = background.total();
//Allocate buffers for pixel Data and U and V fillings
//Needs "zeros" to fill YUV image
pixelData = new uchar[imgSize/2];
pixelData2 = new uchar[imgSize/2];
zeros = new uchar[imgSize];
for(int i =0; i < background.rows; i++)
for(int j = 0; j < background.cols; j++){
zeros[background.cols*i + j] = 125;
}
//Fixes bit allignment problems
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
//Allocate output pixel data
output1 = malloc(greysobeltexture.GetWidth()*greysobeltexture.GetHeight()*4);
output2 = malloc(greysobeltexture.GetWidth()*greysobeltexture.GetHeight()*4);
return 0;
}
void init_opengl_fcns ()
{
cout << " Initializing OpenGL Graphics Library"<<endl;
// <------------------------------------------------ Generate textures for image processing in OpenGL ---------------------------------------------->
ytexture.CreateGreyScale(MAIN_TEXTURE_WIDTH,MAIN_TEXTURE_HEIGHT);
utexture.CreateGreyScale(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
vtexture.CreateGreyScale(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
hsv.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
hsv.GenerateFrameBuffer();
gray.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
gray.GenerateFrameBuffer();
tex.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
tex.GenerateFrameBuffer();
lab.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
lab.GenerateFrameBuffer();
kernel.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
kernel.GenerateFrameBuffer();
kernelx.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
kernelx.GenerateFrameBuffer();
kernely.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
kernely.GenerateFrameBuffer();
laplacian.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
laplacian.GenerateFrameBuffer();
undistort_img.CreateRGBA(MAIN_TEXTURE_WIDTH/2,MAIN_TEXTURE_HEIGHT/2);
undistort_img.GenerateFrameBuffer();
cout<<"Completed initializing OpenGL Graphics"<<endl<<endl;
}
