void saveImages(unsigned char *images, int height, int width, int numberOfRepeats, int *labels, int numberOfLabels, std::string output)
{
srand(time(NULL));
pixel color[height*width];
for(int i = 0; i < 255; i++)
color[i] = randomcolor();
char fileName[32];
for(int l = 0; l < numberOfRepeats; l++)
{
for(int k = 0; k < numberOfLabels; k++)
{
Image<pixel> *im = new Image<pixel>(width, height, true);
for(int i=0; i < height; i++)
for(int j=0; j < width; j++)
im->access[i][j] = color[images[(l * numberOfLabels + k) * height * width + i * width + j]];
strcpy(fileName, "out");
sprintf(&fileName[3], "%d-%d", l, labels[k]);
strcat(fileName, ".ppm");
std::string outputFile;
if (output.length() != 0 && output[output.length() - 1] != '/')
{
outputFile = output + "/" + fileName;
}
else
{
outputFile = output + fileName;
}
savePPM(im, outputFile.c_str());
}
}
}
void Renderer::render() const
{
Ray ray;
P2d pp;
Random rnd(3141592);
C3f *image = new C3f[ _vp.width * _vp.height];
double invNumSample = 1.0 / _vp.numSamples;
// OpenMP
#pragma omp parallel for schedule(dynamic, 1) num_threads(4)
for (int y = 0; y < _vp.height; y++)
{
std::cerr << "Rendering (y = " << y << ") " << (100.0 * y / (_vp.height - 1)) << "%" << std::endl;
for (int x = 0; x < _vp.width; x++)
{
const int imageIndex = (_vp.height - y - 1) * _vp.width + x;
C3f pixelColor(0.0f, 0.0f, 0.0f);
for (int j = 0; j < _vp.numSamples; j++)
{
pp.x = _vp.s*(- x + 0.5 * _vp.width);
pp.y = _vp.s*(y - 0.5 * _vp.height);
ray = _camera->getRay(pp);
pixelColor = pixelColor + radiance(ray, &rnd, 0) / _vp.numSamples;
}
image[imageIndex] = C3f(pixelColor);
}
}
savePPM("output.ppm", image, _vp.width, _vp.height);
delete[] image;
}
void saveImage(unsigned char *img, int height, int width, char *ouputName)
{
srand(time(NULL));
pixel color[height*width];
for(int i = 0; i < 255; i++)
color[i] = randomcolor();
Image<pixel> *output = new Image<pixel>(width, height, true);
for(int i = 0; i < height; i++)
for(int j = 0; j < width; j++)
output->access[i][j] = color[img[i * width + j]];
savePPM(output, ouputName);
}
int main(int argc, char **argv) {
if (argc != 6) {
fprintf(stderr, "usage: %s sigma k min input(ppm) output(ppm)\n", argv[0]);
return 1;
}
float sigma = atof(argv[1]);
float k = atof(argv[2]);
int min_size = atoi(argv[3]);
/* printf("loading input image.\n"); */
image<rgb> *input = loadPPM(argv[4]);
/* printf("processing\n"); */
int num_ccs;
image<rgb> *seg = segment_image(input, sigma, k, min_size, &num_ccs);
savePPM(seg, argv[5]);
/* printf("got %d components\n", num_ccs); */
/* printf("done! uff...thats hard work.\n"); */
return 0;
}
/*
* Save an image to one of the formats implemented by this class
*/
int RImage::save(char file[100]) {
if (strstr(file, ".ppm") != NULL) {
savePPM(file);
} else if (strstr(file, ".pgm") != NULL){
savePGM(file);
} else if (strstr(file, ".jpeg") != NULL ||
strstr(file, ".jpg") != NULL) {
saveJPEG(file, 100);
} else if (strstr(file, ".png") != NULL) {
fprintf(stderr, "ERROR: Format not supported as yet.\n");
savePNG(file);
} else if (strstr(file, ".txt") != NULL) {
saveText(file);
} else {
fprintf(stderr, "ERROR: Cannot save image %s. Unsupported format.\n", file);
exit(1);
}
}
void saveImages(unsigned char *images, int height, int width, int numberOfRepeats, int *labels, int numberOfLabels)
{
srand(time(NULL));
pixel color[height*width];
for(int i = 0; i < 255; i++)
color[i] = randomcolor();
char fileName[32];
for(int l = 0; l < numberOfRepeats; l++)
{
for(int k = 0; k < numberOfLabels; k++)
{
Image<pixel> *im = new Image<pixel>(width, height, true);
for(int i=0; i < height; i++)
for(int j=0; j < width; j++)
im->access[i][j] = color[images[(l * numberOfLabels + k) * height * width + i * width + j]];
strcpy(fileName, "out");
sprintf(&fileName[3], "%d-%d", l, labels[k]);
strcat(fileName, ".ppm");
savePPM(im, fileName);
}
}
}
int main(int argc, char** argv)
{
// Error code returned from openCL calls
int err;
// A, B and C arrays
float *hA = (float *)calloc(LENGTH, sizeof(float));
float *hB = (float *)calloc(LENGTH, sizeof(float));
float *hC = (float *)calloc(LENGTH, sizeof(float));
// Define the scene
const unsigned int kScreenWidth = 800;
const unsigned int kScreenHeight = 600;
float zoomFactor = -4.f;
float aliasFactor = 3.f;
size_t globalWorkSize = kScreenWidth * kScreenHeight;
size_t localWorkSize = 256;
// Colours
Vec whiteCol;
vinit(whiteCol, 8.f, 8.f, 8.f);
Vec lowerWhite;
vinit(lowerWhite, 0.5f, 0.5f, 0.5f);
Vec redCol;
vinit(redCol, 0.8f, 1.f, 0.7f);
Vec greenCol;
vinit(greenCol, 0.4f, 0.5f, 0.7f);
Vec col1;
vinit(col1, 0.01f, 0.8f, 0.01f);
// Setup materials
struct Material ballMaterial1; // White
Vec bm1Gloss; vassign(bm1Gloss, redCol);
Vec bm1Matte; vassign(bm1Matte, greenCol);
setMatOpacity(&ballMaterial1, 0.8f);
setMatteGlossBalance(&ballMaterial1, 0.2f, &bm1Matte, &bm1Gloss);
setMatRefractivityIndex(&ballMaterial1, 1.5500f);
struct Material ballMaterial2; // Red
Vec bm2Gloss; vassign(bm2Gloss, redCol);
Vec bm2Matte; vassign(bm2Matte, greenCol);
setMatOpacity(&ballMaterial2, 0.3f);
setMatteGlossBalance(&ballMaterial2, 0.95f, &bm2Matte, &bm2Gloss);
setMatRefractivityIndex(&ballMaterial2, 1.5500f);
struct Material ballMaterial3; // Red
Vec bm3Gloss; vassign(bm3Gloss, col1);
Vec bm3Matte; vassign(bm3Matte, col1);
setMatOpacity(&ballMaterial3, 0.6f);
setMatteGlossBalance(&ballMaterial3, 0.0, &bm3Matte, &bm3Gloss);
setMatRefractivityIndex(&ballMaterial3, 1.5500f);
// Setup spheres
unsigned int sphNum = 3;
struct Sphere *hSpheres =
(struct Sphere *)calloc(sphNum, sizeof(struct Sphere));
hSpheres[0].material = ballMaterial1;
vinit(hSpheres[0].pos, -9.f, 0.f, -13.f);
hSpheres[0].radius = 5.f;
hSpheres[1].material = ballMaterial2;
vinit(hSpheres[1].pos, -4.f, 1.5f, -5.f);
hSpheres[1].radius = 2.f;
hSpheres[2].material = ballMaterial3;
vinit(hSpheres[2].pos, 1.f, -1.f, -7.f);
hSpheres[2].radius = 3.f;
// Setup light sources
unsigned int lgtNum = 2;
struct Light *hLights =
(struct Light *)calloc(lgtNum, sizeof(struct Light));
vinit(hLights[0].pos, -45.f, 10.f, 85.f);
vassign(hLights[0].col, lowerWhite);
vinit(hLights[1].pos, 20.f, 60.f, -5.f);
vassign(hLights[1].col, lowerWhite);
// Fill vectors a and b with random float values
int count = LENGTH;
for (int i = 0; i < count; i++){
hA[i] = rand() / (float)RAND_MAX;
hB[i] = rand() / (float)RAND_MAX;
}
cl_uint numPlatforms;
// Find number of platforms
err = clGetPlatformIDs(0, NULL, &numPlatforms);
checkError(err, "Finding platforms");
if (numPlatforms == 0) {
printf("Found 0 platforms!\n");
return EXIT_FAILURE;
}
// Get all platforms
cl_platform_id *platform = (cl_platform_id *)malloc(sizeof(cl_platform_id)* numPlatforms);
err = clGetPlatformIDs(numPlatforms, platform, NULL);
checkError(err, "Getting platforms");
// Define an ID for the device
cl_device_id deviceId = 0;
// Secure a GPU
for (int i = 0; i < numPlatforms; i++) {
err = clGetDeviceIDs(platform[i], CL_DEVICE_TYPE_GPU, 1, &deviceId, NULL);
if (err == CL_SUCCESS) {
break;
}
}
// Once a device has been obtained, print out its info
err = output_device_info(deviceId);
checkError(err, "Printing device output");
// Create a context for the GPU
cl_context gpuContext;
gpuContext = clCreateContext(NULL, 1, &deviceId, NULL, NULL, &err);
checkError(err, "Creating context");
// Create a command queue
cl_command_queue commandsGPU;
commandsGPU = clCreateCommandQueue(gpuContext, deviceId, NULL, &err);
checkError(err, "Creating command queue");
// Load the kernel code
std::ifstream sourceFstream("raytrace_kernel.cl");
std::string source((std::istreambuf_iterator<char>(sourceFstream)),
std::istreambuf_iterator<char>());
// Create a program from the source
const char* str = source.c_str();
cl_program program;
program = clCreateProgramWithSource(gpuContext, 1, &str, NULL, &err);
checkError(err, "Creating program");
// Compile the program
err = clBuildProgram(program, 0, NULL, "-I C:\Drive\Alberto\Projects\Code\C++\raytracer_gamma\raytracer_gamma", NULL, NULL);
// If there were compilation errors
if (err != CL_SUCCESS) {
// Print out compilation log
size_t len;
char buffer[2048];
printf("Error: Failed to build program executable!\n%s\n", err_code(err));
clGetProgramBuildInfo(program, deviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
// Exit
return EXIT_FAILURE;
}
// Create the kernel
cl_kernel koRTG;
koRTG = clCreateKernel(program, "raytrace", &err);
checkError(err, "Creating kernel");
// Create the list of spheres and lights in device memory
cl_mem dSpheres = clCreateBuffer(gpuContext, CL_MEM_READ_WRITE,
sizeof(struct Sphere) * sphNum, NULL, &err);
checkError(err, "Creating buffer for spheres");
cl_mem dLights = clCreateBuffer(gpuContext, CL_MEM_READ_WRITE,
sizeof(struct Light) * lgtNum, NULL, &err);
checkError(err, "Creating buffer for lights");
cl_mem dPixelBuffer = clCreateBuffer(gpuContext, CL_MEM_WRITE_ONLY,
kScreenWidth * kScreenHeight * sizeof(Vec), NULL, &err);
checkError(err, "Creating buffer for pixels");
// Write data from host into device memory (fill the buffers with
// the host arrays)
err = clEnqueueWriteBuffer(commandsGPU, dSpheres, CL_TRUE, 0,
sizeof(struct Sphere) * sphNum, hSpheres, 0, NULL, NULL);
checkError(err, "Copying hSperes in dSpheres");
err = clEnqueueWriteBuffer(commandsGPU, dLights, CL_TRUE, 0,
sizeof(struct Light) * lgtNum, hLights, 0, NULL, NULL);
checkError(err, "Copying hLights into dLights");
cl_int status;
cl_uint maxDims;
cl_event events[2];
size_t maxWorkGroupSize;
/**
* Query device capabilities. Maximum
* work item dimensions and the maximmum
* work item sizes
*/
status = clGetDeviceInfo(
deviceId,
CL_DEVICE_MAX_WORK_GROUP_SIZE,
sizeof(size_t),
(void*)&maxWorkGroupSize,
NULL);
if (status != CL_SUCCESS)
{
fprintf(stderr, "Error: Getting Device Info. (clGetDeviceInfo)\n");
return 1;
}
status = clGetDeviceInfo(
deviceId,
CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
sizeof(cl_uint),
(void*)&maxDims,
NULL);
if (status != CL_SUCCESS)
{
fprintf(stderr, "Error: Getting Device Info. (clGetDeviceInfo)\n");
return 1;
}
localWorkSize = maxWorkGroupSize;
if (globalWorkSize % localWorkSize != 0) {
globalWorkSize = (globalWorkSize / localWorkSize + 1) * localWorkSize;
}
// Set kernel arguments
err = clSetKernelArg(koRTG, 0, sizeof(cl_mem), &dSpheres);
err |= clSetKernelArg(koRTG, 1, sizeof(unsigned int), &sphNum);
err |= clSetKernelArg(koRTG, 2, sizeof(cl_mem), &dLights);
err |= clSetKernelArg(koRTG, 3, sizeof(unsigned int), &lgtNum);
err |= clSetKernelArg(koRTG, 4, sizeof(unsigned int), &kScreenWidth);
err |= clSetKernelArg(koRTG, 5, sizeof(unsigned int), &kScreenHeight);
err |= clSetKernelArg(koRTG, 6, sizeof(float), &zoomFactor);
err |= clSetKernelArg(koRTG, 7, sizeof(float), &aliasFactor);
err |= clSetKernelArg(koRTG, 8, sizeof(cl_mem), &dPixelBuffer);
err |= clSetKernelArg(koRTG, 9, sizeof(struct Sphere) * sphNum, NULL);
err |= clSetKernelArg(koRTG, 10, sizeof(struct Light) * lgtNum, NULL);
checkError(err, "Setting kernel arguments");
// Start counting the time between kernel enqueuing and completion
std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
// Execute the kernel over the entire range of our 1d input data set
// letting the OpenCL runtime choose the work-group size
err = clEnqueueNDRangeKernel(commandsGPU, koRTG, 1, NULL,
&globalWorkSize, &localWorkSize, 0, NULL, NULL);
checkError(err, "Enqueueing kernel");
// Wait for the commands in the queue to be executed
err = clFinish(commandsGPU);
checkError(err, "Waiting for commands to finish");
// Read the time after the kernel has executed
std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
// Compute the duration
double kernelExecTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
// Print the duration
printf("Exec time: %.5f ms", kernelExecTime);
// Image
//float *imagePtr = (float *)malloc(globalWorkSize * sizeof(Vec));
//// Screen in world coordinates
//const float kImageWorldWidth = 16.f;
//const float kImageWorldHeight = 12.f;
//// Amount to increase each step for the ray direction
//const float kRayXStep = kImageWorldWidth / ((float)kScreenWidth);
//const float kRayYStep = kImageWorldHeight / ((float)kScreenHeight);
//const float aspectRatio = kImageWorldWidth / kImageWorldHeight;
//// Variables holding the current step in world coordinates
//float rayX = 0.f, rayY = 0.f;
//int pixelsCounter = 0;
//// Calculate size of an alias step in world coordinates
//const float kAliasFactorStepInv = kRayXStep / aliasFactor;
//// Calculate total size of samples to be taken
//const float kSamplesTot = aliasFactor * aliasFactor;
//// Also its inverse
//const float kSamplesTotinv = 1.f / kSamplesTot;
//for (int y = 0; y < kScreenWidth * kScreenHeight; ++y, pixelsCounter += 3) {
// // Retrieve the global ID of the kernel
// const unsigned gid = y;
//
// // Calculate world position of pixel being currently worked on
// const float kPxWorldX = ((((float)(gid % kScreenWidth) -
// (kScreenWidth * 0.5f))) * kRayXStep);
// const float kPxWorldY = ((kScreenHeight *0.5f) - ((float)(gid / kScreenWidth))) * kRayYStep;
// // The ray to be shot. The vantage point (camera) is at the origin,
// // and its intensity is maximum
// struct Ray ray; vinit(ray.origin, 0.f, 0.f, 0.f); vinit(ray.intensity, 1.f, 1.f, 1.f);
// // The colour of the pixel to be computed
// Vec pixelCol = { 0.f, 0.f, 0.f };
// // Mock background material
// struct Material bgMaterial;
// Vec black; vinit(black, 0.f, 0.f, 0.f);
// setMatteGlossBalance(&bgMaterial, 0.f, &black, &black);
// setMatRefractivityIndex(&bgMaterial, 1.00f);
// // For each sample to be taken
// for (int i = 0; i < aliasFactor; ++i) {
// for (int j = 0; j < aliasFactor; ++j) {
// // Calculate the direction of the ray
// float x = (kPxWorldX + (float)(((float)j) * kAliasFactorStepInv)) * aspectRatio;
// float y = (kPxWorldY + (float)(((float)i) * kAliasFactorStepInv));
// // Set the ray's dir and normalise it
// vinit(ray.dir, x, y, zoomFactor); vnorm(ray.dir);
// // Raytrace for the current sample
// Vec currentSampleCol = rayTrace(hSpheres, sphNum, hLights, lgtNum,
// ray, bgMaterial, 0);
// vsmul(currentSampleCol, kSamplesTotinv, currentSampleCol);
// // Compute the average
// vadd(pixelCol, pixelCol, currentSampleCol);
// }
// }
// // Write result in destination buffer
// *(imagePtr + pixelsCounter) = pixelCol.x;
// *(imagePtr + pixelsCounter + 1) = pixelCol.y;
// *(imagePtr + pixelsCounter + 2) = pixelCol.z;
//}
// Create a buffer to hold the result of the computation on the device
Vec *pixelsIntermediate = (Vec *)calloc(kScreenHeight * kScreenWidth, sizeof(Vec));
//Vec *pixelsIntermediate = (Vec *)(imagePtr);
// Read the results back from the device into the host
err = clEnqueueReadBuffer(commandsGPU, dPixelBuffer, CL_TRUE, 0,
kScreenWidth * kScreenHeight * sizeof(Vec), pixelsIntermediate, 0, NULL, NULL);
// If the reading operation didn't complete successfully
if (err != CL_SUCCESS) {
printf("Error: Failed to read output buffer!\n%s\n", err_code(err));
// Exit
exit(1);
}
// Calculate the maximum colour value across the whole picture
float maxColourValue = maxColourValuePixelBuffer(pixelsIntermediate,
kScreenWidth * kScreenHeight);
// Cast the buffer to the type accepted by the savePPM function
RGB *pixels = (RGB *)(pixelsIntermediate);
// Print execution time
/*rtime = wtime() - rtime;
printf("\nThe kernel ran in %lf seconds\n", rtime);*/
// Cleanup
clReleaseMemObject(dPixelBuffer);
clReleaseMemObject(dLights);
clReleaseMemObject(dSpheres);
clReleaseProgram(program);
clReleaseKernel(koRTG);
clReleaseCommandQueue(commandsGPU);
clReleaseContext(gpuContext);
// ... Also on host
free(hLights);
free(hSpheres);
free(hA);
free(hB);
free(hC);
free(platform);
// Try to save a PPM picture
savePPM(pixels, "testPPM.ppm", kScreenWidth, kScreenHeight, maxColourValue);
free(pixelsIntermediate);
//free(imagePtr);
getchar();
return 0;
}
int main(int argc, char **argv) {
if (argc != 5) {
fprintf(stderr, "usage: %s input (without .ppm) output (without .ppm) nbimages ratio \n", argv[0]);
return 1;
}
// (1) variables declarations
char * imname = new char[100];
char * outname = new char[100];
char * appel = new char[1000];
// (2) reading arguments
int nb_images = atoi(argv[3]);
int start=1;
int i;
sprintf(imname, "%s0%004d.ppm", argv[1], start);
sprintf(outname, "%s0%004d.ppm", argv[2], start);
float ratio = atof(argv[4]);
printf("%s\n",imname);
image<rgb> *input;
// (3) loading first image
printf("loading input image.\n");
input = loadPPM(imname);
int width = input->width();
int height = input->height();
int N = width*height;
image<rgb> *output= new image<rgb>((int)(width/ratio), (int)(height/ratio));
for (i=start;i<=nb_images;i++) {
sprintf(imname, "%s0%004d.ppm",argv[1], i);
sprintf(outname, "%s0%004d.ppm",argv[2], i);
input = loadPPM(imname);
int moy_r, moy_g, moy_b, norm;
for (int y = 0; y < height/2; y++) {
for (int x = 0; x < width/2; x++) {
moy_r = imRef(input, x*2,y*2).r;
moy_g = imRef(input, x*2,y*2).g;
moy_b = imRef(input, x*2,y*2).b;
norm = 1;
if (x*2+1<width) {
moy_r += imRef(input, x*2+1,y*2).r;
moy_g += imRef(input, x*2+1,y*2).g;
moy_b += imRef(input, x*2+1,y*2).b;
norm++;}
if (y*2+1<height) {
moy_r += imRef(input, x*2,y*2+1).r;
moy_g += imRef(input, x*2,y*2+1).g;
moy_b += imRef(input, x*2,y*2+1).b;
norm++;}
if ((x*2+1<width) && (y*2+1<height)) {
moy_r += imRef(input, x*2+1,y*2+1).r;
moy_g += imRef(input, x*2+1,y*2+1).g;
moy_b += imRef(input, x*2+1,y*2+1).b;
norm++; }
imRef(output, x,y).r = moy_r/norm;
imRef(output, x,y).g = moy_g/norm;
imRef(output, x,y).b = moy_b/norm;
}
}
savePPM(output, outname);
}
printf("done.\n");
return 0;
}
int main(int argc, char **argv) {
if (argc != 10) {
fprintf(stderr, "usage: %s sigma k min input output doPreprocess(0/1) doPostprocess(0/1) sort(s/c/f) rgb(0/1)\n", argv[0]);
fprintf(stderr, " input: portable pixelmap (uncompressed) \n");
fprintf(stderr, " output: portable pixelmap (uncompressed)\n");
fprintf(stderr, " doPreprocess: 0 - without preprocess, 1 - with preprocess\n");
fprintf(stderr, " sort: s - std::sort\n");
fprintf(stderr, " csf - parallel counting sort (round)\n");
fprintf(stderr, " csr - parallel counting sort (floor)\n");
fprintf(stderr, " rgb: 1 - RGB image, 0 - Gray-level (8 bit) images.\n");
fprintf(stderr, "example: 0.5 500 20 dragon.ppm dragonOut.ppm 1 1 csr 1 \n");
return 1;
//example: 0.5 500 20 d:\testImgs\001_test.ppm d:\out001.ppm 1 1 csr 1
}
EtTimer tmr;
float sigma = (float)atof(argv[1]);
float c = (float)atof(argv[2]);
int minSize = atoi(argv[3]);
bool preProcess = argv[6][0] == '1';
bool postProcess = argv[7][0] == '1';
bool rgbProcess = argv[9][0] == '1';
image<rgb> *input = loadPPM(argv[4]);
image<rgb> *res = new image<rgb>( input->width(), input->height());
if( rgbProcess ){
tmr.start();
EtGcSegmentRgb* segmenter = new EtGcSegmentRgb(input->width(), input->height(), preProcess, postProcess, 3 );
tmr.stop();
std::cout << input->width() << " " << input->height() << " Inicialization " << tmr.getElapsedTime() << std::endl;
tmr.start();
segmenter->segment(input, res, sigma, c, minSize, argv[8]);
tmr.stop();
std::cout << res->width() << " " << res->height() << " Full " << tmr.getElapsedTime() << std::endl;
savePPM(res, argv[5]);
}
else{
tmr.start();
EtGcSegmentGray* segmenterG = new EtGcSegmentGray(input->width(), input->height(), preProcess, postProcess, 3 );
image<uchar>* gray = imageRGBtoGRAY(input);
tmr.stop();
std::cout << input->width() << " " << input->height() << " Inicialization " << tmr.getElapsedTime() << std::endl;
tmr.start();
segmenterG->segment(gray, res, sigma, c, minSize, argv[8]);
tmr.stop();
std::cout << res->width() << " " << res->height() << " Full " << tmr.getElapsedTime() << std::endl;
savePPM(res, argv[5]);
}
return 0;
}
int main(int argc, char **argv)
{
if(argc<5)
{
printf("Usage : test <yuv image file> <image width> <image height> <output template filename>\n");
return 1;
}
const int iteration_number = 100;
printf("Time will be measured in each configuration for %d iterations...\n", iteration_number);
const char *filename = argv[1];
uint32_t width = atoi(argv[2]), height = atoi(argv[3]);
const char *out = argv[4];
char *out_filename = malloc(strlen(out)+15);
uint8_t *YUV;
if(readRawYUV(filename, width, height, &YUV)!=0)
{
printf("Error reading image file, check that the file exists and has the correct format and resolution\n");
return 1;
}
uint8_t *Y = YUV, *U = YUV+width*height, *V = YUV+width*height+((width+1)/2)*((height+1)/2);
uint8_t *RGB = malloc(3*width*height);
//std version
{
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
yuv420_rgb24_std(width, height, Y, U, V, width, (width+1)/2, RGB, width*3, YCBCR_601);
t = clock()-t;
printf("Processing time (standard) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_std.ppm");
savePPM(out_filename, width, height, RGB, 3*width);
}
//sse2 unaligned version
{
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
yuv420_rgb24_sseu(width, height, Y, U, V, width, (width+1)/2, RGB, width*3, YCBCR_601);
t = clock()-t;
printf("Processing time (sse2) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_sse.ppm");
savePPM(out_filename, width, height, RGB, 3*width);
}
// ffmpeg version
{
struct SwsContext * ctx = sws_getContext(width, height, AV_PIX_FMT_YUV420P,
width, height, AV_PIX_FMT_RGB24,
0, 0, 0, 0);
const uint8_t *const inData[3] = { Y, U, V };
int inLinesize[3] = { width, (width+1)/2, (width+1)/2 };
int outLinesize[1] = { 3*width};
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
sws_scale(ctx, inData, inLinesize, 0, height, &RGB, outLinesize);
t = clock()-t;
printf("Processing time (ffmpeg) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_av.ppm");
savePPM(out_filename, width, height, RGB, 3*width);
}
#if USE_IPP
// ipp version
{
const Ipp8u* pSrc[3] = {Y,U,V};
int srcStep[3] = {width, (width+1)/2, (width+1)/2};
Ipp8u* pDst = RGB;
int dstStep = 3*width;
IppiSize imgSize = {.width=width, .height=height};
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
ippiYCbCr420ToRGB_8u_P3C3R(pSrc, srcStep, pDst, dstStep, imgSize);
t = clock()-t;
printf("Processing time (ipp) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_ipp.ppm");
savePPM(out_filename, width, height, RGB, 3*width);
}
#endif
free(RGB);
// now test with aligned data ...
const size_t y_stride = width + (16-width%16)%16,
uv_stride = (width+1)/2 + (16-((width+1)/2)%16)%16,
rgb_stride = width*3 +(16-(3*width)%16)%16;
const size_t y_size = y_stride*height, uv_size = uv_stride*((height+1)/2);
uint8_t *Ya = _mm_malloc(y_size, 16);
uint8_t *Ua = _mm_malloc(uv_size, 16);
uint8_t *Va = _mm_malloc(uv_size, 16);
for(unsigned int i=0; i<height; ++i)
{
memcpy(Ya+i*y_stride, Y+i*width, width);
if((i%2)==0)
{
memcpy(Ua+(i/2)*uv_stride, U+(i/2)*((width+1)/2), (width+1)/2);
memcpy(Va+(i/2)*uv_stride, V+(i/2)*((width+1)/2), (width+1)/2);
}
}
RGB = _mm_malloc(3*rgb_stride*height, 16);
//sse2 aligned version
{
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
yuv420_rgb24_sse(width, height, Ya, Ua, Va, y_stride, uv_stride, RGB, rgb_stride, YCBCR_601);
t = clock()-t;
printf("Processing time (sse2 aligned) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_sse_a.ppm");
savePPM(out_filename, width, height, RGB, rgb_stride);
}
// ffmpeg aligned version
{
struct SwsContext * ctx = sws_getContext(width, height, AV_PIX_FMT_YUV420P,
width, height, AV_PIX_FMT_RGB24,
0, 0, 0, 0);
const uint8_t *const inData[3] = { Ya, Ua, Va };
int inLinesize[3] = { y_stride, uv_stride, uv_stride};
int outLinesize[1] = {rgb_stride};
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
sws_scale(ctx, inData, inLinesize, 0, height, &RGB, outLinesize);
t = clock()-t;
printf("Processing time (ffmpeg aligned) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_av_a.ppm");
savePPM(out_filename, width, height, RGB, rgb_stride);
}
#if USE_IPP
// ipp aligned version
{
const Ipp8u* pSrc[3] = {Ya,Ua,Va};
int srcStep[3] = {y_stride, uv_stride, uv_stride};
Ipp8u* pDst = RGB;
int dstStep = rgb_stride;
IppiSize imgSize = {.width=width, .height=height};
clock_t t = clock();
for(int i=0;i<iteration_number; ++i)
ippiYCbCr420ToRGB_8u_P3C3R(pSrc, srcStep, pDst, dstStep, imgSize);
t = clock()-t;
printf("Processing time (ipp aligned) : %f sec\n", ((float)t)/CLOCKS_PER_SEC);
strcpy(out_filename, out);
strcat(out_filename, "_ipp_a.ppm");
savePPM(out_filename, width, height, RGB, rgb_stride);
}
#endif
_mm_free(RGB);
_mm_free(Va);
_mm_free(Ua);
_mm_free(Ya);
free(YUV);
free(out_filename);
return 0;
}
int main(int argc, char **argv) {
if (argc < 6) {
fprintf(stderr, "usage: %s nbimages ratio_horizontal ratio_vertical input1 (without .ppm) input2 (without .ppm) \n", argv[0]);
return 1;
}
// (1) variables declarations
char * imname = new char[100];
char * imname2 = new char[100];
char * outname = new char[100];
char * appel = new char[1000];
// (2) reading arguments
int nb_images = atoi(argv[1]);
int start=1;
int i;
sprintf(imname, "%s0%004d.ppm", argv[4], start);
sprintf(imname2, "%s0%004d.ppm", argv[5], start);
int ratio_horizontal = atoi(argv[2]);
int ratio_vertical = atoi(argv[3]);
printf("%s\n",imname);
image<rgb> *input; image<rgb> *input2;
// (3) loading first image
printf("loading input image.\n");
input = loadPPM(imname);
int width = input->width();
int height = input->height();
int N = width*height;
image<rgb> *big = new image<rgb>(width*ratio_horizontal, height*ratio_vertical);
for (i=start;i<=nb_images;i++) {
sprintf(imname, "%s0%004d.ppm",argv[4], i);
sprintf(imname2, "%s0%004d.ppm",argv[5], i);
sprintf(outname, "%sout-0%004d.ppm", argv[5], i);
input = loadPPM(imname);
input2 = loadPPM(imname2);
if(ratio_vertical==2){
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(big,x,y) = imRef(input, x,y);
imRef(big,x,y+height) = imRef(input2, x,y);
}
}
}
else if(ratio_horizontal==2){
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(big,x,y) = imRef(input, x,y);
imRef(big,x+width,y) = imRef(input2, x,y);
}
}
}
savePPM(big, outname);
sprintf(appel, "convert %s %s.png ;", outname, outname );
system(appel);
}
printf("done.\n");
return 0;
}
int main(int argc, char** argv) {
if (argc != 11) {
printf("%s c c_reg min sigma hie_num start_fr end_fr input output\n", argv[0]);
printf(" c --> value for the threshold function in over-segmentation\n");
printf(" c_reg --> value for the threshold function in hierarchical region segmentation\n");
printf(" min --> enforced minimum supervoxel size\n");
printf(" sigma --> variance of the Gaussian smoothing.\n");
printf(" range --> number of frames as one subsequence (k in the paper)\n");
printf(" hie_num --> desired number of hierarchy levels\n");
printf(" start_fr --> starting frame index\n");
printf(" end_fr --> end frame index\n");
printf(" input --> input path of ppm video frames\n");
printf(" output --> output path of segmentation results\n");
return 1;
}
// Read Parameters
float c = (float)atof(argv[1]);
float c_reg = (float)atof(argv[2]);
int min_size = atoi(argv[3]);
float sigma = (float)atof(argv[4]);
int range = atoi(argv[5]);
int hie_num = atoi(argv[6]);
int start_frame_num = atoi(argv[7]);
int end_frame_num = atoi(argv[8]);
char* input_path = argv[9];
char* output_path = argv[10];
if (c <= 0 || c_reg < 0 || min_size < 0 || sigma < 0 || hie_num < 0) {
fprintf(stderr, "Unable to use the input parameters.");
return 1;
}
//subarna: optical flow
double alpha = 0.012;
double ratio = 0.75;
int minWidth = 20;
int nOuterFPIterations = 7;
int nInnerFPIterations = 1;
int nSORIterations = 30;
// count files in the input directory
/*int frame_num = 0;
struct dirent* pDirent;
DIR* pDir;
pDir = opendir(input_path);
if (pDir != NULL) {
while ((pDirent = readdir(pDir)) != NULL) {
int len = strlen(pDirent->d_name);
if (len >= 4) {
if (strcmp(".ppm", &(pDirent->d_name[len - 4])) == 0)
frame_num++;
}
}
}
//http://msdn.microsoft.com/en-us/library/windows/desktop/aa365200%28v=vs.85%29.aspx
if (frame_num == 0) {
fprintf(stderr, "Unable to find video frames at %s", input_path);
return 1;
}
printf("Total number of frames in fold is %d\n", frame_num);
// check if the range is right
if (range > frame_num)
range = frame_num;
if (range < 1)
range = 1;
*/
// check if the range is right
if (range > (end_frame_num - start_frame_num))
range = (end_frame_num - start_frame_num);
if (range < 1)
range = 1;
# ifdef USE_OPTICAL_FLOW
if (range < 2)
{
range = 2;
printf("range value should at least be 2 if motion values are to be used\n");
printf("making the range value 2");
if ( (end_frame_num - start_frame_num) < 2 )
{
printf("\n Not enough frames ... exiting\n\n\n\n");
exit(1);
}
}
# endif
// make the output directory
struct stat st;
int status = 0;
char savepath[1024];
sprintf(savepath, "%s",output_path);
if (stat(savepath, &st) != 0) {
/* Directory does not exist */
if (mkdir(savepath/*, S_IRWXU*/) != 0) {
status = -1;
}
}
for (int i = 0; i <= hie_num; i++) {
sprintf(savepath, "%s/%02d",output_path,i);
if (stat(savepath, &st) != 0) {
/* Directory does not exist */
if (_mkdir(savepath/*, S_IRWXU*/) != 0) { //subarna: _mkdir
status = -1;
}
}
}
if (status == -1) {
fprintf(stderr,"Unable to create the output directories at %s",output_path);
return 1;
}
// Initialize Parameters
int last_clip = (end_frame_num - start_frame_num + 1) % range;
int num_clip = (end_frame_num - start_frame_num + 1) / range;
char filepath[1024];
universe** u = new universe*[num_clip + 1];
image<rgb>** input_first = new image<rgb>*[range];
image<rgb>** input_middle = new image<rgb>*[range + 1];
image<rgb>** input_last = new image<rgb>*[last_clip + 1];
//subarna
# ifdef LUV
DImage** input_first_LUV = new DImage*[range];
DImage** input_middle_LUV = new DImage*[range+1];
DImage** input_last_LUV = new DImage*[last_clip+1];
# endif
// Time Recorder
time_t Start_t, End_t;
int time_task;
Start_t = time(NULL);
int height, width;
// clip 1
//calculate pair-wise optical flow
//initialize memory and first frame
printf("processing subsequence -- 0\n");
for (int j = 0; j < range; j++) {
sprintf(filepath, "%s/%05d.ppm", input_path, j + 1+ start_frame_num);
input_first[j] = loadPPM(filepath);
printf("load --> %s\n", filepath);
if (j == 0 )
{
height = input_first[0]->height();
width = input_first[0]->width();
}
# ifdef LUV
input_first_LUV[j] = new DImage (width, height,3);
int m = 0;
//convert to LUV and then apply bilateral filter
for (int s = 0; s < height*width; s++)
{
double x1,y1,z1;
double x2,y2,z2;
ccRGBtoXYZ(input_first[j]->data[s].r, input_first[j]->data[s].g, input_first[j]->data[s].b, &x1, &y1, &z1);
ccXYZtoCIE_Luv(x1, y1, z1, &x2, &y2, &z2);
input_first_LUV[j]->pData[m] = x2,
input_first_LUV[j]->pData[m+1] = y2,
input_first_LUV[j]->pData[m+2] = z2;
m = m+3;
}
// pass input_first_LUV
# endif
}
#ifdef USE_OPTICAL_FLOW
DImage** D_vx_motion_first = new DImage*[range];
DImage** D_vx_motion_middle = new DImage*[range + 1];
DImage** D_vx_motion_last = new DImage*[last_clip + 1];
DImage** D_vy_motion_first = new DImage*[range];
DImage** D_vy_motion_middle = new DImage*[range + 1];
DImage** D_vy_motion_last = new DImage*[last_clip + 1];
# endif
# ifdef USE_OPTICAL_FLOW
DImage** D_input_first = new DImage*[range];
DImage** D_input_middle = new DImage*[range + 1];
DImage** D_input_last = new DImage*[last_clip + 1];
for (int i = 0; i < range; i++ )
{
D_input_first[i] = new DImage(width,height,3);
D_vx_motion_first[i] = new DImage (width,height);
D_vy_motion_first[i] = new DImage (width,height);
}
image<rgb>* motion_buffer = NULL;
DImage* D_motion_buffer = new DImage(width,height,3);
//initialize
int m = 0;
int m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_first[0]->pData[m1] = input_first[0]->data[m].r;
D_input_first[0]->pData[m1+1] = input_first[0]->data[m].g;
D_input_first[0]->pData[m1+2] = input_first[0]->data[m].b;
m++;
m1=m1+3;
}
}
D_input_first[0]->im2double();
for (int j = 0; j < range-1; j++) {
// initialization for consecutive frames
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_first[j+1]->pData[m1] = input_first[j+1]->data[m].r;
D_input_first[j+1]->pData[m1+1] = input_first[j+1]->data[m].g;
D_input_first[j+1]->pData[m1+2] = input_first[j+1]->data[m].b;
m++;
m1=m1+3;
}
}
D_input_first[j+1]->im2double();
OpticalFlow::Coarse2FineTwoFrames(*D_input_first[j], *D_input_first[j+1], &D_vx_motion_first[j], &D_vy_motion_first[j], alpha,ratio,minWidth,nOuterFPIterations,nInnerFPIterations,nSORIterations);
# ifdef DUMP_FLOW
//debug: to be deleted
image<rgb>* test_out = new image<rgb>(width, height);
int m = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
//test_out->data[m].r = ((int)(fabs(D_vx_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].g = ((int)(fabs(D_vy_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].b = 0 ; //test_out->data[m].r;
test_out->data[m].r = 50 + 30*((int)(fabs(D_vx_motion_first[j]->pData[m])));
test_out->data[m].g = 50 + 30*((int)(fabs(D_vy_motion_first[j]->pData[m])));
test_out->data[m].b = 0 ; //test_out->data[m].r;
m++;
}
}
sprintf(filepath,"%s/motion/%05d.ppm",output_path, j + 1+ start_frame_num);
savePPM(test_out, filepath); //"out_test/test1.ppm"
delete test_out;
# endif
}
delete input_first[0];
sprintf(filepath, "%s/%05d.ppm", input_path, range +1 + start_frame_num);
input_first[0] = loadPPM(filepath);
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_motion_buffer->pData[m1] = input_first[0]->data[m].r;
D_motion_buffer->pData[m1+1] = input_first[0]->data[m].g;
D_motion_buffer->pData[m1+2] = input_first[0]->data[m].b;
m++;
m1=m1+3;
}
}
// dummy place holder
D_motion_buffer->im2double();
OpticalFlow::Coarse2FineTwoFrames(*D_input_first[range-2], *D_motion_buffer, &D_vx_motion_first[range-1], &D_vy_motion_first[range-1], alpha,ratio,minWidth,nOuterFPIterations,nInnerFPIterations,nSORIterations);
# if 0
//copy content from D_motion_first[j-1] to D_motion_first[range-1]
D_vx_motion_first[range-1]->copyData(*D_vx_motion_first[range-2]);
D_vy_motion_first[range-1]->copyData(*D_vy_motion_first[range-2]);
# endif
///////////////////////////////////////
# endif
# ifdef USE_OPTICAL_FLOW
// frame index starts from 0
# ifndef LUV
u[0] = segment_image(output_path, input_first, D_vx_motion_first, D_vy_motion_first, 0, range - 1, c, c_reg, min_size,
sigma, hie_num, NULL,start_frame_num);
# else
u[0] = segment_image_LUV(output_path, input_first_LUV, D_vx_motion_first, D_vy_motion_first, 0, range - 1, c, c_reg, min_size,
sigma, hie_num, NULL,start_frame_num);
# endif
# else
// frame index starts from 0
# ifndef LUV
u[0] = segment_image(output_path, input_first,0, range - 1, c, c_reg, min_size,
sigma, hie_num, NULL,start_frame_num);
# else
u[0] = segment_image_LUV(output_path, input_first_LUV, 0, range - 1, c, c_reg, min_size,
sigma, hie_num, NULL,start_frame_num);
# endif
# endif
for (int j = 0; j < range; j++) {
delete input_first[j];
# ifdef LUV
delete input_first_LUV[j];
# endif
}
# ifdef USE_OPTICAL_FLOW //subarna
for (int j = 0; j < range; j++) {
delete D_vx_motion_first[j];
delete D_vy_motion_first[j];
delete D_input_first[j];
}
# endif
// clip 2 -- last
int ii;
for (ii = 1; ii < num_clip; ii++)
{
printf("processing subsequence -- %d\n", ii);
for (int j = 0; j < range + 1; j++)
{
sprintf(filepath, "%s/%05d.ppm", input_path, ii * range + j + start_frame_num);
input_middle[j] = loadPPM(filepath);
printf("load --> %s\n", filepath);
# ifdef LUV
input_middle_LUV[j] = new DImage (width, height,3);
int m = 0;
//convert to LUV and then apply bilateral filter
for (int s = 0; s < height*width; s++)
{
double x1,y1,z1;
double x2,y2,z2;
ccRGBtoXYZ(input_middle[j]->data[s].r, input_middle[j]->data[s].g, input_middle[j]->data[s].b, &x1, &y1, &z1);
ccXYZtoCIE_Luv(x1, y1, z1, &x2, &y2, &z2);
input_middle_LUV[j]->pData[m] = x2,
input_middle_LUV[j]->pData[m+1] = y2,
input_middle_LUV[j]->pData[m+2] = z2;
m = m+3;
}
//pass input_middle_LUV
# endif
}
# ifdef USE_OPTICAL_FLOW
for (int i = 0; i < range+1; i++ )
{
D_input_middle[i] = new DImage(width,height,3);
D_vx_motion_middle[i] = new DImage(width,height);
D_vy_motion_middle[i] = new DImage(width,height);
}
//initialize
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_middle[0]->pData[m1] = input_middle[0]->data[m].r;
D_input_middle[0]->pData[m1+1] = input_middle[0]->data[m].g;
D_input_middle[0]->pData[m1+2] = input_middle[0]->data[m].b;
m++;
m1=m1+3;
}
}
D_input_middle[0]->im2double();
//calculate pair-wise optical flow
for (int j = 0; j < range; j++) {
// initialization for consecutive frames
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_middle[j+1]->pData[m1] = input_middle[j+1]->data[m].r;
D_input_middle[j+1]->pData[m1+1] = input_middle[j+1]->data[m].g;
D_input_middle[j+1]->pData[m1+2] = input_middle[j+1]->data[m].b;
m++;
m1 =m1+3;
}
}
D_input_middle[j+1]->im2double();
OpticalFlow::Coarse2FineTwoFrames(*D_input_middle[j], *D_input_middle[j+1], &D_vx_motion_middle[j], &D_vy_motion_middle[j], alpha,ratio,minWidth,nOuterFPIterations,nInnerFPIterations,nSORIterations);
# ifdef DUMP_FLOW
//debug: to be deleted
image<rgb>* test_out = new image<rgb>(width, height);
int m = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
//test_out->data[m].r = ((int)(fabs(D_vx_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].g = ((int)(fabs(D_vy_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].b = 0 ; //test_out->data[m].r;
test_out->data[m].r = 50 + 40*((int)(fabs(D_vx_motion_middle[j]->pData[m])));
test_out->data[m].g = 50 + 40*((int)(fabs(D_vx_motion_middle[j]->pData[m])));
test_out->data[m].b = 0 ; //test_out->data[m].r;
m++;
}
}
sprintf(filepath,"%s/motion/%05d.ppm",output_path, i * range + j + start_frame_num);
savePPM(test_out, filepath); //"out_test/test1.ppm"
delete test_out;
# endif
}
// subarna: fix crash for specific frame number case
if ( (ii == num_clip - 1 ) && (last_clip == 0) )
{
// for the last frame motion feature -- copy feature value from last frame, but with opposite sign
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
D_vx_motion_middle[range]->pData[i*width + j] = -D_vx_motion_middle[range-1]->pData[i*width + j];
D_vy_motion_middle[range]->pData[i*width + j] = -D_vy_motion_middle[range-1]->pData[i*width + j];
}
}
}
else
{
delete input_middle[0];
sprintf(filepath, "%s/%05d.ppm", input_path, (ii+1) * range +1 + start_frame_num);
input_middle[0] = loadPPM(filepath);
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_motion_buffer->pData[m1] = input_middle[0]->data[m].r;
D_motion_buffer->pData[m1+1] = input_middle[0]->data[m].g;
D_motion_buffer->pData[m1+2] = input_middle[0]->data[m].b;
m++;
m1=m1+3;
}
}
// dummy place holder
D_motion_buffer->im2double();
OpticalFlow::Coarse2FineTwoFrames(*D_input_middle[range], *D_motion_buffer, &D_vx_motion_middle[range], &D_vy_motion_middle[range], alpha,ratio,minWidth,nOuterFPIterations,nInnerFPIterations,nSORIterations);
/////////////////////////////////////
}
# endif
# ifdef USE_OPTICAL_FLOW
# ifndef LUV
u[ii] = segment_image(output_path, input_middle, D_vx_motion_middle, D_vy_motion_middle, ii * range - 1,
ii * range + range - 1, c, c_reg, min_size, sigma, hie_num,
u[ii - 1], start_frame_num);
# else
u[ii] = segment_image_LUV(output_path, input_middle_LUV, D_vx_motion_middle, D_vy_motion_middle, ii * range - 1,
ii * range + range - 1, c, c_reg, min_size, sigma, hie_num,
u[ii - 1],start_frame_num);
# endif
# else
# ifndef LUV
u[ii] = segment_image(output_path, input_middle, ii * range - 1,
ii * range + range - 1, c, c_reg, min_size, sigma, hie_num,
u[ii - 1], start_frame_num);
# else
u[ii] = segment_image_LUV(output_path, input_middle_LUV, ii * range - 1,
ii* range + range - 1, c, c_reg, min_size, sigma, hie_num,
u[ii - 1],start_frame_num);
# endif
# endif
if ( u[ii-1] ) delete u[ii - 1];
////////////////////
for (int j = 0; j < range + 1; j++)
{
delete input_middle[j];
# ifdef LUV
delete input_middle_LUV[j];
# endif
}
# ifdef USE_OPTICAL_FLOW
for (int j = 0; j < range + 1; j++)
{
delete D_vx_motion_middle[j];
delete D_vy_motion_middle[j];
delete D_input_middle[j];
}
# endif
}
// clip last
if (last_clip > 0) {
printf("processing subsequence -- %d\n", num_clip);
for (int j = 0; j < last_clip + 1; j++)
{
sprintf(filepath, "%s/%05d.ppm", input_path, num_clip * range + j + start_frame_num);
input_last[j] = loadPPM(filepath);
printf("load --> %s\n", filepath);
# ifdef LUV
input_last_LUV[j] = new DImage (width, height,3);
int m=0;
for (int s = 0; s < width*height; s++)
{
double x1,y1,z1;
double x2,y2,z2;
ccRGBtoXYZ(input_last[j]->data[s].r, input_last[j]->data[s].g, input_last[j]->data[s].b, &x1, &y1, &z1);
ccXYZtoCIE_Luv(x1, y1, z1, &x2, &y2, &z2);
input_last_LUV[j]->pData[m] = x2,
input_last_LUV[j]->pData[m+1] = y2,
input_last_LUV[j]->pData[m+2] = z2;
m = m+3;
}
# endif
}
# ifdef USE_OPTICAL_FLOW
//subarna
for (int i = 0; i < last_clip+1; i++ )
{
D_input_last[i] = new DImage(width,height,3);
D_vx_motion_last[i] = new DImage(width,height);
D_vy_motion_last[i] = new DImage(width,height);
}
//subarna
//initialize
m1 = 0;
m = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_last[0]->pData[m1] = input_last[0]->data[m].r;
D_input_last[0]->pData[m1+1] = input_last[0]->data[m].g;
D_input_last[0]->pData[m1+2] = input_last[0]->data[m].b;//0
m++;
m1=m1+3;
}
}
D_input_last[0]->im2double();
//calculate pair-wise optical flow
for (int j = 0; j < last_clip; j++) {
// initialization for consecutive frames
m = 0;
m1 = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
D_input_last[j+1]->pData[m1] = input_last[j+1]->data[m].r;
D_input_last[j+1]->pData[m1+1] = input_last[j+1]->data[m].g;
D_input_last[j+1]->pData[m1+2] = input_last[j+1]->data[m].b;
m++;
m1=m1+3;
}
}
D_input_last[j+1]->im2double();
OpticalFlow::Coarse2FineTwoFrames(*D_input_last[j], *D_input_last[j+1], &D_vx_motion_last[j], &D_vy_motion_last[j], alpha,ratio,minWidth,nOuterFPIterations,nInnerFPIterations,nSORIterations);
# ifdef DUMP_FLOW
//debug: to be deleted
image<rgb>* test_out = new image<rgb>(width, height);
int m = 0;
for(int k1= 0; k1 < width; k1++)
{
for (int k2 = 0; k2 < height; k2++)
{
//test_out->data[m].r = ((int)(fabs(D_vx_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].g = ((int)(fabs(D_vy_motion_first[j]->pData[m])*30)>>4)<<4;
//test_out->data[m].b = 0 ; //test_out->data[m].r;
test_out->data[m].r = 50 + 30*((int)(fabs(D_vx_motion_last[j]->pData[m])));
test_out->data[m].g = 50 + 30*((int)(fabs(D_vx_motion_last[j]->pData[m])));
test_out->data[m].b = 0 ; //test_out->data[m].r;
m++;
}
}
sprintf(filepath,"%s/motion/%05d.ppm",output_path, num_clip * range + j + start_frame_num);
savePPM(test_out, filepath); //"out_test/test1.ppm"
delete test_out;
# endif
}
// for the last frame motion feature -- copy feature value from last frame, but with opposite sign
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
D_vx_motion_last[last_clip]->pData[i*width + j] = -D_vx_motion_last[last_clip-1]->pData[i*width + j];
D_vy_motion_last[last_clip]->pData[i*width + j] = -D_vy_motion_last[last_clip-1]->pData[i*width + j];
}
}
//////////////////////////////////////
# endif
# ifdef USE_OPTICAL_FLOW
# ifndef LUV
u[num_clip] = segment_image(output_path, input_last, D_vx_motion_last,D_vy_motion_last, num_clip * range - 1,
num_clip * range + last_clip - 1, c, c_reg, min_size, sigma,
hie_num, u[num_clip - 1],start_frame_num);
# else
u[num_clip] = segment_image_LUV(output_path, input_last_LUV, D_vx_motion_last,D_vy_motion_last, num_clip * range - 1,
num_clip * range + last_clip - 1, c, c_reg, min_size, sigma,hie_num, u[num_clip - 1],start_frame_num);
# endif
# else
# ifndef LUV
u[num_clip] = segment_image(output_path, input_last,num_clip * range - 1,
num_clip * range + last_clip - 1, c, c_reg, min_size, sigma,
hie_num, u[num_clip - 1],start_frame_num);
# else
u[num_clip] = segment_image_LUV(output_path, input_last_LUV, num_clip * range - 1,
num_clip * range + last_clip - 1, c, c_reg, min_size, sigma,hie_num, u[num_clip - 1],start_frame_num);
# endif
# endif
if (u[num_clip - 1]) delete u[num_clip - 1];
delete u[num_clip];
for (int j = 0; j < last_clip + 1; j++)
{
delete input_last[j];
# ifdef LUV
delete input_last_LUV[j];
# endif
}
//subarna
# ifdef USE_OPTICAL_FLOW
for (int j = 0; j < last_clip + 1; j++) {
delete D_vx_motion_last[j];
delete D_vy_motion_last[j];
delete D_input_last[j];
}
delete(D_motion_buffer);
# endif
}
//////////////////////////////////////
# ifdef LUV
delete input_first_LUV;
delete input_middle_LUV;
delete input_last_LUV;
# endif
# ifdef USE_OPTICAL_FLOW
delete D_vx_motion_first;
delete D_vy_motion_first;
delete D_vx_motion_middle;
delete D_vy_motion_middle;
delete D_vx_motion_last;
delete D_vy_motion_last;
# endif
/////////////////////////////////////
delete[] u;
// Time Recorder
End_t = time(NULL);
time_task = difftime(End_t, Start_t);
std::ofstream myfile;
char timefile[1024];
sprintf(timefile, "%s/%s", output_path, "time.txt");
myfile.open(timefile);
myfile << time_task << endl;
myfile.close();
printf("Congratulations! It's done!\n");
printf("Time_total = %d seconds\n", time_task);
return 0;
}
