void loadImageData(int argc, char **argv)
{
// load image (needed so we can get the width and height before we create the window
char *image_path = NULL;
if (argc >= 1)
{
image_path = sdkFindFilePath(image_filename, argv[0]);
}
if (image_path == NULL)
{
fprintf(stderr, "Error finding image file '%s'\n", image_filename);
exit(EXIT_FAILURE);
}
LoadBMPFile((uchar4 **)&hImage, &width, &height, image_path);
if (!hImage)
{
fprintf(stderr, "Error opening file '%s'\n", image_path);
exit(EXIT_FAILURE);
}
printf("Loaded '%s', %d x %d pixels\n\n", image_path, width, height);
}
int main( int argc, char** argv)
{
unsigned char * pRGBA = NULL;
int w, h;
if ( !LoadBMPFile( (void **) &pRGBA, &w, &h, "portrait_noise.bmp") )
return 1;
glutInit( &argc, argv );
glutInitWindowSize(w, h);
glutInitWindowPosition(0, 0);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutCreateWindow("image processing template");
glutDisplayFunc(Display);
glutIdleFunc(Idle);
glutKeyboardFunc(Keyboard);
glutReshapeFunc(Reshape);
GLenum error = glewInit();
if (error != GL_NO_ERROR)
return -1;
g_Tex = glCreateTexture(w, h, pRGBA);
g_PBO = glCreatePBO(w, h);
Wrapper_Convolution_Init( pRGBA, w, h, g_PBO );
glutMainLoop();
return 0;
}
//==============================================================
// 로드
void CDIB::LoadFromFile(wstring file_name) {
if (!FileExists(file_name)) return;
file_name=ToUpper(file_name);
if (EndsWith(file_name, L".BMP")) LoadBMPFile(file_name); else
if (EndsWith(file_name, L".PNG")) LoadPNGFile(file_name);
if (EndsWith(file_name, L".JPG") || EndsWith(file_name, L".JPEG")) LoadJPEGFile(file_name);
}
void runAutoTest(int argc, char **argv, const char *filename, int kernel_param)
{
printf("[%s] - (automated testing w/ readback)\n", sSDKsample);
int devID = findCudaDevice(argc, (const char **)argv);
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = sdkFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL)
{
printf("imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
exit(EXIT_FAILURE);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
checkCudaErrors(CUDA_MallocArray(&h_Src, imageW, imageH));
TColor *d_dst = NULL;
unsigned char *h_dst = NULL;
checkCudaErrors(cudaMalloc((void **)&d_dst, imageW*imageH*sizeof(TColor)));
h_dst = (unsigned char *)malloc(imageH*imageW*4);
{
g_Kernel = kernel_param;
printf("[AutoTest]: %s <%s>\n", sSDKsample, filterMode[g_Kernel]);
checkCudaErrors(CUDA_Bind2TextureArray());
runImageFilters(d_dst);
checkCudaErrors(CUDA_UnbindTexture());
checkCudaErrors(cudaDeviceSynchronize());
checkCudaErrors(cudaMemcpy(h_dst, d_dst, imageW*imageH*sizeof(TColor), cudaMemcpyDeviceToHost));
sdkSavePPM4ub(filename, h_dst, imageW, imageH);
}
checkCudaErrors(CUDA_FreeArray());
free(h_Src);
checkCudaErrors(cudaFree(d_dst));
free(h_dst);
printf("\n[%s] -> Kernel %d, Saved: %s\n", sSDKsample, kernel_param, filename);
// cudaDeviceReset causes the driver to clean up all state. While
// not mandatory in normal operation, it is good practice. It is also
// needed to ensure correct operation when the application is being
// profiled. Calling cudaDeviceReset causes all profile data to be
// flushed before the application exits
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
void runAutoTest(int argc, char **argv)
{
int devID = 0;
printf("[%s] - (automated testing w/ readback)\n", sSDKsample);
devID = cutilChooseCudaDevice(argc, argv);
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = cutFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL) {
printf( "imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_FAILED);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
cutilSafeCall( CUDA_MallocArray(&h_Src, imageW, imageH) );
g_CheckRender = new CheckBackBuffer(imageW, imageH, sizeof(TColor), false);
g_CheckRender->setExecPath(argv[0]);
TColor *d_dst = NULL;
cutilSafeCall( cudaMalloc( (void **)&d_dst, imageW*imageH*sizeof(TColor)) );
while (g_Kernel <= 3) {
printf("[AutoTest]: %s <%s>\n", sSDKsample, filterMode[g_Kernel]);
cutilSafeCall( CUDA_Bind2TextureArray() );
runImageFilters(d_dst);
cutilSafeCall( CUDA_UnbindTexture() );
cutilSafeCall( cutilDeviceSynchronize() );
cudaMemcpy(g_CheckRender->imageData(), d_dst, imageW*imageH*sizeof(TColor), cudaMemcpyDeviceToHost);
g_CheckRender->savePPM(sOriginal[g_Kernel], true, NULL);
if (!g_CheckRender->PPMvsPPM(sOriginal[g_Kernel], sReference[g_Kernel], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Kernel++;
}
cutilSafeCall( CUDA_FreeArray() );
free(h_Src);
cutilSafeCall( cudaFree( d_dst ) );
delete g_CheckRender;
printf("\n[%s] -> Test Results: %d errors\n", sSDKsample, g_TotalErrors);
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, (!g_TotalErrors ? QA_PASSED : QA_FAILED));
}
void init_phi(){
int *init;
unsigned char *mask;
const char *mask_path = MASK;
if((init=(int *)malloc(imageW*imageH*sizeof(int)))==NULL)printf("ME_INIT\n");
if((phi=(float *)malloc(imageW*imageH*sizeof(float)))==NULL)printf("ME_PHI\n");
mask = (unsigned char *)malloc(imageW*imageH*sizeof(unsigned char));
//printf("Init Mask\n");
LoadBMPFile(&h_Mask, &imageW, &imageH, mask_path);
for(r=0;r<imageH;r++){
for(c=0;c<imageW;c++){
mask[r*imageW+c] = (h_Mask[r*imageW+c].x)/255;
//printf("%3d ", mask[r*imageW+c]);
}
//printf("\n");
}
sedt2d(init,mask,imageH,imageW);
//printf("sdf of init mask\n");
for(r=0;r<imageH;r++){
for(c=0;c<imageW;c++){
phi[r*imageW+c]=(float)init[r*imageW+c];
if(phi[r*imageW+c]>0){
phi[r*imageW+c]=0.5*sqrt(abs(phi[r*imageW+c]));
} else {
phi[r*imageW+c]=-0.5*sqrt(abs(phi[r*imageW+c]));
}
//printf("%6.3f ", phi[r*imageW+c]);
}
//printf("\n");
}
free(init);
free(mask);
}
CBMPContainer::CBMPContainer(char *fileName)
{
BOOL bResult;
char *fullFileName;
fullFileName = new char [strlen(fileName) + strlen(BITMAP_LOAD_DIRECTORY) + 1];
strcpy(fullFileName, BITMAP_LOAD_DIRECTORY);
strcat(fullFileName, fileName);
memset(&myFile, 0x00, sizeof(BMPFile));
bResult = LoadBMPFile(fullFileName, &myFile);
myFileName = fileName;
assert(bResult);
delete [] fullFileName;
}
void loadImageData(int argc, char **argv)
{
// load image (needed so we can get the width and height before we create the window
char* image_path = NULL;
if (argc >= 1) image_path = shrFindFilePath(image_filename, argv[0]);
if (image_path == NULL) {
shrLog("Error finding image file '%s'\n", image_filename);
exit(EXIT_FAILURE);
}
LoadBMPFile((uchar4 **)&h_img, &width, &height, image_path);
//cutilCheckError(cutLoadPPM4ub(image_path, (unsigned char **) &h_img, &width, &height));
h_temp = new unsigned int[width * height];
if (!h_img) {
shrLog("Error opening file '%s'\n", image_path);
exit(-1);
}
shrLog("Loaded '%s', %d x %d pixels\n\n", image_path, width, height);
}
int main(int argc, char** argv){
const char *image_path = IMAGE;
//TODO : declare ALL variables here
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
D = (float *)malloc(imageW*imageH*sizeof(float));
//printf("Input Image\n");
for(r=0;r<imageH;r++){
for(c=0;c<imageW;c++){
D[r*imageW+c] = h_Src[r*imageW+c].x;
/*printf("%3.0f ", D[r*imageW+c]);*/
}
//printf("\n");
}
N = imageW*imageH;
for(i=0;i<N;i++){
D[i] = EPSILON - abs(D[i] - THRESHOLD);
}
//printf("Speed Function\n");
//for(int r=0;r<imageH;r++){
// for(int c=0;c<imageW;c++){
// printf("%3.0f ", D[r*imageW+c]);
// }
// printf("\n");
//}
// Set up CUDA Timer
cutCreateTimer(&Timer);
cutCreateTimer(&ReInitTimer);
cutStartTimer(Timer);
init_phi();
if((contour=(float *)malloc(imageW*imageH*sizeof(float)))==NULL)printf("Contour\n");
if((phi1=(float *)malloc(imageW*imageH*sizeof(float)))==NULL)printf("GRADPHI\n");
//update_phi();
// GL initialisation
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_ALPHA | GLUT_DOUBLE);
glutInitWindowSize(imageW,imageH);
glutInitWindowPosition(100,100);
glutCreateWindow("GL Level Set Evolution");
glClearColor(0.0,0.0,0.0,0.0);
glutDisplayFunc(disp);
glutMainLoop();
//printf("phi+1\n");
//for(int r=0;r<imageH;r++){
// for(int c=0;c<imageW;c++){
// printf("%6.3f ", phi[r*imageW+c]);
// }
// printf("\n");
//}
}
void init(void)
{
// You need to ues glew
glewInit();
GLfloat diffuse[4] = {1.0, 1.0, 1.0, 1.0};
glClearColor (0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
// make synthetic cubemap data
makeSyntheticImages();
//
// Creating a 2D texture from image
//
int width, height;
uchar4 *dst;
LoadBMPFile(&dst, &width, &height, "../mob.bmp"); // this is how to load image
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &color_tex);
glBindTexture(GL_TEXTURE_2D, color_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, dst);
#define DYNAMIC_CUBEMAP //STATIC_CUBEMAP
//
// creating cube map texture (either static or dynamic)
//
#ifdef STATIC_CUBEMAP
// create static cubemap from synthetic data
glGenTextures(1, &cube_tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_tex);
// ToDo...
#endif
// generate cubemap on-the-fly
#ifdef DYNAMIC_CUBEMAP
//RGBA8 Cubemap texture, 24 bit depth texture, 256x256
glGenTextures(1, &cube_tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube_tex);
// ToDo...
//
// creating FBO and attach cube map texture
//
//-------------------------
glGenFramebuffersEXT(1, &fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
//Attach one of the faces of the Cubemap texture to this FBO
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_CUBE_MAP_POSITIVE_X, cube_tex, 0);
//-------------------------
glGenRenderbuffersEXT(1, &depth_rb);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_rb);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, imageSize, imageSize);
//-------------------------
//Attach depth buffer to FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depth_rb);
//-------------------------
//Does the GPU support current FBO configuration?
GLenum status;
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
std::cout<<"good"<<std::endl; break;
default:
assert(false); break;
}
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
#endif
}
int main(int argc, char **argv)
{
char *dump_file = NULL;
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
pArgc = &argc;
pArgv = argv;
printf("%s Starting...\n\n", sSDKsample);
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv,
"file", (char **) &dump_file);
int kernel = 1;
if (checkCmdLineFlag(argc, (const char **)argv, "kernel"))
{
kernel = getCmdLineArgumentInt(argc, (const char **)argv, "kernel");
}
runAutoTest(argc, argv, dump_file, kernel);
}
else
{
printf("[%s]\n", sSDKsample);
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = sdkFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL)
{
printf("imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
exit(EXIT_FAILURE);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL(&argc, argv);
cudaGLSetGLDevice(gpuGetMaxGflopsDeviceId());
checkCudaErrors(CUDA_MallocArray(&h_Src, imageW, imageH));
initOpenGLBuffers();
}
printf("Starting GLUT main loop...\n");
printf("Press [1] to view noisy image\n");
printf("Press [2] to view image restored with knn filter\n");
printf("Press [3] to view image restored with nlm filter\n");
printf("Press [4] to view image restored with modified nlm filter\n");
printf("Press [*] to view smooth/edgy areas [RED/BLUE] Ct's when a filter is active\n");
printf("Press [f] to print frame rate\n");
printf("Press [?] to print Noise and Lerp Ct's\n");
printf("Press [q] to exit\n");
sdkCreateTimer(&timer);
sdkStartTimer(&timer);
glutMainLoop();
}
int main(int argc, char **argv)
{
shrQAStart(argc, argv);
if (argc > 1) {
if (cutCheckCmdLineFlag(argc, (const char **)argv, "qatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "glverify"))
{
g_bOpenGLQA = true;
g_bFBODisplay = false;
fpsLimit = frameCheckNumber;
}
if (cutCheckCmdLineFlag(argc, (const char **)argv, "fbo")) {
g_bFBODisplay = true;
fpsLimit = frameCheckNumber;
}
}
if (g_bQAReadback) {
runAutoTest(argc, argv);
} else {
printf("[%s] ", sSDKsample);
if (g_bFBODisplay) printf("[FBO Display] ");
if (g_bOpenGLQA) printf("[OpenGL Readback Comparisons] ");
printf("\n");
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if ( cutCheckCmdLineFlag(argc, (const char **)argv, "device")) {
printf("[%s]\n", argv[0]);
printf(" Does not explicitly support -device=n in OpenGL mode\n");
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
printf(" > %s -device=n -qatest\n", argv[0]);
printf("exiting...\n");
exit(0);
}
// First load the image, so we know what the size of the image (imageW and imageH)
printf("Allocating host and CUDA memory and loading image file...\n");
const char *image_path = cutFindFilePath("portrait_noise.bmp", argv[0]);
if (image_path == NULL) {
printf( "imageDenoisingGL was unable to find and load image file <portrait_noise.bmp>.\nExiting...\n");
shrQAFinishExit(argc, (const char **)argv, QA_FAILED);
}
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
printf("Data init done.\n");
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
initGL( &argc, argv );
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
cutilSafeCall( CUDA_MallocArray(&h_Src, imageW, imageH) );
initOpenGLBuffers();
// Creating the Auto-Validation Code
if (g_bOpenGLQA) {
if (g_bFBODisplay) {
g_CheckRender = new CheckFBO(imageW, imageH, 4);
} else {
g_CheckRender = new CheckBackBuffer(imageW, imageH, 4);
}
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(g_bOpenGLQA);
}
}
printf("Starting GLUT main loop...\n");
printf("Press [1] to view noisy image\n");
printf("Press [2] to view image restored with knn filter\n");
printf("Press [3] to view image restored with nlm filter\n");
printf("Press [4] to view image restored with modified nlm filter\n");
printf("Press [ ] to view smooth/edgy areas [RED/BLUE] Ct's\n");
printf("Press [f] to print frame rate\n");
printf("Press [?] to print Noise and Lerp Ct's\n");
printf("Press [q] to exit\n");
glutDisplayFunc(displayFunc);
glutKeyboardFunc(shutDown);
cutilCheckError( cutCreateTimer(&hTimer) );
cutilCheckError( cutStartTimer(hTimer) );
glutTimerFunc(REFRESH_DELAY, timerEvent,0);
glutMainLoop();
cutilDeviceReset();
shrQAFinishExit(argc, (const char **)argv, QA_PASSED);
}
