void TestRegressionWindow::treeWidgetContextMenuRequested(const QPoint &pos)
{
if((m_testCounter == -1 && m_activeProcess) || (m_testCounter > 0 && m_activeProcess) ||
m_testsUrl.isEmpty() || m_khtmlUrl.isEmpty()) // Still processing/not ready yet...
{
return;
}
QTreeWidgetItem *item = m_ui.treeWidget->itemAt(pos);
if(item && item != m_ui.treeWidget->topLevelItem(0))
{
m_activeTreeItem = item;
// Build & show popup menu...
QMenu menu(m_ui.treeWidget);
menu.addAction(SmallIcon("media-playback-start"), i18n("Run test..."), this, SLOT(runSingleTest()));
menu.addSeparator();
menu.addAction(SmallIcon("list-add"), i18n("Add to ignores..."), this, SLOT(addToIgnores()));
menu.addAction(SmallIcon("dialog-cancel"), i18n("Remove from ignores..."), this, SLOT(removeFromIgnores()));
if(!menu.exec(m_ui.treeWidget->mapToGlobal(pos)))
m_activeTreeItem = 0; // Needs reset...
}
}
int
main(int argc, char **argv)
{
pArgc = &argc;
pArgv = argv;
char *ref_file = NULL;
printf("%s Starting...\n\n", sSDKsample);
//start logs
if (checkCmdLineFlag(argc, (const char **)argv, "help"))
{
printHelp();
exit(EXIT_SUCCESS);
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
fpsLimit = frameCheckNumber;
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
}
if (ref_file)
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
int device = findCudaDevice(argc, (const char **)argv);
if (device < 0)
{
printf("No CUDA Capable devices found, exiting...\n");
exit(EXIT_SUCCESS);
}
checkDeviceMeetComputeSpec(argc, argv);
}
else
{
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
cudaSetDevice(dev);
}
else
{
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
}
}
else
{
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
{
printf(" This SDK does not explicitly support -device=n when running with OpenGL.\n");
printf(" When specifying -device=n (n=0,1,2,....) the sample must not use OpenGL.\n");
printf(" See details below to run without OpenGL:\n\n");
printf(" > %s -device=n -file=output.bin\n\n", argv[0]);
printf("exiting...\n");
exit(EXIT_SUCCESS);
}
// 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);
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
cudaGLSetGLDevice(dev);
}
else
{
exit(EXIT_SUCCESS);
}
}
// load volume data
initData(argc, argv);
printf(
"Press \n"
" 'SPACE' to toggle animation\n"
" 'p' to toggle pre-integrated transfer function\n"
" '+' and '-' to change density (0.01 increments)\n"
" ']' and '[' to change brightness\n"
" ';' and ''' to modify transfer function offset\n"
" '.' and ',' to modify transfer function scale\n\n");
if (ref_file)
{
runSingleTest(ref_file, argv[0]);
}
else
{
// This is the normal rendering path for VolumeRender
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
initPixelBuffer();
atexit(cleanup);
glutMainLoop();
}
cudaDeviceReset();
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
pArgc = &argc;
pArgv = argv;
char *ref_file = NULL;
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
printf("%s Starting...\n\n", sSDKsample);
printf("NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.\n\n");
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
fpsLimit = frameCheckNumber;
}
}
// Get the path of the filename
char *filename;
if (getCmdLineArgumentString(argc, (const char **) argv, "image", &filename))
{
image_filename = filename;
}
// load image
char *image_path = sdkFindFilePath(image_filename, argv[0]);
if (image_path == NULL)
{
fprintf(stderr, "Error unable to find and load image file: '%s'\n", image_filename);
exit(EXIT_FAILURE);
}
sdkLoadPPM4ub(image_path, (unsigned char **)&h_img, &width, &height);
if (!h_img)
{
printf("Error unable to load PPM file: '%s'\n", image_path);
exit(EXIT_FAILURE);
}
printf("Loaded '%s', %d x %d pixels\n", image_path, width, height);
if (checkCmdLineFlag(argc, (const char **)argv, "threads"))
{
nthreads = getCmdLineArgumentInt(argc, (const char **) argv, "threads");
}
if (checkCmdLineFlag(argc, (const char **)argv, "sigma"))
{
sigma = getCmdLineArgumentFloat(argc, (const char **) argv, "sigma");
}
runBenchmark = checkCmdLineFlag(argc, (const char **) argv, "benchmark");
int device;
struct cudaDeviceProp prop;
cudaGetDevice(&device);
cudaGetDeviceProperties(&prop, device);
if (!strncmp("Tesla", prop.name, 5))
{
printf("Tesla card detected, running the test in benchmark mode (no OpenGL display)\n");
// runBenchmark = true;
runBenchmark = true;
}
// Benchmark or AutoTest mode detected, no OpenGL
if (runBenchmark == true || ref_file != NULL)
{
findCudaDevice(argc, (const char **)argv);
}
else
{
// 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);
findCudaGLDevice(argc, (const char **)argv);
}
initCudaBuffers();
if (ref_file)
{
printf("(Automated Testing)\n");
bool testPassed = runSingleTest(ref_file, argv[0]);
cleanup();
// 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(testPassed ? EXIT_SUCCESS : EXIT_FAILURE);
}
if (runBenchmark)
{
printf("(Run Benchmark)\n");
benchmark(100);
cleanup();
// 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(EXIT_SUCCESS);
}
initGLBuffers();
glutMainLoop();
exit(EXIT_SUCCESS);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
// start logs
int devID;
char *ref_file = NULL;
printf("%s Starting...\n\n", argv[0]);
#if defined(__linux__)
setenv ("DISPLAY", ":0", 0);
#endif
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **)argv, "radius"))
{
filter_radius = getCmdLineArgumentInt(argc, (const char **) argv, "radius");
}
if (checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
iterations = getCmdLineArgumentInt(argc, (const char **)argv, "passes");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
}
}
// load image to process
loadImageData(argc, argv);
if (checkCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// This is a separate mode of the sample, where we are benchmark the kernels for performance
devID = findCudaDevice(argc, (const char **)argv);
// Running CUDA kernels (bilateralfilter) in Benchmarking mode
g_TotalErrors += runBenchmark(argc, argv);
// 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);
}
else if (checkCmdLineFlag(argc, (const char **)argv, "radius") ||
checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
// This overrides the default mode. Users can specify the radius used by the filter kernel
devID = findCudaDevice(argc, (const char **)argv);
g_TotalErrors += runSingleTest(ref_file, argv[0]);
// 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);
}
else
{
// Default mode running with OpenGL visualization and in automatic mode
// the output automatically changes animation
printf("\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, (char **)argv);
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
dev = gpuGLDeviceInit(argc, (const char **)argv);
if (dev == -1)
{
exit(EXIT_FAILURE);
}
}
else
{
// 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(EXIT_SUCCESS);
}
// Now we can create a CUDA context and bind it to the OpenGL context
initCuda();
initGLResources();
// sets the callback function so it will call cleanup upon exit
#if defined (__APPLE__) || defined(MACOSX)
atexit(cleanup);
#else
glutCloseFunc(cleanup);
#endif
printf("Running Standard Demonstration with GLUT loop...\n\n");
printf("Press '+' and '-' to change filter width\n"
"Press ']' and '[' to change number of iterations\n"
"Press 'e' and 'E' to change Euclidean delta\n"
"Press 'g' and 'G' to changle Gaussian delta\n"
"Press 'a' or 'A' to change Animation mode ON/OFF\n\n");
// Main OpenGL loop that will run visualization for every vsync
glutMainLoop();
}
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int
main(int argc, char **argv)
{
int devID = 0;
char *ref_file = NULL;
pArgc = &argc;
pArgv = argv;
// start logs
printf("%s Starting...\n\n", argv[0]);
if (checkCmdLineFlag(argc, (const char **)argv, "help"))
{
printHelp();
exit(EXIT_SUCCESS);
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if (argc > 1)
{
if (checkCmdLineFlag(argc, (const char **)argv, "threads"))
{
nthreads = getCmdLineArgumentInt(argc, (const char **) argv, "threads");
}
if (checkCmdLineFlag(argc, (const char **)argv, "radius"))
{
filter_radius = getCmdLineArgumentInt(argc, (const char **) argv, "radius");
}
if (checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
iterations = getCmdLineArgumentInt(argc, (const char **) argv, "passes");
}
if (checkCmdLineFlag(argc, (const char **)argv, "file"))
{
getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
}
}
// load image to process
loadImageData(argc, argv);
if (checkCmdLineFlag(argc, (const char **)argv, "benchmark"))
{
// This is a separate mode of the sample, where we are benchmark the kernels for performance
devID = findCudaDevice(argc, (const char **)argv);
// Running CUDA kernels (boxfilter) in Benchmarking mode
g_TotalErrors += runBenchmark();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else if (checkCmdLineFlag(argc, (const char **)argv, "radius") ||
checkCmdLineFlag(argc, (const char **)argv, "passes"))
{
// This overrides the default mode. Users can specify the radius used by the filter kernel
devID = findCudaDevice(argc, (const char **)argv);
g_TotalErrors += runSingleTest(ref_file, argv[0]);
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
else
{
// Default mode running with OpenGL visualization and in automatic mode
// the output automatically changes animation
printf("\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);
int dev = findCapableDevice(argc, argv);
if (dev != -1)
{
cudaGLSetGLDevice(dev);
}
else
{
cudaDeviceReset();
exit(EXIT_SUCCESS);
}
// Now we can create a CUDA context and bind it to the OpenGL context
initCuda();
initGLResources();
// sets the callback function so it will call cleanup upon exit
atexit(cleanup);
printf("Running Standard Demonstration with GLUT loop...\n\n");
printf("Press '+' and '-' to change filter width\n"
"Press ']' and '[' to change number of iterations\n"
"Press 'a' or 'A' to change animation ON/OFF\n\n");
// Main OpenGL loop that will run visualization for every vsync
glutMainLoop();
cudaDeviceReset();
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
