From: <st...@us...> - 2009-06-05 12:53:02
|
Revision: 3918 http://hugin.svn.sourceforge.net/hugin/?rev=3918&view=rev Author: stativ Date: 2009-06-05 12:21:00 +0000 (Fri, 05 Jun 2009) Log Message: ----------- Fixed verbosity handling. It still can't write merged files. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp Added Paths: ----------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Removed Paths: ------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.tcc Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-05 05:53:17 UTC (rev 3917) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-05 12:21:00 UTC (rev 3918) @@ -134,36 +134,36 @@ << "Valid options are:" << std::endl << " -o prefix output file" << std::endl << " -m mode merge mode, can be one of: avg, avg_slow, khan (default), if avg, no" << std::endl - << " -i, -s, or -d options apply" << std::endl - << " -i iter number of iterations to execute (default is 1)" << std::endl + << " -i, -s, or -d options apply" << std::endl + << " -i iter number of iterations to execute (default is 1)" << std::endl << " -c Only consider pixels that are defined in all images (avg mode only)" << std::endl - << " -s file debug files to save each iteration, can be one of:" << std::endl - << " a - all debug files (can only be used alone)" << std::endl - << " w - calculated weights from each iteration" << std::endl - << " r - result image from each iteration" << std::endl - << " s - source images before processing" << std::endl - << " if verbose >= 3, all debug files are output unless specified" << std::endl - << " -a calcs apply one or more advanced caculations, can be one or more of:" << std::endl - << " b - biasing weights logarithmically" << std::endl - << " c - choose pixels with heighest weight instead of averaging" << std::endl - << " (overrides options -a b and -a d)" << endl - << " d - choose a pixel with the heighest weight instead of" << endl - << " averaging when all pixel weights are within 10% of eachother" << endl - << " h - favor a high signal to noise ratio" << std::endl - << " i - ignore alpha channel" << endl - << " n - do not use luminance images for estimating initial weights" << endl - << " (bases weights on input images itself)" << endl -/* << " m - multi-scale calculation of weights" << std::endl - << " s - favor choosing from the same image" << std::endl - << " u - use joint bilateral upscaling" << std::endl - << " ex: -d hms" << std::endl -*/ << " -e export each initial weight to <input_file_paths>_iw.<ext>" << std::endl - << " -l load a previously exported initial weight with respect " << endl - << " to the input file names" << std::endl - << " NOTE: if both -e and -l options are on, the program will " << endl - << " calculate and save the initial weights, then wait " << endl - << " until user indicates that it can continue by loading " << endl - << " the previously saved weights" << endl + << " -s file debug files to save each iteration, can be one of:" << std::endl + << " a - all debug files (can only be used alone)" << std::endl + << " w - calculated weights from each iteration" << std::endl + << " r - result image from each iteration" << std::endl + << " s - source images before processing" << std::endl + << " if verbose >= 3, all debug files are output unless specified" << std::endl + << " -a calcs apply one or more advanced caculations, can be one or more of:" << std::endl + << " b - biasing weights logarithmically" << std::endl + << " c - choose pixels with heighest weight instead of averaging" << std::endl + << " (overrides options -a b and -a d)" << endl + << " d - choose a pixel with the heighest weight instead of" << endl + << " averaging when all pixel weights are within 10% of eachother" << endl + << " h - favor a high signal to noise ratio" << std::endl + << " i - ignore alpha channel" << endl + << " n - do not use luminance images for estimating initial weights" << endl + << " (bases weights on input images itself)" << endl +/* << " m - multi-scale calculation of weights" << std::endl + << " s - favor choosing from the same image" << std::endl + << " u - use joint bilateral upscaling" << std::endl + << " ex: -d hms" << std::endl +*/ << " -e export each initial weight to <input_file_paths>_iw.<ext>" << std::endl + << " -l load a previously exported initial weight with respect " << endl + << " to the input file names" << std::endl + << " NOTE: if both -e and -l options are on, the program will " << endl + << " calculate and save the initial weights, then wait " << endl + << " until user indicates that it can continue by loading " << endl + << " the previously saved weights" << endl << " -v Verbose, print progress messages, repeat for" << std::endl << " even more verbose output" << std::endl << " -h Display help (this text)" << std::endl @@ -184,10 +184,10 @@ std::string outputFile = "merged.hdr"; std::string mode = "khan"; bool onlyCompleteOverlap = false; - int num_iters = 1; - uint8_t save = 0; - uint16_t adv = 0; - uint8_t ui = 0; + int num_iters = 1; + uint8_t save = 0; + uint16_t adv = 0; + uint8_t ui = 0; string basename; while ((c = getopt (argc, argv, optstring)) != -1) { @@ -198,129 +198,129 @@ case 'c': onlyCompleteOverlap = true; break; - case 'i': - num_iters = atoi(optarg); - break; - case 'e': - ui += khanAdvModes::UI_EXPORT_INIT_WEIGHTS; - if(g_verbose > 0) - cout << "Exporting initial weights" << endl; - break; - case 'l': - ui += khanAdvModes::UI_IMPORT_INIT_WEIGHTS; - if(g_verbose > 0) - cout << "Importing initial weights" << endl; - break; - case 's': - for(char *c = optarg; *c; c++) { - switch(*c) { - case 'w': - save += khanAdvModes::SAVE_WEIGHTS; - if(g_verbose > 0) - cout << "Saving weights from each iteration" << endl; - break; - case 'r': - save += khanAdvModes::SAVE_RESULTS; - if(g_verbose > 0) - cout << "Saving results from each iteration" << endl; - break; - case 's': - save += khanAdvModes::SAVE_SOURCES; - if(g_verbose > 0) - cout << "Saving sources after loading" << endl; - break; - case 'a': - save = khanAdvModes::SAVE_ALL; - if(g_verbose > 0) - cout << "Saving all debug outputs" << endl; - break; - default: - cerr << "Invalid argument for option -s: " << *c << std::endl; - usage(argv[0]); - return 1; - } - } - break; - case 'a': - for(char *c = optarg; *c; c++) { - switch(*c) { - case 'b': - if(adv & khanAdvModes::ADV_UNAVG) { - cerr << "Cannot use b with c in option -a" << endl; - usage(argv[0]); - return 1; - } - adv += khanAdvModes::ADV_BIAS; - if(g_verbose > 0) - cout << "Applying: logarithmic bias of weights" << endl; - break; - case 'c': - if(adv & khanAdvModes::ADV_BIAS) { - cout << "Warning: overriding log bias of weights " - << "width option -a c" << endl; - adv -= khanAdvModes::ADV_BIAS; - } - if(adv & khanAdvModes::ADV_UNAVG2) { - cout << "Warning: overriding option -a d with option " - << "-a c" << endl; - adv-= khanAdvModes::ADV_UNAVG2; - } - adv += khanAdvModes::ADV_UNAVG; - if(g_verbose > 0) { - cout << "Applying: choose pixel with largest weight" << endl; - } - break; - case 'd': - if(adv & khanAdvModes::ADV_UNAVG) { - cout << "Warning: overriding option -a d with option " - << "-a c" << endl; - } - else { - adv+= khanAdvModes::ADV_UNAVG2; - cout << "Applying: choosing pixel with the largest weight " - << "when weights are similar" << endl; - } - break; - case 'h': - adv += khanAdvModes::ADV_SNR; - if(g_verbose > 0) - cout << "Applying: favoring high signal to noise ratio" - << endl; - break; - case 'i': - adv += khanAdvModes::ADV_ALPHA; - if(g_verbose > 0) - cout << "Applying: ignore alpha channel" << endl; - break; - case 'n': - adv += khanAdvModes::ADV_NOLUM; - if(g_verbose > 0) - cout << "Using input images to estimate initial weights instead of luminance" << endl; - break; -/* case 'm': - adv += ADV_MULTI; - if(g_verbose > 0) - cout << "Applying: multi-scaling" << endl; - break; - case 's': - adv += ADV_SAME; - if(g_verbose > 0) - cout << "Applying: favor choosing from the same image" << endl; - break; - case 'u': - adv += ADV_JBU; - if(g_verbose > 0) { - cout << "Applying: use joint bilateral upsampling" - << endl; - } - break; -*/ default: - cerr << "Invalid argument for option -a: " << *c << std::endl; - usage(argv[0]); - return 1; - } - } - break; + case 'i': + num_iters = atoi(optarg); + break; + case 'e': + ui += khanAdvModes::UI_EXPORT_INIT_WEIGHTS; + if(g_verbose > 0) + cout << "Exporting initial weights" << endl; + break; + case 'l': + ui += khanAdvModes::UI_IMPORT_INIT_WEIGHTS; + if(g_verbose > 0) + cout << "Importing initial weights" << endl; + break; + case 's': + for(char *c = optarg; *c; c++) { + switch(*c) { + case 'w': + save += khanAdvModes::SAVE_WEIGHTS; + if(g_verbose > 0) + cout << "Saving weights from each iteration" << endl; + break; + case 'r': + save += khanAdvModes::SAVE_RESULTS; + if(g_verbose > 0) + cout << "Saving results from each iteration" << endl; + break; + case 's': + save += khanAdvModes::SAVE_SOURCES; + if(g_verbose > 0) + cout << "Saving sources after loading" << endl; + break; + case 'a': + save = khanAdvModes::SAVE_ALL; + if(g_verbose > 0) + cout << "Saving all debug outputs" << endl; + break; + default: + cerr << "Invalid argument for option -s: " << *c << std::endl; + usage(argv[0]); + return 1; + } + } + break; + case 'a': + for(char *c = optarg; *c; c++) { + switch(*c) { + case 'b': + if(adv & khanAdvModes::ADV_UNAVG) { + cerr << "Cannot use b with c in option -a" << endl; + usage(argv[0]); + return 1; + } + adv += khanAdvModes::ADV_BIAS; + if(g_verbose > 0) + cout << "Applying: logarithmic bias of weights" << endl; + break; + case 'c': + if(adv & khanAdvModes::ADV_BIAS) { + cout << "Warning: overriding log bias of weights " + << "width option -a c" << endl; + adv -= khanAdvModes::ADV_BIAS; + } + if(adv & khanAdvModes::ADV_UNAVG2) { + cout << "Warning: overriding option -a d with option " + << "-a c" << endl; + adv-= khanAdvModes::ADV_UNAVG2; + } + adv += khanAdvModes::ADV_UNAVG; + if(g_verbose > 0) { + cout << "Applying: choose pixel with largest weight" << endl; + } + break; + case 'd': + if(adv & khanAdvModes::ADV_UNAVG) { + cout << "Warning: overriding option -a d with option " + << "-a c" << endl; + } + else { + adv+= khanAdvModes::ADV_UNAVG2; + cout << "Applying: choosing pixel with the largest weight " + << "when weights are similar" << endl; + } + break; + case 'h': + adv += khanAdvModes::ADV_SNR; + if(g_verbose > 0) + cout << "Applying: favoring high signal to noise ratio" + << endl; + break; + case 'i': + adv += khanAdvModes::ADV_ALPHA; + if(g_verbose > 0) + cout << "Applying: ignore alpha channel" << endl; + break; + case 'n': + adv += khanAdvModes::ADV_NOLUM; + if(g_verbose > 0) + cout << "Using input images to estimate initial weights instead of luminance" << endl; + break; +/* case 'm': + adv += ADV_MULTI; + if(g_verbose > 0) + cout << "Applying: multi-scaling" << endl; + break; + case 's': + adv += ADV_SAME; + if(g_verbose > 0) + cout << "Applying: favor choosing from the same image" << endl; + break; + case 'u': + adv += ADV_JBU; + if(g_verbose > 0) { + cout << "Applying: use joint bilateral upsampling" + << endl; + } + break; +*/ default: + cerr << "Invalid argument for option -a: " << *c << std::endl; + usage(argv[0]); + return 1; + } + } + break; case 'o': outputFile = optarg; break; @@ -335,12 +335,12 @@ usage(argv[0]); return 1; } - }//end while + }//end while - cout << endl; + cout << endl; - if(g_verbose > 2) - save = khanAdvModes::SAVE_ALL; + /*if(g_verbose > 2) + save = khanAdvModes::SAVE_ALL;*/ unsigned nFiles = argc - optind; if (nFiles == 0) { @@ -392,8 +392,9 @@ if (g_verbose > 0) { cout << "Running Khan algorithm" << std::endl; } + // ALREADY CHANGED - khan<weightMexicanHatFunctor<int,float> > deghoster(inputFiles, num_iters, adv, save, ui); + khan<weightMexicanHatFunctor<int,float> > deghoster(inputFiles, num_iters, adv, save, ui, g_verbose); const vector<FImagePtr> weights = deghoster.createWeightMasks(); // save output file @@ -403,9 +404,10 @@ weightedAverageOfImageFiles(inputFiles, deghoster.getWidth(), deghoster.getHeight(), weights, &output); - //ImageExportInfo exinfo(outputFile.c_str()); - //exinfo.setPixelType("FLOAT"); - //exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo); + ImageExportInfo exinfo(outputFile.c_str()); + exinfo.setPixelType("FLOAT"); + BImage mask(output.width(), output.height(), 255); + exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo); } else { std::cerr << "Unknown merge mode, see help for a list of possible modes" << std::endl; return 1; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp 2009-06-05 05:53:17 UTC (rev 3917) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.cpp 2009-06-05 12:21:00 UTC (rev 3918) @@ -43,18 +43,18 @@ * destImgs is ptr to an empty vector to be filled in */ void jointBilateralUpsampling(vector<FImagePtr> *sources, - vector<FImagePtr> *refs, - vector<FImagePtr> *destImgs, int num_neighbors) + vector<FImagePtr> *refs, + vector<FImagePtr> *destImgs, int num_neighbors) { - int num_layers = sources->size(); - bool destEmpty = destImgs->size() == 0; - for(int i = 0; i < num_layers; i++) { - FImagePtr tmp = jbuImage(sources->at(i), refs->at(i), num_neighbors); - if(!destEmpty) - destImgs->at(i) = tmp; - else - destImgs->push_back(tmp); - } + int num_layers = sources->size(); + bool destEmpty = destImgs->size() == 0; + for(int i = 0; i < num_layers; i++) { + FImagePtr tmp = jbuImage(sources->at(i), refs->at(i), num_neighbors); + if(!destEmpty) + destImgs->at(i) = tmp; + else + destImgs->push_back(tmp); + } } @@ -62,139 +62,139 @@ * creates the resulting FImagePtr and returns it */ FImagePtr jbuImage(FImagePtr source, FImagePtr refIm, int num_neighbors) -{ - int width = refIm->width(); - int height = refIm->height(); - int s_width = source->width(); - int s_height = source->height(); - float scale = s_width / width; - - FImagePtr dest = FImagePtr(new FImage(width, height)); - float sigma = 0.5; - int mu = 0; - - for(int y = 0; y < height; y++) { - float *refPixLoc = (float *)(refIm->data()) + y * width; - - if(g_verbose > 2) - cout << "y: " << y << "\n" - << "\trefPixLoc: " << hex << refPixLoc << endl; - - for(int x = 0; x < width; x++) { - float refPix = *(refPixLoc + x); - - float total_val = 0; - float normalizing_factor = 0; - - //prevent black areas fro all rgausses being 0 - float norgauss = 0; - float norgauss_normalize = 0; - - //find coords in source - float o_x = x * scale; - float o_y = y * scale; - - if(g_verbose > 2) - cout << "x: " << x << "\n" - << "\trefPixLoc+x: " << hex << refPixLoc + x << "\n" - << "\to_x: " << o_x << "\n" - << "\to_y: " << o_y << endl; - - //for each neighbor for the source - for(int j = -num_neighbors; j <= num_neighbors; j++) { - int r_y = (int)round(o_y + j); - r_y = (r_y > 0 ? (r_y < s_height ? r_y : s_height-1) : 0); - float *srcPixLoc = (float *)source->data() + r_y * s_width; - //corresponding reference pixel - float *neighborPixLoc = (float *)refIm->data() + - (int) (r_y * scale * width); - - if(g_verbose > 3) - cout << "\tj: " << j << "\n" - << "\t\tr_y: " << r_y << "\n" - << "\t\tsrcPixLoc: " << hex << srcPixLoc << "\n" - << "\t\tneighborPixLoc: " << hex << neighborPixLoc << endl; - - for(int i = -num_neighbors; i <= num_neighbors; i++) { - //find coords in source - int r_x = (int)round(o_x + i); - r_x = (r_x > 0 ? (r_x < s_width ? r_x : s_width-1) : 0); - float srcPix = *(srcPixLoc + r_x); - //in ref img - neighborPixLoc += int(r_x * scale); - float neighborPix = *neighborPixLoc; - - if(g_verbose > 3) - cout << "\ti: " << i << "\n" - << "\t\tr_x: " << r_x << "\n" - << "\t\tsrcPixLoc+r_x: " << hex << srcPixLoc + r_x << "\n" - << "\t\tsrcPix: " << srcPix << "\n" - << "\t\tneighborPixLoc: " << hex << neighborPixLoc << "\n" - << " \t\tneighborPix: " << neighborPix << endl; - - //gauss dist to center - float sgauss = simpleGauss(dist(o_x, o_y, r_x, r_y), - sigma, mu); - //gauss radiance diff to center in ref - float rgauss = simpleGauss(abs(refPix - neighborPix), - sigma, mu); - - //multiply gausses by value in source and add to total val - norgauss = srcPix * sgauss; - norgauss_normalize += sgauss; - float totalgauss = sgauss * rgauss; - normalizing_factor += totalgauss; - total_val += srcPix * totalgauss; - - if(g_verbose > 3) - cout << "\t\tsgauss: " << sgauss << "\n" - << "\t\trgauss: " << rgauss << "\n" - << "\t\ttotalgauss+srcPix: " << totalgauss + - srcPix << endl; - - } //end for i - }//end for j - - //normalize and store - - if(g_verbose > 2) - cout << "\tnormalizing_factor: " << normalizing_factor << "\n" - << "\ttotal_val(before): " << total_val << endl; +{ + int width = refIm->width(); + int height = refIm->height(); + int s_width = source->width(); + int s_height = source->height(); + float scale = s_width / width; + + FImagePtr dest = FImagePtr(new FImage(width, height)); + float sigma = 0.5; + int mu = 0; + + for(int y = 0; y < height; y++) { + float *refPixLoc = (float *)(refIm->data()) + y * width; + + if(g_verbose > 2) + cout << "y: " << y << "\n" + << "\trefPixLoc: " << hex << refPixLoc << endl; + + for(int x = 0; x < width; x++) { + float refPix = *(refPixLoc + x); + + float total_val = 0; + float normalizing_factor = 0; + + //prevent black areas fro all rgausses being 0 + float norgauss = 0; + float norgauss_normalize = 0; + + //find coords in source + float o_x = x * scale; + float o_y = y * scale; + + if(g_verbose > 2) + cout << "x: " << x << "\n" + << "\trefPixLoc+x: " << hex << refPixLoc + x << "\n" + << "\to_x: " << o_x << "\n" + << "\to_y: " << o_y << endl; + + //for each neighbor for the source + for(int j = -num_neighbors; j <= num_neighbors; j++) { + int r_y = (int)round(o_y + j); + r_y = (r_y > 0 ? (r_y < s_height ? r_y : s_height-1) : 0); + float *srcPixLoc = (float *)source->data() + r_y * s_width; + //corresponding reference pixel + float *neighborPixLoc = (float *)refIm->data() + + (int) (r_y * scale * width); + + if(g_verbose > 3) + cout << "\tj: " << j << "\n" + << "\t\tr_y: " << r_y << "\n" + << "\t\tsrcPixLoc: " << hex << srcPixLoc << "\n" + << "\t\tneighborPixLoc: " << hex << neighborPixLoc << endl; + + for(int i = -num_neighbors; i <= num_neighbors; i++) { + //find coords in source + int r_x = (int)round(o_x + i); + r_x = (r_x > 0 ? (r_x < s_width ? r_x : s_width-1) : 0); + float srcPix = *(srcPixLoc + r_x); + //in ref img + neighborPixLoc += int(r_x * scale); + float neighborPix = *neighborPixLoc; + + if(g_verbose > 3) + cout << "\ti: " << i << "\n" + << "\t\tr_x: " << r_x << "\n" + << "\t\tsrcPixLoc+r_x: " << hex << srcPixLoc + r_x << "\n" + << "\t\tsrcPix: " << srcPix << "\n" + << "\t\tneighborPixLoc: " << hex << neighborPixLoc << "\n" + << " \t\tneighborPix: " << neighborPix << endl; + + //gauss dist to center + float sgauss = simpleGauss(dist(o_x, o_y, r_x, r_y), + sigma, mu); + //gauss radiance diff to center in ref + float rgauss = simpleGauss(abs(refPix - neighborPix), + sigma, mu); + + //multiply gausses by value in source and add to total val + norgauss = srcPix * sgauss; + norgauss_normalize += sgauss; + float totalgauss = sgauss * rgauss; + normalizing_factor += totalgauss; + total_val += srcPix * totalgauss; + + if(g_verbose > 3) + cout << "\t\tsgauss: " << sgauss << "\n" + << "\t\trgauss: " << rgauss << "\n" + << "\t\ttotalgauss+srcPix: " << totalgauss + + srcPix << endl; + + } //end for i + }//end for j + + //normalize and store + + if(g_verbose > 2) + cout << "\tnormalizing_factor: " << normalizing_factor << "\n" + << "\ttotal_val(before): " << total_val << endl; - if(total_val) { - total_val /= normalizing_factor; - *((float *)dest->data() + y * width + x) = total_val; - } - else { - total_val = norgauss/norgauss_normalize; - } - - if(g_verbose > 3) - cout << "\ttotal_val(after): " << total_val << "\n" - << "stored in: " << hex << dest->data() + - y * width + x << endl; - }//end for x - }//end for y - - return dest; + if(total_val) { + total_val /= normalizing_factor; + *((float *)dest->data() + y * width + x) = total_val; + } + else { + total_val = norgauss/norgauss_normalize; + } + + if(g_verbose > 3) + cout << "\ttotal_val(after): " << total_val << "\n" + << "stored in: " << hex << dest->data() + + y * width + x << endl; + }//end for x + }//end for y + + return dest; } /** given 2 floating point pixel locations, computes the distance */ float dist(float x1, float y1, float x2, float y2) { - return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)); + return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)); } /** gaussian applied to a single variable */ float simpleGauss(float x, float sigma, float mu) { - if(sigma == 0) { - cerr << "simpleGauss: sigma must be non-zero" << endl; - exit(1); - } - float pi = 3.1415926; - float x_p = x - mu; - float exponent = std::exp(x_p * x_p / (-2 * sigma * sigma)); - exponent /= sqrt(2 * pi) * sigma; - return exponent; + if(sigma == 0) { + cerr << "simpleGauss: sigma must be non-zero" << endl; + exit(1); + } + float pi = 3.1415926; + float x_p = x - mu; + float exponent = std::exp(x_p * x_p / (-2 * sigma * sigma)); + exponent /= sqrt(2 * pi) * sigma; + return exponent; } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h 2009-06-05 05:53:17 UTC (rev 3917) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/jbu.h 2009-06-05 12:21:00 UTC (rev 3918) @@ -42,9 +42,9 @@ /** upsamples multiple images given vector to store results in */ void jointBilateralUpsampling(std::vector<FImagePtr> *sources, - std::vector<FImagePtr> *refs, - std::vector<FImagePtr> *destImgs, - int num_neighbors); + std::vector<FImagePtr> *refs, + std::vector<FImagePtr> *destImgs, + int num_neighbors); /** upsamples a single image and returns the FImagePtr to the result */ FImagePtr jbuImage(FImagePtr source, FImagePtr refIm, int num_neighbors); Copied: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp (from rev 3912, hugin/branches/gsoc2009_deghosting/src/deghosting/khan.tcc) =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp (rev 0) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-05 12:21:00 UTC (rev 3918) @@ -0,0 +1,866 @@ +// -*- c-basic-offset: 4 -*- + +/** @file khan.cpp + * + * @brief Implementation of the khan deghosting algorithm + * + * @author Jing Jin <ji...@gm...> + * ported to the current interface by Lukas Jirkovsky + * + * $Id: khan.cpp 3626 2009-02-04 08:50:47Z stativ $ + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include <hugin_config.h> +#include <fstream> +#include <sstream> +#include <cmath> +#include <algorithm> + +#include <boost/shared_ptr.hpp> + +#include <hugin_utils/utils.h> + +// include vigra image processing library +#include <vigra/error.hxx> +#include <vigra/functorexpression.hxx> +#include <vigra/transformimage.hxx> +#include <vigra/combineimages.hxx> +#include <vigra/resizeimage.hxx> + +#include <vigra_ext/impexalpha.hxx> +#include <vigra_ext/utils.h> + +#include "khan.h" +#include "support.h" + +#ifdef _MSC_VER +#define snprintf _snprintf +#endif + +#define ENABLE_SAME 0 /*-a s option currently doesn't work */ +#define ENABLE_SCALING 0 /*-a m and u options currently don't work */ + +namespace deghosting { + +using namespace std; +using namespace hugin_utils; +using namespace vigra; +using namespace vigra::functor; +using vigra::NumericTraits; + +template <class T> +khan<T>::khan(vector<string>& setInputFiles, int setIter, uint16_t setFlags, uint8_t setSave, uint8_t setUI, int setVerbosity) + :inputFiles(setInputFiles),iterations(setIter),adv_mode(setFlags),save_mode(setSave),ui_mode(setUI),verbosity(setVerbosity) +{ + ; +} + +template <class T> +khan<T>::~khan() { + ; +} + +/** favor high SNR function + * f(x) = 1 - (x-220/255)^4 +*/ +template <class T> +float khan<T>::favorHighSNR(unsigned char x) +{ + double t = x/255 - 0.8627; + t *= t; // ^2 + t *= t; // ^4 + t *= t; // ^8 + return 1.0 - x; +} + +template <class T> +vector<FImagePtr> khan<T>::createWeightMasks() +{ + ////////////////////////////////////////////////////////////////////////// + // 1. SETUP. load and prepare images + + // log grayscale images + std::vector<FImagePtr> grayImages; + + // transparency images + vector<BImagePtr> alpha_images; + + // initial weights (maybe 8 bit would be enough for them?) + std::vector<FImagePtr> imgWeights; + + //file infos for images + vector<ImageImportInfo> exrInfo; + vector<ImageImportInfo> grayInfo; + + //load images and prepare initial weights + for (unsigned i = 0; i < inputFiles.size(); i++) { + + + if (verbosity > 0) { + std::cout << "Loading and preparing " << inputFiles[i] << std::endl; + } + + // load image from disk + vigra::ImageImportInfo info(inputFiles[i].c_str()); + + if(verbosity >1) + cout << "Loading source image: " << inputFiles[i].c_str() << endl; + exrInfo.push_back(info); + BImagePtr origGray(new BImage(info.size())); + FRGBImage img(info.size()); + FImagePtr gray(new FImage(info.size())); + + // load image + vigra::importImageAlpha(info, vigra::destImage(img), + destImage(*origGray)); + + // convert image to grayscale (and take logarithm) + vigra::RGBToGrayAccessor<ImageType::value_type> color2gray; + transformImage(srcImageRange(img, color2gray), + destImage(*gray), + log(Arg1()+Param(1.f))); + + // store for later use + grayImages.push_back(gray); + if(!(adv_mode & khanAdvModes::ADV_ALPHA)) + alpha_images.push_back(origGray); + + // for debugging purposes, save floating point tiff files + if (save_mode & khanAdvModes::SAVE_SOURCES) { + char tmpfn[100]; + snprintf(tmpfn, 99, "debug_init_gray_%d.tiff", i); + ImageExportInfo exGray(tmpfn); + exportImage(srcImageRange(*gray), exGray.setPixelType("UINT8")); + if(!(adv_mode & khanAdvModes::ADV_ALPHA)) { + snprintf(tmpfn, 99, "debug_init_alpha_%d.tiff", i); + exGray = ImageExportInfo(tmpfn); + exportImage(srcImageRange(*origGray), exGray.setPixelType("UINT8")); + } + } + + //if calculating weights from scratch + if(!(ui_mode & khanAdvModes::UI_IMPORT_INIT_WEIGHTS) || + (ui_mode & khanAdvModes::UI_EXPORT_INIT_WEIGHTS)) { + //load image + BImagePtr origGray(new BImage(info.size())); + // if weights should be based on input image instead of luminance image + if (adv_mode & khanAdvModes::ADV_NOLUM) { + vigra::copyImage(srcImageRange(img,color2gray), destImage(*origGray)); + } + else { // base weights on luminance image + std::string grayFile = hugin_utils::stripExtension(inputFiles[i]) + "_gray.pgm"; + + if(verbosity > 1) + cout << "Loading luminance image: " << grayFile << endl; + + vigra::ImageImportInfo infog(grayFile.c_str()); + grayInfo.push_back(infog); + + vigra::importImage(infog, destImage(*origGray)); + } + FImagePtr weight(new FImage(info.size())); + + // calculate initial weights, using mexican hat function + transformImage(srcImageRange(*origGray), + destImage(*weight), + weightFunctor); + + if(adv_mode & khanAdvModes::ADV_SNR) { + if(verbosity > 1) + cout << "favoring high snr..." << endl; + + FImagePtr snrWeight(new FImage(info.size())); + transformImage(srcImageRange(*origGray), destImage(*snrWeight), + &khan<T>::favorHighSNR); + + //weight(x) = weightMexicanHat(x) * favorHighSNR(x) + combineTwoImages(srcImageRange(*weight), srcImage(*snrWeight), + destImage(*weight), Arg1() * Arg2()); + } + + imgWeights.push_back(weight); + + // for debugging purposes, save floating point tiff files + if (save_mode & khanAdvModes::SAVE_WEIGHTS) { + char tmpfn[100]; + snprintf(tmpfn, 99, "debug_init_weights_%d.tiff", i); + ImageExportInfo exWeights(tmpfn); + exportImage(srcImageRange(*weight), exWeights.setPixelType("UINT8")); + } + } + } + + if(ui_mode & khanAdvModes::UI_EXPORT_INIT_WEIGHTS) { + if(!saveImages(inputFiles, "iw", imgWeights)) + cerr << "Cannot export initial weights" << endl; + else if(verbosity > 0) + cout << "Saved initial weights in source folder" << endl; + } + + if(ui_mode & khanAdvModes::UI_IMPORT_INIT_WEIGHTS) { + string s; + if(ui_mode & khanAdvModes::UI_EXPORT_INIT_WEIGHTS) { //just exported weights + while(true) { + cout << "Enter 'c' to load initial weights from source folder" << endl + << "Enter 'q' to cancel loading initial weights: "; + cin >> s; + + if(s[0] == 'c' || s[0] == 'q') + break; + } + } + + if(!s.length() || s[0] == 'c') { + vector<FImagePtr> tmpWeights; + if(!deghosting::loadImages(inputFiles, "iw", &tmpWeights)) { + cerr << "Cannot import initial weights" << endl; + /*if(!imgWeights.size()) + return false;*/ + } + else { + imgWeights = tmpWeights; + if(verbosity > 0) + cout << "Loaded initial weights from source folder" << endl; + } + } + } + + ////////////////////////////////////////////////////////////////////////// + // 2. Estimation of weights + + // images used to compute weight + vector<vector<float> > source_images; + // final weights + vector<vector<float> > weights; + // alpha mask + vector<vector<char> > alpha; + + //pos+size info for input images + vector<Rect2D> img_bounds; + + //size of final composite + int width, height; + + if(verbosity > 1) + cout << "Remappin input images" << endl; + + if((width = Fimages2Vectors(exrInfo, + alpha_images, grayImages, &source_images, &img_bounds)) == -1) { + + cerr << "Error converting images to vectors" << endl; + abort(); + } + + if(!((adv_mode & khanAdvModes::ADV_JBU) || (adv_mode & khanAdvModes::ADV_MULTI))) { + if(verbosity > 1) + cout << "Clearing gray input images" << endl; + grayImages.clear(); + } + height = source_images.size()/width; + + + if(Fimages2Vectors(exrInfo, alpha_images, imgWeights, &weights) == -1) { + cerr << "Error converting images to vectors" << endl; + cerr << "Perhaps *_gray.pgm files missing from command line?" << endl; + abort(); + } + + if(verbosity > 3) { //check consistency + cout << "checking image and weight vectors for consistent size" <<endl; + assert(source_images.size() == weights.size()); + for(unsigned i = 0; i < source_images.size(); i++) + assert(source_images.at(i).size() == weights.at(i).size()); + } + + if(!((adv_mode & khanAdvModes::ADV_JBU) || (adv_mode & khanAdvModes::ADV_MULTI))) { + if(verbosity > 1) + cout << "Clearing initial weight images" << endl; + imgWeights.clear(); + } + + if (verbosity > 0) { + std::cout << "deghosting (Khan algorithm) " << std::endl; + } + + int bias = 5; //hat function coefficient to make "wrong" pixels less weighted + //min value 1 + int rad_neighbors = 1; +#if ENABLE_SCALING + int jbu_neighbors = 2; +#endif + vector<vector<float> > init_weights(weights); + + if(verbosity > 0) + std::cout << "deghosting..." << std::endl; + + //variables used for multi-scaling + int proportion = 1; + int nw, nh; + vector <FImagePtr> smallGrayImages; + vector <FImagePtr> smallInitWeights; + vector<FImagePtr> smallWeights; + vector<BImagePtr> smallAlphaImages; + + //for each iteration + for(int iter = 0; iter < iterations; iter++) { + + if(verbosity > 0) + std::cout << "\n\niteration " << iter << endl; + + if(adv_mode & khanAdvModes::ADV_JBU || adv_mode & khanAdvModes::ADV_MULTI) { + proportion = 1 << ((iterations - iter)/2); + nw = width / proportion; + nh = height / proportion; + } + + try { + #if ENABLE_SCALING + //small image + if((proportion > 1)) { + //diff than last size, need to resize + + if(!smallGrayImages.size() || + smallGrayImages[0]->width() != + img_bounds[0].width() / proportion) { + if(verbosity > 1) + std::cout << "resizing to 1/" << proportion << " size" << endl; + + //don't use jbu if smaller + bool smaller = !smallGrayImages.size() || + (smallGrayImages[0]->width() > + img_bounds[0].width() / proportion); + + weights.clear(); + source_images.clear(); + init_weights.clear(); + smallWeights.clear(); + + if(smaller) { //1st time, need to initialize + smallGrayImages.resize(img_bounds.size()); + smallInitWeights.resize(img_bounds.size()); + smallAlphaImages.resize(img_bounds.size()); + Fvectors2Images(img_bounds, alpha_images, weights, width, + &smallWeights); + } + else { + Fvectors2Images(img_bounds, smallAlphaImages, weights, + width * (proportion >> 1), &smallWeights); + // ^-- width of last iter + } + + assert(smallWeights.size() == img_bounds.size()); + + for(unsigned i = 0; i < smallWeights.size(); i++) { + int w = img_bounds.at(i).width(); + int h = img_bounds.at(i).height(); + + FImagePtr smallGray(new FImage(w, h)); + FImagePtr newInitWeight(new FImage(w, h)); + BImagePtr smallAlpha(new BImage(w, h)); + //resize input img + resizeImageLinearInterpolation( + srcImageRange(*(grayImages.at(i))), + destImageRange(*smallGray)); + smallGrayImages.at(i) = smallGray; + + //resize init_weights + resizeImageLinearInterpolation( + srcImageRange(*(imgWeights.at(i))), + destImageRange(*newInitWeight)); + smallInitWeights.at(i) = newInitWeight; + + //resize alpha images + if(!(adv_mode & ADV_ALPHA)) { + resizeImageLinearInterpolation( + srcImageRange(*(alpha_images.at(i))), + destImageRange(*smallAlpha)); + smallAlphaImages.at(i) = smallAlpha; + } + + //resize weights + if(smaller && (adv_mode & ADV_JBU)) { + smallWeights.at(i) = jbuImage(smallWeights.at(i), + smallGray, jbu_neighbors); + } + else { + FImagePtr newWeight(new FImage(w, h)); + resizeImageLinearInterpolation( + srcImageRange(*(smallWeights.at(i))), + destImageRange(*newWeight)); + //replace old weights w/ new weights + smallWeights.at(i) = newWeight; + } + + } //end for i + + //convert everything to vectors + if(Fimages2Vectors(exrInfo, alpha_images, smallWeights, + &weights) == -1) + abort(); + if(Fimages2Vectors(exrInfo, alpha_images, smallGrayImages, + &source_images) == -1) + abort(); + if(Fimages2Vectors(exrInfo, alpha_images, smallInitWeights, + &init_weights) == -1) + abort(); + + } // end if != ns + + khanIteration(source_images, nh, nw, &weights, init_weights, + rad_neighbors, adv_mode); + } // end if proportion + else {//if just computing normal sized + if(smallWeights.size() && + smallWeights[0]->width() != img_bounds[0].width()) { //nw == width + if(verbosity > 1) { + std::cout << "resizing to 1/1" << " size" << endl; + } + + //delete cache for smaller layers to save memory + smallGrayImages.clear(); + smallInitWeights.clear(); + smallAlphaImages.clear(); + + weights.clear(); + source_images.clear(); + init_weights.clear(); + smallWeights.clear(); + Fvectors2Images(img_bounds, alpha_images, weights, width, + &smallWeights); + + for(unsigned i = 0; i < smallWeights.size(); i++) { + int w = img_bounds.at(i).width(); + int h = img_bounds.at(i).height(); + //resize weights + FImagePtr newWeight(new FImage(w, h)); + resizeImageLinearInterpolation( + srcImageRange(*(smallWeights.at(i))), + destImageRange(*newWeight)); + //replace old weights w/ new weights + smallWeights.at(i) = newWeight; + }//end for + + //convert everything to vectors + if(Fimages2Vectors(exrInfo, alpha_images, smallWeights, + &weights) == -1) + abort(); + smallWeights.clear(); + + if(Fimages2Vectors(exrInfo, alpha_images, grayImages, + &source_images) == -1) + abort(); + grayImages.clear(); + + if(Fimages2Vectors(exrInfo, alpha_images, imgWeights, + &init_weights) == -1) + abort(); + imgWeights.clear(); + }//end if + #endif + khanIteration(source_images, height, width, &weights, + init_weights, rad_neighbors, adv_mode); + #if ENABLE_SCALING + } + #endif + } + catch(std::exception &e) { + cerr << "caught exception in khanMain(1): " << e.what() << endl; + abort(); + } + + vector<FImagePtr> w; + //save files for debugging purposes + if(save_mode & khanAdvModes::SAVE_WEIGHTS) { + if(verbosity > 1) + std::cout << "saving debug weights..." << endl; + + Fvectors2Images(img_bounds, alpha_images, weights, width, &w); + + char tmpfn[100]; + for(unsigned i = 0; i < w.size(); i++) { + snprintf(tmpfn, 99, "iter%d_weight_layer%d.tiff", iter, i); + ImageExportInfo exWeight(tmpfn); + exportImage(srcImageRange(*(w.at(i))), exWeight.setPixelType("UINT8")); + } + } + if((save_mode & khanAdvModes::SAVE_RESULTS)) { + if(verbosity > 1) + std::cout << "saving debug result..." << endl; + + char tmpfn[100]; + snprintf(tmpfn, 99, "iter%d_result.exr", iter); + FRGBImage debug_out; + BImage debug_mask; + + if(!w.size()) + Fvectors2Images(img_bounds, alpha_images, weights, width, &w); + + #if ENABLE_SCALING + //need to upscale weights 1st + if(adv_mode & ADV_JBU) { + jointBilateralUpsampling(&weights, &grayImages, &w, + jbu_neighbors); + } + elseif(adv_mode & ADV_MULTI) { + for(int i = 0; i < num_layers; i++) { + FImagePtr tmpW(new FImage(width, height)); + resizeImageLinearInterpolation( + srcImageRange(*(w.at(i))), + destImageRange(*tmpW)); + tmpWeights.push_back(tmpW); + } + } + #endif + + vector<FImagePtr> w; + Fvectors2Images(img_bounds, alpha_images, weights, width, &w); + weightedAverageOfImageFiles(inputFiles, width, height, w, &debug_out, + &debug_mask); + ImageExportInfo exinfo(tmpfn); + exportImageAlpha(srcImageRange(debug_out), srcImage(debug_mask), exinfo); + } + } //end iteration loop + + #if ENABLE_SCALING + if(weights[0]->width() < grayImages[0]->width()) { + if(verbosity > 1) + cout << "performing final joint bilateral upsampling" << endl; + jointBilateralUpsampling(&weights, &grayImages, &weights, + jbu_neighbors); + } + #endif + + if(adv_mode & khanAdvModes::ADV_BIAS) { + //bias and renormalize weights + if(verbosity > 0) { + std::cout << "\nadjusting weights" << endl; + } + for(int i = 0; i < height; i++) { + int y_offset = i * width; + for(int j = 0; j < width; j++) { + int total_offset = y_offset + j; + float sum = 0; + vector<float> *tmp_weights = &(weights.at(total_offset)); + int num_layers = tmp_weights->size(); + + //cout <<"raar" << endl; + for(int layer = 0; layer < num_layers; layer++) { + float tmp = tmp_weights->at(layer); + tmp = pow(tmp, bias); + sum += tmp; + tmp_weights->at(layer) = tmp; + } + + float avg = 1/(float)num_layers; + for(int layer = 0; layer < num_layers; layer++) { + tmp_weights->at(layer) = + (sum ? tmp_weights->at(layer) / sum : avg); + } + } // end for j + } // end for i + } + else if(adv_mode & khanAdvModes::ADV_UNAVG) { + //make largest weight = 1, rest 0 + if(verbosity > 0) + std::cout << "\nadjusting weights" << endl; + + FImagePtr w; + + if(save_mode & khanAdvModes::SAVE_WEIGHTS) + w = FImagePtr(new FImage(Size2D(width, height))); + + for(int i = 0; i < height; i++) { + int y_offset = i * width; + for(int j = 0; j < width; j++) { + vector<int> max_ind; + float max = 0; //consider everything w/in 1% of max as max + int total_offset = y_offset + j; + vector<float> *tmpWeights = &(weights.at(total_offset)); + int num_layers = tmpWeights->size(); + + for(int layer = 0; layer < num_layers; layer++) { + float tmp = tmpWeights->at(layer); + if(tmp > max + max * 0.01) { + //make prev max 0 + while(!max_ind.empty()) { + tmpWeights->at(layer) = 0; + max_ind.pop_back(); + } + //make curr 1 + tmpWeights->at(layer) = 1; + + max = tmp; + max_ind.push_back(layer); + } + else if(tmp > max - max * 0.01) { + max_ind.push_back(layer); + } + else { //make curr 0 + tmpWeights->at(layer) = 0; + } + }//end for layer + + if((save_mode & khanAdvModes::SAVE_WEIGHTS) && max_ind.size() == 1) { + *(float *)(w->data() + total_offset) = + (max_ind[0] + 1) / (float)num_layers; + } + } //end for j + } // end for i + + if(save_mode & khanAdvModes::SAVE_WEIGHTS) { //save labels + if(verbosity > 1) + cout << "saving weight labels..." << endl; + + ImageExportInfo exWeight("weight_labels.tiff"); + exportImage(srcImageRange(*w), exWeight.setPixelType("UINT8")); + } + } + + // apply weights and store result in output image + vector<FImagePtr> w; + Fvectors2Images(img_bounds, alpha_images, weights, width, &w); + weights.clear(); + alpha_images.clear(); + khan<T>::width = width; + khan<T>::height = height; + return w; + //return true; +}//end khanMain + +/** writes the new weights in the given weights object pointer + */ +template <class T> +void khan<T>::khanIteration(const std::vector<std::vector<float> > &source_images, + const int height, const int width, + std::vector<std::vector<float> > *weights, + const std::vector<std::vector<float> > &init_weights, + const int rad_neighbors, const unsigned int adv_mode) +{ + try { + if(verbosity > 0) + std::cout << "processing..." << endl; + + if(verbosity > 3) + cout << "copying prev weights" << endl; + + vector<vector<float> > old_weights = *weights; + + //for each row + for(int row = 0; row < height; row++) { + int row_offset = row * width; + + if(verbosity ==2 || verbosity == 3) { + if(row % 100) { + if(verbosity == 3 && !(row % 10)) + cout << "." << flush; + } + else + cout << "\nrow " << row << " to " << (row +100) << flush; + } + + //for each column + for (int col = 0; col < width; col++) { + int total_offset = col + row_offset; + + if(verbosity > 3) + cout << "(x, y) = (" << col << ", " << row << ")" << endl; + + //get descriptors + vector<int> neighbor_offsets; + khanNeighbors(&neighbor_offsets, col, row, width, height, rad_neighbors); + + float total_sum = 0; + std::vector<float> raw_weights; + float max_weight = 0; + float min_weight = FLT_MAX; + + int num_layers = old_weights.at(total_offset).size(); + assert((unsigned)num_layers == source_images.at(total_offset).size()); + //for each layer + for(int layer = 0; layer < num_layers; layer++) { + if(verbosity > 3) { + cout << "layer " << layer << endl; + } + + //initialize sum to 0 + float sum_weight = 0; + float sum_prev_weight = 0; + //get center pixel + float curr_px = source_images.at(total_offset).at(layer); + + if(verbosity >3) + cout << "\tpixel = " << curr_px << endl; + //for each neighbor location + for(unsigned n = 0; n < neighbor_offsets.size(); n++) { + int n_offset = neighbor_offsets.at(n); + vector<float> *px_neighbor_w = &(old_weights.at(n_offset)); + const vector<float> *px_neighbor_v = + &(source_images.at(n_offset)); + unsigned num_l = px_neighbor_w->size(); + assert(num_l == px_neighbor_v->size()); + float tmp_weight = 0; + float tmp_prev_weight = 0; + + if(verbosity > 3) { + cout << "\t\tneighbor " << n << endl + << "\t\t\toffset: " << n_offset << endl; + } + + //number of layers at this neighbor location + for(unsigned l = 0; l < num_l; l++) { + + if(verbosity > 3) { + cout << "\t\t\tlayer " << l << endl + << "\t\t\tvalue = " << px_neighbor_v->at(l) << endl + << " \t\t\tweight = " << px_neighbor_w->at(l) + << endl; + } + + //diff against center + float val = curr_px - px_neighbor_v->at(l); + + //gaussian + val = std::exp(val * val * -0.5) / sqrt(2 * 3.14159); + //multiply by prev weight + val *= px_neighbor_w->at(l); + + if(verbosity > 3) { + cout << "\t\t\tresult = " << val << endl; + } + //add to sum + tmp_prev_weight += px_neighbor_w->at(l); + tmp_weight += val; + } //end l loop + if(num_l) { + //make sure each position gets same amount of weight + //regardless of number of layers + sum_prev_weight += tmp_prev_weight / num_l; + sum_weight += tmp_weight / num_l; + } + } //end neighbor loop + + if(sum_prev_weight == 0) { + sum_prev_weight = 1; + } + + sum_weight = sum_weight / sum_prev_weight * + init_weights.at(total_offset).at(layer); + + + #if ENABLE_SAME + if(adv_mode &ADV_SAME) { + //sum of neighbors (on same img) weights + float sum_neighbor_weights = 0; + for(int n = 0; n < num_neighbors / num_layers; n++) { + try { + sum_neighbor_weights += + *(old_weights.at(layer)->data() + neighbor_ptr_vec.at(n)); + } + catch(std::exception &e) { + abort(); + } + } + sum_weight *= sum_neighbor_weights; + } + #endif + + if(sum_weight > max_weight) + max_weight = sum_weight; + if(sum_weight < min_weight) + min_weight = sum_weight; + + //store in weights + raw_weights.push_back(sum_weight); + total_sum += sum_weight; + if(verbosity > 3) { + cout << "\t\traw weight = " << sum_weight << endl; + } + + } //end layer loop + /* + cout << "maxweigt: " << max_weight << endl; + cout << "minweight: " << min_weight << endl; + */ + //if diff is too small, just choose one with the heighest weight + if((adv_mode & khanAdvModes::ADV_UNAVG2) && + (min_weight >= 0.9 * max_weight)) { + bool tmp = true; + ... [truncated message content] |
From: <st...@us...> - 2009-06-05 13:03:37
|
Revision: 3919 http://hugin.svn.sourceforge.net/hugin/?rev=3919&view=rev Author: stativ Date: 2009-06-05 13:03:31 +0000 (Fri, 05 Jun 2009) Log Message: ----------- I wonder why it didn't work before. Another run and it worked. Anyway, this commit adds resizing of mask in weightedAverageOfImageFiles (it was there before but I've removed it because khan in fact doesn't use mask). The mask is not used, but it gives space for using external mask in future. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-05 12:21:00 UTC (rev 3918) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-05 13:03:31 UTC (rev 3919) @@ -339,8 +339,8 @@ cout << endl; - /*if(g_verbose > 2) - save = khanAdvModes::SAVE_ALL;*/ + if(g_verbose > 2) + save = khanAdvModes::SAVE_ALL; unsigned nFiles = argc - optind; if (nFiles == 0) { @@ -403,11 +403,11 @@ } weightedAverageOfImageFiles(inputFiles, deghoster.getWidth(), deghoster.getHeight(), weights, &output); - - ImageExportInfo exinfo(outputFile.c_str()); + + /*ImageExportInfo exinfo(outputFile.c_str()); exinfo.setPixelType("FLOAT"); BImage mask(output.width(), output.height(), 255); - exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo); + exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo);*/ } else { std::cerr << "Unknown merge mode, see help for a list of possible modes" << std::endl; return 1; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-06-05 12:21:00 UTC (rev 3918) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-06-05 13:03:31 UTC (rev 3919) @@ -38,6 +38,8 @@ assert(inputFiles.size() == weights.size()); output->resize(width, height); + if (mask != 0) + mask->resize(width, height); for(unsigned i = 0; i < inputFiles.size(); i++) { const ImageImportInfo curr_info(inputFiles[i].c_str()); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-09 10:49:19
|
Revision: 3930 http://hugin.svn.sourceforge.net/hugin/?rev=3930&view=rev Author: stativ Date: 2009-06-09 10:49:11 +0000 (Tue, 09 Jun 2009) Log Message: ----------- Turn on saving mask again. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-09 05:55:06 UTC (rev 3929) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/hugin_hdrmerge.cpp 2009-06-09 10:49:11 UTC (rev 3930) @@ -404,10 +404,10 @@ weightedAverageOfImageFiles(inputFiles, deghoster.getWidth(), deghoster.getHeight(), weights, &output); - /*ImageExportInfo exinfo(outputFile.c_str()); + ImageExportInfo exinfo(outputFile.c_str()); exinfo.setPixelType("FLOAT"); BImage mask(output.width(), output.height(), 255); - exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo);*/ + exportImageAlpha(srcImageRange(output), srcImage(mask), exinfo); } else { std::cerr << "Unknown merge mode, see help for a list of possible modes" << std::endl; return 1; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-06-09 05:55:06 UTC (rev 3929) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-06-09 10:49:11 UTC (rev 3930) @@ -147,7 +147,7 @@ output_bounds are needed to convert the vectors back into images */ -int Fimages2Vectors(const vector<ImageImportInfo> &file_info, +int Fimages2Vectors(const vector<string> &input_files, const vector<BImagePtr> &alpha_images, const vector<FImagePtr> &input_images, vector<vector<float> > *return_image, @@ -156,7 +156,7 @@ int width = 0; int height = 0; - int total_layers = file_info.size(); + int total_layers = input_files.size(); bool ignore_alpha = !(alpha_images.size()); //error checking @@ -164,7 +164,7 @@ return -1; for(int i = 0; i < total_layers; i++) { - ImageImportInfo f = file_info.at(i); + ImageImportInfo f(input_files[i].c_str()); int end_x = f.getPosition().x + f.width(); int end_y = f.getPosition().y + f.height(); @@ -177,7 +177,7 @@ return_image->resize(width * height, vector<float>()); for(int i = 0; i < total_layers; i++) { - ImageImportInfo f = file_info.at(i); + ImageImportInfo f(input_files[i].c_str()); Diff2D pos = f.getPosition(); assert(pos.x >= 0 && pos.y >= 0); Size2D size = f.size(); @@ -204,7 +204,7 @@ return width; } -int Bimages2Vectors(const vector<ImageImportInfo> &file_info, +int Bimages2Vectors(const vector<string> &input_files, const vector<BImagePtr> &alpha_images, const vector<BImagePtr> &input_images, vector<vector<char> > *return_image, @@ -212,7 +212,7 @@ { int width = 0; int height = 0; - int total_layers = file_info.size(); + int total_layers = input_files.size(); bool ignore_alpha = !(alpha_images.size()); //error checking @@ -220,7 +220,7 @@ return -1; for(int i = 0; i < total_layers; i++) { - ImageImportInfo f = file_info.at(i); + ImageImportInfo f(input_files[i].c_str()); int end_x = f.getPosition().x + f.width(); int end_y = f.getPosition().y + f.height(); @@ -233,7 +233,7 @@ return_image->resize(width * height, vector<char>()); for(int i = 0; i < total_layers; i++) { - ImageImportInfo f = file_info.at(i); + ImageImportInfo f(input_files[i].c_str()); Diff2D pos = f.getPosition(); assert(pos.x >= 0 && pos.y >= 0); Size2D size = f.size(); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-09 10:49:47
|
Revision: 3931 http://hugin.svn.sourceforge.net/hugin/?rev=3931&view=rev Author: stativ Date: 2009-06-09 10:49:46 +0000 (Tue, 09 Jun 2009) Log Message: ----------- Removed unnecessary exrInfo vector Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-09 10:49:11 UTC (rev 3930) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-09 10:49:46 UTC (rev 3931) @@ -104,7 +104,6 @@ std::vector<FImagePtr> imgWeights; //file infos for images - vector<ImageImportInfo> exrInfo; vector<ImageImportInfo> grayInfo; //load images and prepare initial weights @@ -120,7 +119,6 @@ if(verbosity >1) cout << "Loading source image: " << inputFiles[i].c_str() << endl; - exrInfo.push_back(info); BImagePtr origGray(new BImage(info.size())); FRGBImage img(info.size()); FImagePtr gray(new FImage(info.size())); @@ -259,7 +257,7 @@ if(verbosity > 1) cout << "Remappin input images" << endl; - if((width = Fimages2Vectors(exrInfo, + if((width = Fimages2Vectors(inputFiles, alpha_images, grayImages, &source_images, &img_bounds)) == -1) { cerr << "Error converting images to vectors" << endl; @@ -274,7 +272,7 @@ height = source_images.size()/width; - if(Fimages2Vectors(exrInfo, alpha_images, imgWeights, &weights) == -1) { + if(Fimages2Vectors(inputFiles, alpha_images, imgWeights, &weights) == -1) { cerr << "Error converting images to vectors" << endl; cerr << "Perhaps *_gray.pgm files missing from command line?" << endl; abort(); Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-06-09 10:49:11 UTC (rev 3930) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-06-09 10:49:46 UTC (rev 3931) @@ -71,12 +71,12 @@ * @param output_bounds Rectangles that store each image's offset and size * @return The width of the composite image */ -int Fimages2Vectors(const std::vector<vigra::ImageImportInfo> &file_info, +int Fimages2Vectors(const std::vector<std::string> &input_files, const std::vector<BImagePtr> &alpha_images, const std::vector<FImagePtr> &input_images, std::vector<std::vector<float> > *return_image, std::vector<vigra::Rect2D> *output_bounds = NULL); -int Bimages2Vectors(const std::vector<vigra::ImageImportInfo> &file_info, +int Bimages2Vectors(const std::vector<std::string> &input_files, const std::vector<BImagePtr> &alpha_images, const std::vector<BImagePtr> &input_images, std::vector<std::vector<char> > *return_image, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-09 11:40:10
|
Revision: 3932 http://hugin.svn.sourceforge.net/hugin/?rev=3932&view=rev Author: stativ Date: 2009-06-09 11:40:09 +0000 (Tue, 09 Jun 2009) Log Message: ----------- Small cleanup Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-09 10:49:46 UTC (rev 3931) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-09 11:40:09 UTC (rev 3932) @@ -420,7 +420,7 @@ } // end if != ns khanIteration(source_images, nh, nw, &weights, init_weights, - rad_neighbors, adv_mode); + rad_neighbors); } // end if proportion else {//if just computing normal sized if(smallWeights.size() && @@ -471,7 +471,7 @@ }//end if #endif khanIteration(source_images, height, width, &weights, - init_weights, rad_neighbors, adv_mode); + init_weights, rad_neighbors); #if ENABLE_SCALING } #endif @@ -647,7 +647,7 @@ const int height, const int width, std::vector<std::vector<float> > *weights, const std::vector<std::vector<float> > &init_weights, - const int rad_neighbors, const unsigned int adv_mode) + const int rad_neighbors) { try { if(verbosity > 0) Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-06-09 10:49:46 UTC (rev 3931) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-06-09 11:40:09 UTC (rev 3932) @@ -126,7 +126,7 @@ const int height, const int width, std::vector<std::vector<float> > *weights, const std::vector<std::vector<float> > &init_weights, - const int rad_neighbors, const unsigned int adv_mode); + const int rad_neighbors); }; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-23 13:27:42
|
Revision: 3957 http://hugin.svn.sourceforge.net/hugin/?rev=3957&view=rev Author: stativ Date: 2009-06-23 13:27:26 +0000 (Tue, 23 Jun 2009) Log Message: ----------- Some work on reimplementation of khan. Unfortunately it crashes after a while. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-06-23 13:18:44 UTC (rev 3956) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-06-23 13:27:26 UTC (rev 3957) @@ -37,7 +37,7 @@ /** create weight masks * create weight masks for masking out ghosting regions */ - virtual std::vector<BImagePtr> createWeightMasks() {} + virtual std::vector<FImagePtr> createWeightMasks() {} /** load images for processing * @param inputFiles images to be processed Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-23 13:18:44 UTC (rev 3956) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-23 13:27:26 UTC (rev 3957) @@ -10,6 +10,9 @@ #include <panotools/PanoToolsInterface.h> +using std::endl; +using std::cout; + namespace deghosting { Khan::Khan(std::vector<std::string>& setInputFiles, const uint16_t setFlags, const uint16_t setDebugFlags, int setIterations, EMoR setResponse) { inputFiles = setInputFiles; @@ -91,7 +94,7 @@ } } - std::vector<BImagePtr> Khan::createWeightMasks() { + std::vector<FImagePtr> Khan::createWeightMasks() { // first compute the denominator (abs(H))^1/2 * (2*pi)^5/2 // it should be faster than computing it for every pixel // note H always contain 5 elements (HSIZE = 5) @@ -105,7 +108,7 @@ // convert them to L*a*b // and create initial weights for (unsigned int i = 0; i < inputFiles.size(); i++) { - std::cout << "Loading image number " << i << std::endl; + cout << "Loading image number " << i << endl; // I should reimplement it without using VIGRA ImageImportInfo imgInfo(inputFiles[i].c_str()); FRGBImage * pInputImg = new FRGBImage(imgInfo.size()); @@ -152,24 +155,37 @@ } delete pInputImg; pInputImg = 0; - std::cout << ">> Loading of image number " << i << " finished" << std::endl; } + cout << endl << "Running khan algorithm" << endl; // and we can run khan algorithm // loop through all images for (unsigned int i = 0; i < LabImages.size(); i++) { + cout << "processing image " << i << endl; + // vector storing pixel data double X[5]; + double Y[5]; + // sums for eq. 6 + float wpqssum = 0; + float wpqsKhsum = 0; + // iterator to the upper left corner FLabImage::traverser sy = LabImages[i]->upperLeft(); // iterator to the lower right corner FLabImage::traverser send = LabImages[i]->lowerRight(); + // iterator to the weight image left corner + FImage::traverser wy = weights[i]->upperLeft(); // loop through the row - for (int y=1; sy.y != send.y; ++sy.y, ++y) { + for (int y=1; sy.y != send.y; ++sy.y, ++wy.y, ++y) { + cout << "processing row " << y << endl; // iterator to the source (L*a*b image) FLabImage::traverser sx = sy; + // iterator to the weight + FImage::traverser wx = wy; // loop over the pixels - for (int x=1; sx.x != send.x; ++sx.x, ++x) { + for (int x=1; sx.x != send.x; ++sx.x, ++wx.x, ++x) { + cout << "processing column " << x << endl; // set pixel vector X[0] = x; // x X[1] = y; // y @@ -177,11 +193,76 @@ X[3] = (*sx)[1]; // a X[4] = (*sx)[2]; // b - // loop through the neighbourhood + // loop through all layers + for (unsigned int j = 0; j < LabImages.size(); j++) { + cout << "processing layer " << j << endl; + // sum of weights + + // iterator to the current pixel + FLabImage::traverser currpx = LabImages[j]->upperLeft(); + // set it to the current position + currpx.y += y; + currpx.x += x; + + // current pixel in weights + FImage::traverser currweight = weights[j]->upperLeft(); + // set it to the current position + currweight.y += y; + currweight.x += x; + + // iterator to the neighbour + FLabImage::traverser neighby = currpx; + // iterator to the weight + FImage::traverser weighty = currweight; + + int ndy = 0; + // set iterator to the upper border of neighbourhood if it's not first row + // also set the ndy position + if(y>1) { + neighby.y -= NEIGHB_DIST; + weighty.y -= NEIGHB_DIST; + ndy = -NEIGHB_DIST; + } + + // iterate through neighbourhoods y axis + for (; ndy <= NEIGHB_DIST; ++neighby.y, ++weighty.y, ++ndy) { + cout << "iterating through the y axis, ndy=" << ndy << endl; + FLabImage::traverser neighbx = neighby; + FImage::traverser weightx = weighty; + int ndx = 0; + // set iterator to the left border of neighborhood if it's not first column + // also set the ndx position + if (x>1) { + neighbx.x -= NEIGHB_DIST; + weightx.x -= NEIGHB_DIST; + ndx = -NEIGHB_DIST; + } + // iterate through neighbourhoods x axis + for (; ndx <= NEIGHB_DIST; ++neighby.y, ++weightx.x, ++ndx) { + cout << "iterating through the x axis, ndx=" << ndx << endl; + // now we can construct pixel vector + // should omit the middle pixel, ie use only neighbours + Y[0] = X[0] - ndx; + Y[1] = X[1] - ndy; + Y[2] = X[2] - (*neighbx)[0]; + Y[3] = X[3] - (*neighbx)[1]; + Y[4] = X[4] - (*neighbx)[2]; + + wpqsKhsum += (*weightx * Kh(Y)); + wpqssum += *weightx; + } + } + } + + cout << "computing P" << endl; + // compute probability + float P = wpqsKhsum/wpqssum; + // set weight + *wx *= P; } } } - + return weights; } } \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-24 10:59:11
|
Revision: 3962 http://hugin.svn.sourceforge.net/hugin/?rev=3962&view=rev Author: stativ Date: 2009-06-24 10:58:39 +0000 (Wed, 24 Jun 2009) Log Message: ----------- Added setting of verbosity + some small fixes. But it still crashes just before creating weight image. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-06-23 17:22:53 UTC (rev 3961) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-06-24 10:58:39 UTC (rev 3962) @@ -64,6 +64,11 @@ * @param response array of five floats representing response */ virtual void setCameraResponse(float response[]) {} + + /** set verbosity level + * @param verbosity the higher the number is, the more verbose algorithm will be + */ + virtual void setVerbosity(int verbosity) {} virtual ~Deghosting() {} }; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-06-23 17:22:53 UTC (rev 3961) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-06-24 10:58:39 UTC (rev 3962) @@ -138,6 +138,7 @@ deghoster = &khanDeghoster; + deghoster->setVerbosity(2); deghoster->createWeightMasks(); } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-23 17:22:53 UTC (rev 3961) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-24 10:58:39 UTC (rev 3962) @@ -20,6 +20,7 @@ debugFlags = setDebugFlags; iterations = setIterations; response = setResponse; + verbosity = 0; PIPOW = std::pow((2*PI),(double)HSIZE/2.0); denom = 1/PIPOW; for (int i = 0; i<HSIZE; i++) @@ -45,6 +46,10 @@ void Khan::setCameraResponse(EMoR newResponse) { response = newResponse; } + + void Khan::setVerbosity(int newVerbosity) { + verbosity = newVerbosity; + } float Khan::hat(RGBValue<float> pixel) { double value = (pixel[0]+pixel[1]+pixel[2])/3; @@ -61,7 +66,11 @@ // note: both x and H always contain five elements (HSIZE = 5) double sum = 0; for (int i = 0; i<HSIZE; i++) { + #ifdef H_IDENTITY + sum += x[i] * x[i]; + #else sum += (x[i] / H[i]) * x[i]; + #endif } return (std::exp(-0.5*sum) * denom); } @@ -161,14 +170,18 @@ // and we can run khan algorithm // loop through all images for (unsigned int i = 0; i < LabImages.size(); i++) { - cout << "processing image " << i << endl; + if (verbosity > 1) + cout << "processing image " << i << endl; // vector storing pixel data double X[5]; double Y[5]; // sums for eq. 6 - float wpqssum = 0; - float wpqsKhsum = 0; + double wpqssum = 0; + double wpqsKhsum = 0; + // image size + int width = LabImages[i]->width(); + int height = LabImages[i]->height(); // iterator to the upper left corner FLabImage::traverser sy = LabImages[i]->upperLeft(); @@ -178,14 +191,14 @@ FImage::traverser wy = weights[i]->upperLeft(); // loop through the row for (int y=1; sy.y != send.y; ++sy.y, ++wy.y, ++y) { - cout << "processing row " << y << endl; // iterator to the source (L*a*b image) FLabImage::traverser sx = sy; // iterator to the weight FImage::traverser wx = wy; // loop over the pixels for (int x=1; sx.x != send.x; ++sx.x, ++wx.x, ++x) { - cout << "processing column " << x << endl; + if (verbosity > 2) + cout << "processing pixel (" << x << "," << y << ")" << endl; // set pixel vector X[0] = x; // x X[1] = y; // y @@ -195,7 +208,8 @@ // loop through all layers for (unsigned int j = 0; j < LabImages.size(); j++) { - cout << "processing layer " << j << endl; + if (verbosity > 2) + cout << "processing layer " << j << endl; // sum of weights // iterator to the current pixel @@ -215,31 +229,32 @@ // iterator to the weight FImage::traverser weighty = currweight; - int ndy = 0; + int ndy = -y; // set iterator to the upper border of neighbourhood if it's not first row // also set the ndy position - if(y>1) { + if(y > NEIGHB_DIST) { neighby.y -= NEIGHB_DIST; weighty.y -= NEIGHB_DIST; ndy = -NEIGHB_DIST; } // iterate through neighbourhoods y axis - for (; ndy <= NEIGHB_DIST; ++neighby.y, ++weighty.y, ++ndy) { - cout << "iterating through the y axis, ndy=" << ndy << endl; + int maxDisty = (height - y) >= ndy ? NEIGHB_DIST : (height - y); + for (; ndy <= maxDisty; ++neighby.y, ++weighty.y, ++ndy) { FLabImage::traverser neighbx = neighby; FImage::traverser weightx = weighty; - int ndx = 0; + int ndx = -x; // set iterator to the left border of neighborhood if it's not first column // also set the ndx position - if (x>1) { + if (x > NEIGHB_DIST) { neighbx.x -= NEIGHB_DIST; weightx.x -= NEIGHB_DIST; ndx = -NEIGHB_DIST; } // iterate through neighbourhoods x axis - for (; ndx <= NEIGHB_DIST; ++neighby.y, ++weightx.x, ++ndx) { - cout << "iterating through the x axis, ndx=" << ndx << endl; + int maxDistx = (width - x) >= ndy ? NEIGHB_DIST : (width - x); + for (; ndx <= maxDistx; ++neighbx.x, ++weightx.x, ++ndx) { + //cout << "(" << ndx << "," << ndy << ")"; // now we can construct pixel vector // should omit the middle pixel, ie use only neighbours Y[0] = X[0] - ndx; @@ -250,18 +265,30 @@ wpqsKhsum += (*weightx * Kh(Y)); wpqssum += *weightx; + + maxDistx = (width - x) >= ndy ? NEIGHB_DIST : (width - x); } + //cout << endl; + + maxDisty = (height - y) >= ndy ? NEIGHB_DIST : (height - y); } } - cout << "computing P" << endl; - // compute probability - float P = wpqsKhsum/wpqssum; - // set weight - *wx *= P; + if (verbosity > 2) + cout << "computing P" << endl; + // compute probability and set weight + *wx *= (float) wpqsKhsum/wpqssum; } } + // save debug weights + // save weights for testing purposes + { + char tmpfn[100]; + snprintf(tmpfn, 99, "weights_%d.tiff", i); + ImageExportInfo exWeights(tmpfn); + exportImage(srcImageRange(*weights[i]), exWeights.setPixelType("UINT8")); + } } return weights; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-06-24 17:01:14
|
Revision: 3963 http://hugin.svn.sourceforge.net/hugin/?rev=3963&view=rev Author: stativ Date: 2009-06-24 17:01:12 +0000 (Wed, 24 Jun 2009) Log Message: ----------- Fixed crash, but now I see that weights are not generated correctly... Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Added Paths: ----------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-06-24 10:58:39 UTC (rev 3962) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-06-24 17:01:12 UTC (rev 3963) @@ -65,6 +65,7 @@ uint16_t flags = 0; uint16_t debugFlags = 0; EMoR response(0.0f); + int verbosity = 0; response.resize(5); response[0] = -3.59f; response[1] = -0.93f; @@ -119,6 +120,7 @@ usage(argv[0]); return 0; case 'v': + verbosity++; break; } } @@ -138,7 +140,7 @@ deghoster = &khanDeghoster; - deghoster->setVerbosity(2); + deghoster->setVerbosity(verbosity); deghoster->createWeightMasks(); } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-24 10:58:39 UTC (rev 3962) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-24 17:01:12 UTC (rev 3963) @@ -215,21 +215,21 @@ // iterator to the current pixel FLabImage::traverser currpx = LabImages[j]->upperLeft(); // set it to the current position - currpx.y += y; - currpx.x += x; + currpx.y += y-1; + currpx.x += x-1; // current pixel in weights FImage::traverser currweight = weights[j]->upperLeft(); // set it to the current position - currweight.y += y; - currweight.x += x; + currweight.y += y-1; + currweight.x += x-1; // iterator to the neighbour FLabImage::traverser neighby = currpx; // iterator to the weight FImage::traverser weighty = currweight; - int ndy = -y; + int ndy = -y+1; // set iterator to the upper border of neighbourhood if it's not first row // also set the ndy position if(y > NEIGHB_DIST) { @@ -239,11 +239,11 @@ } // iterate through neighbourhoods y axis - int maxDisty = (height - y) >= ndy ? NEIGHB_DIST : (height - y); + int maxDisty = (height - y) >= NEIGHB_DIST ? NEIGHB_DIST : (height - y); for (; ndy <= maxDisty; ++neighby.y, ++weighty.y, ++ndy) { FLabImage::traverser neighbx = neighby; FImage::traverser weightx = weighty; - int ndx = -x; + int ndx = -x+1; // set iterator to the left border of neighborhood if it's not first column // also set the ndx position if (x > NEIGHB_DIST) { @@ -252,9 +252,10 @@ ndx = -NEIGHB_DIST; } // iterate through neighbourhoods x axis - int maxDistx = (width - x) >= ndy ? NEIGHB_DIST : (width - x); + int maxDistx = (width - x) >= NEIGHB_DIST ? NEIGHB_DIST : (width - x); for (; ndx <= maxDistx; ++neighbx.x, ++weightx.x, ++ndx) { - //cout << "(" << ndx << "," << ndy << ")"; + if (verbosity > 3) + cout << "(" << ndx << "," << ndy << ")"; // now we can construct pixel vector // should omit the middle pixel, ie use only neighbours Y[0] = X[0] - ndx; @@ -266,11 +267,12 @@ wpqsKhsum += (*weightx * Kh(Y)); wpqssum += *weightx; - maxDistx = (width - x) >= ndy ? NEIGHB_DIST : (width - x); + maxDistx = (width - x) >= NEIGHB_DIST ? NEIGHB_DIST : (width - x); } - //cout << endl; + if (verbosity > 3) + cout << endl; - maxDisty = (height - y) >= ndy ? NEIGHB_DIST : (height - y); + maxDisty = (height - y) >= NEIGHB_DIST ? NEIGHB_DIST : (height - y); } } Added: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h (rev 0) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-06-24 17:01:12 UTC (rev 3963) @@ -0,0 +1,83 @@ + +#ifndef KHAN_H_ +#define KHAN_H_ + +#include "deghosting.h" + +#include <vigra/rgbvalue.hxx> + +// needed for RGB2Lab +#include <vigra/imageinfo.hxx> +#include <vigra/transformimage.hxx> +#include <vigra/colorconversions.hxx> + +// for hat function +#include <vigra/rgbvalue.hxx> + +// needed for Kh() +#define PI 3.14159265358979323846 +#define HSIZE 5 +#define H_IDENTITY // H is identity matrix + +// number of pixels to look at in all directions +// ie. 1 for neighbourhood of size 3x3, 2 for 5x5 etc. +#define NEIGHB_DIST 1 + +using namespace vigra; + +namespace deghosting +{ + typedef FVector3Image FLabImage; + typedef boost::shared_ptr<FLabImage> FLabImagePtr; + + typedef TinyVector<float,3> colorVal; + typedef std::vector<float> EMoR; + + class Khan : public Deghosting + { + public: + Khan(std::vector< std::string >& inputFiles, const uint16_t flags, const uint16_t debugFlags, int iterations, EMoR response); + std::vector<FImagePtr> createWeightMasks(); + void loadImages(std::vector<std::string>& inputFiles); + void setFlags(const uint16_t flagslags); + void setDebugFlags(const uint16_t debugFlags); + void setIterationNum(const int iterations); + void setCameraResponse(EMoR newResponse); + void setVerbosity(int verbosity); + ~Khan() {} + private: + std::vector<std::string> inputFiles; + uint16_t flags; + uint16_t debugFlags; + int iterations; + EMoR response; + int verbosity; + + // Kh() things + // bandwith matrix + double H[HSIZE]; + // (2*pi)^(5/2) + double PIPOW; + // 1/Kh denominator + double denom; + + // other necessary stuff + std::vector<FLabImagePtr> LabImages; + std::vector<FImagePtr> weights; + + /** hat function + * used for creating initial weights + */ + static inline float hat(RGBValue<float> pixel); + /** transform image using EMoR response + * @param inputFile filename of image to be transformed + * @param *pInputImg FRGBImage to be transformed + */ + void linearizeRGB(std::string, FRGBImage* pInputImg); + /** kernel function + */ + inline double Kh(double x[]); + }; +} + +#endif /* KHAN_H_ */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-01 07:10:13
|
Revision: 3977 http://hugin.svn.sourceforge.net/hugin/?rev=3977&view=rev Author: stativ Date: 2009-07-01 07:10:00 +0000 (Wed, 01 Jul 2009) Log Message: ----------- Fixed Kh function Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-06-30 15:38:35 UTC (rev 3976) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-01 07:10:00 UTC (rev 3977) @@ -25,7 +25,9 @@ iterations = setIterations; response = setResponse; verbosity = 0; - PIPOW = std::pow((2*PI),(double)HSIZE/2.0); + //PIPOW = std::pow((2*PI),(double)HSIZE/2.0); + sigma = 256; + PIPOW = sigma*std::sqrt(2*PI); denom = 1/PIPOW; for (int i = 0; i<HSIZE; i++) H[i] = 1; @@ -76,7 +78,7 @@ sum += (x[i] / H[i]) * x[i]; #endif } - return (std::exp(-0.5*sum) * denom); + return (std::exp(-sum/(2*sigma*sigma)) * denom); } void Khan::linearizeRGB(std::string inputFile,FRGBImage *pInputImg) { @@ -175,7 +177,7 @@ // khan iteration for (int it = 0; it < iterations; it++) { if (verbosity > 0) - cout << "iteration " << it << endl; + cout << "iteration " << it+1 << endl; // copy weights from previous iteration if (verbosity > 1) cout << "copying weights from previous iteration" << endl; @@ -297,6 +299,8 @@ cout << "computing new weight" << endl; // compute probability and set weight *wx *= (float) wpqsKhsum/wpqssum; + wpqsKhsum = wpqssum = 0; + } } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-06-30 15:38:35 UTC (rev 3976) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-01 07:10:00 UTC (rev 3977) @@ -60,6 +60,8 @@ double PIPOW; // 1/Kh denominator double denom; + // sigma in gauusian density function + double sigma; // other necessary stuff std::vector<FLabImagePtr> LabImages; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-02 11:34:22
|
Revision: 3983 http://hugin.svn.sourceforge.net/hugin/?rev=3983&view=rev Author: stativ Date: 2009-07-02 11:34:17 +0000 (Thu, 02 Jul 2009) Log Message: ----------- Woo Hoo!!! I think I made it! Computed weights are a bit different from the previous implementation but they seems to be at least partially correct. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-01 22:22:01 UTC (rev 3982) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 11:34:17 UTC (rev 3983) @@ -25,12 +25,9 @@ iterations = setIterations; response = setResponse; verbosity = 0; - //PIPOW = std::pow((2*PI),(double)HSIZE/2.0); - sigma = 256; + sigma = 1; PIPOW = sigma*std::sqrt(2*PI); denom = 1/PIPOW; - for (int i = 0; i<HSIZE; i++) - H[i] = 1; } void Khan::loadImages(std::vector<std::string>& newInputFiles) { @@ -67,18 +64,8 @@ return 1.0 - t; } - double Khan::Kh(double x[]) { - // transpose(x) * H^-1 and multiply result with x - // note: both x and H always contain five elements (HSIZE = 5) - double sum = 0; - for (int i = 0; i<HSIZE; i++) { - #ifdef H_IDENTITY - sum += x[i] * x[i]; - #else - sum += (x[i] / H[i]) * x[i]; - #endif - } - return (std::exp(-sum/(2*sigma*sigma)) * denom); + double Khan::Kh(deghosting::AlgTinyVector< float, 3 > x) { + return (std::exp(-(x*x)/(2*sigma*sigma)) * denom); } void Khan::linearizeRGB(std::string inputFile,FRGBImage *pInputImg) { @@ -110,15 +97,6 @@ } std::vector<FImagePtr> Khan::createWeightMasks() { - // first compute the denominator (abs(H))^1/2 * (2*pi)^5/2 - // it should be faster than computing it for every pixel - // note H always contain 5 elements (HSIZE = 5) - double detH = 1; - for (unsigned int i = 0; i < HSIZE; i++) { - detH *= H[i]; - } - denom = 1/(detH * PIPOW); - // load images // convert them to L*a*b // and create initial weights @@ -138,29 +116,13 @@ // generate initial weights using hat function transformImage(srcImageRange(*pInputImg),destImage(*weight),hat); // convert from linear RGB to L*a*b // - FLabImagePtr LabImage(new FLabImage(imgInfo.size())); RGB2LabFunctor<float> RGB2Lab; + FLabImagePtr LabImage(new FLabImage(imgInfo.size())); transformImage(srcImageRange(*pInputImg), destImage(*LabImage), RGB2Lab); LabImages.push_back(LabImage); weights.push_back(weight); - - // save linear RGB for testing purposes - /*{ - char tmpfn[100]; - snprintf(tmpfn, 99, "init_linearRGB_%d.tiff", i); - ImageExportInfo exWeights(tmpfn); - exportImage(srcImageRange(*pInputImg), exWeights.setPixelType("UINT8")); - } - // save Lab for testing purposes - { - char tmpfn[100]; - snprintf(tmpfn, 99, "init_Lab_%d.tiff", i); - ImageExportInfo exWeights(tmpfn); - exportImage(srcImageRange(*LabImage), exWeights.setPixelType("UINT8")); - }*/ - // save weights for testing purposes if (debugFlags & SAVE_WEIGHTS) { char tmpfn[100]; @@ -193,8 +155,7 @@ cout << "processing image " << i << endl; // vector storing pixel data - double X[5]; - double Y[5]; + AlgTinyVector<float, 3> X; // sums for eq. 6 double wpqssum = 0; double wpqsKhsum = 0; @@ -219,11 +180,7 @@ if (verbosity > 2) cout << "processing pixel (" << x << "," << y << ")" << endl; // set pixel vector - X[0] = x; // x - X[1] = y; // y - X[2] = (*sx)[0]; // L - X[3] = (*sx)[1]; // a - X[4] = (*sx)[2]; // b + X = *sx/100; // loop through all layers for (unsigned int j = 0; j < LabImages.size(); j++) { @@ -278,13 +235,7 @@ // now we can construct pixel vector // should omit the middle pixel, ie use only neighbours if (ndx != ndy != 0) { - Y[0] = X[0] - ndx; - Y[1] = X[1] - ndy; - Y[2] = X[2] - (*neighbx)[0]; - Y[3] = X[3] - (*neighbx)[1]; - Y[4] = X[4] - (*neighbx)[2]; - - wpqsKhsum += (*weightx * Kh(Y)); + wpqsKhsum += (*weightx * Kh(X-(*neighbx)/100)); wpqssum += *weightx; } @@ -300,6 +251,7 @@ if (verbosity > 2) cout << "computing new weight" << endl; // compute probability and set weight + //cout << "P=" << (float) wpqsKhsum/wpqssum << endl; *wx *= (float) wpqsKhsum/wpqssum; wpqsKhsum = wpqssum = 0; @@ -318,4 +270,4 @@ } return weights; } -} \ No newline at end of file +} Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-01 22:22:01 UTC (rev 3982) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-02 11:34:17 UTC (rev 3983) @@ -3,6 +3,8 @@ #define KHAN_H_ #include "deghosting.h" +// for AlgTinyVector +#include "support.h" #include <vigra/rgbvalue.hxx> @@ -16,8 +18,6 @@ // needed for Kh() #define PI 3.14159265358979323846 -#define HSIZE 5 -#define H_IDENTITY // H is identity matrix // number of pixels to look at in all directions // ie. 1 for neighbourhood of size 3x3, 2 for 5x5 etc. @@ -27,10 +27,9 @@ namespace deghosting { - typedef FVector3Image FLabImage; + typedef BasicImage<AlgTinyVector<float, 3> > FLabImage; typedef boost::shared_ptr<FLabImage> FLabImagePtr; - typedef TinyVector<float,3> colorVal; typedef std::vector<float> EMoR; class Khan : public Deghosting @@ -54,9 +53,7 @@ int verbosity; // Kh() things - // bandwith matrix - double H[HSIZE]; - // (2*pi)^(5/2) + // (2*pi)^(1/2) double PIPOW; // 1/Kh denominator double denom; @@ -78,7 +75,7 @@ void linearizeRGB(std::string, FRGBImage* pInputImg); /** kernel function */ - inline double Kh(double x[]); + inline double Kh(deghosting::AlgTinyVector< float, 3 > x); }; } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-01 22:22:01 UTC (rev 3982) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 11:34:17 UTC (rev 3983) @@ -36,12 +36,70 @@ #include <vigra_ext/impexalpha.hxx> #include <vigra_ext/utils.h> +#include <iostream> + namespace deghosting { using namespace std; using namespace vigra; using namespace vigra::functor; +/** Fixed size vector with scalar multiplication and element-wise substraction and addition + */ +template <class T, int SIZE> +class AlgTinyVector : public TinyVector<T, SIZE> +{ + public: + const T operator*(const AlgTinyVector t) const { + T retVal = 0; + for (unsigned int i = 0; i < t.size(); ++i) { + retVal += t[i] * (*this)[i]; + } + return retVal; + } + + const AlgTinyVector operator*(const int t) const { + AlgTinyVector retVal; + for (unsigned int i = 0; i < (*this).size(); ++i) { + retVal[i] = t * (*this)[i]; + } + return retVal; + } + + const AlgTinyVector operator/(const int t) const { + AlgTinyVector retVal; + for (unsigned int i = 0; i < (*this).size(); ++i) { + retVal[i] = (*this)[i] / t; + } + return retVal; + } + + const AlgTinyVector operator-(const AlgTinyVector t) const { + AlgTinyVector retVal; + for (unsigned int i = 0; i < t.size(); ++i) { + retVal[i] = t[i] - (*this)[i]; + } + return retVal; + } + + const AlgTinyVector operator+(const AlgTinyVector t) const { + AlgTinyVector retVal; + for (unsigned int i = 0; i < t.size(); ++i) { + retVal[i] = t[i] + (*this)[i]; + } + return retVal; + } + + AlgTinyVector & operator=(const TinyVector<T,SIZE> & t) { + if (*this == t) + return *this; + for (unsigned int i = 0; i < t.size(); ++i) { + (*this)[i] = t[i]; + } + return *this; + } +}; + /** compute output image when given source images */ bool weightedAverageOfImageFiles(const vector<string> inputFiles, int width, int height, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-02 11:56:13
|
Revision: 3984 http://hugin.svn.sourceforge.net/hugin/?rev=3984&view=rev Author: stativ Date: 2009-07-02 11:56:09 +0000 (Thu, 02 Jul 2009) Log Message: ----------- Remove some of the unused functions Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-07-02 11:34:17 UTC (rev 3983) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.cpp 2009-07-02 11:56:09 UTC (rev 3984) @@ -143,210 +143,4 @@ return true; } -/** merges images into a better memory layout -return width of final image (can calc height from this) - -output_bounds are needed to convert the vectors back into images -*/ -int Fimages2Vectors(const vector<string> &input_files, - const vector<BImagePtr> &alpha_images, - const vector<FImagePtr> &input_images, - vector<vector<float> > *return_image, - vector<Rect2D> *output_bounds) -{ - - int width = 0; - int height = 0; - int total_layers = input_files.size(); - bool ignore_alpha = !(alpha_images.size()); - - //error checking - if((unsigned)total_layers != input_images.size()) - return -1; - - for(int i = 0; i < total_layers; i++) { - ImageImportInfo f(input_files[i].c_str()); - int end_x = f.getPosition().x + f.width(); - int end_y = f.getPosition().y + f.height(); - - if(end_x > width) - width = end_x; - if(end_y > height) - height = end_y; - } - - return_image->resize(width * height, vector<float>()); - - for(int i = 0; i < total_layers; i++) { - ImageImportInfo f(input_files[i].c_str()); - Diff2D pos = f.getPosition(); - assert(pos.x >= 0 && pos.y >= 0); - Size2D size = f.size(); - float *data = (float *) input_images.at(i)->data(); - char *alpha; - if(!ignore_alpha) - alpha = (char *) alpha_images.at(i)->data(); - for(int y = 0; y < size.height(); y++) { - int real_y = y + pos.y; - for(int x = 0; x < size.width(); x++) { - if(ignore_alpha || *(alpha + y * size.width() + x)) { - int real_x = x + pos.x; - return_image-> - at(real_y * width + real_x).push_back( - *(data + y * size.width() + x)); - } - } //end for x - } //end for y - if(output_bounds) { - output_bounds->push_back(Rect2D(*(new Point2D(pos)), size)); - } - } - - return width; -} - -int Bimages2Vectors(const vector<string> &input_files, - const vector<BImagePtr> &alpha_images, - const vector<BImagePtr> &input_images, - vector<vector<char> > *return_image, - vector<Rect2D> *output_bounds) -{ - int width = 0; - int height = 0; - int total_layers = input_files.size(); - bool ignore_alpha = !(alpha_images.size()); - - //error checking - if((unsigned)total_layers != input_images.size()) - return -1; - - for(int i = 0; i < total_layers; i++) { - ImageImportInfo f(input_files[i].c_str()); - int end_x = f.getPosition().x + f.width(); - int end_y = f.getPosition().y + f.height(); - - if(end_x > width) - width = end_x; - if(end_y > height) - height = end_y; - } - - return_image->resize(width * height, vector<char>()); - - for(int i = 0; i < total_layers; i++) { - ImageImportInfo f(input_files[i].c_str()); - Diff2D pos = f.getPosition(); - assert(pos.x >= 0 && pos.y >= 0); - Size2D size = f.size(); - char *data = (char *) input_images.at(i)->data(); - char *alpha; - if(!ignore_alpha) - alpha = (char *) alpha_images.at(i)->data(); - for(int y = 0; y < size.height(); y++) { - int real_y = y + pos.y; - for(int x = 0; x < size.width(); x++) { - if(ignore_alpha || *(alpha + y * size.width() + x)) { - int real_x = x + pos.x; - return_image-> - at(real_y * width + real_x).push_back( - *(data + y * size.width() + x)); - } - } //end for x - } //end for y - if(output_bounds) { - output_bounds->push_back(Rect2D(*(new Point2D(pos)), size)); - } - } - - return width; -} - -/** converts from a vector of vectors to a vector of images */ -void Fvectors2Images(const vector<Rect2D> &bounds, - const vector<BImagePtr> &alpha_images, - const vector<vector<float> > &input_images, - const int width, - vector<FImagePtr> *output_images) -{ - int total_layers = bounds.size(); - bool ignore_alpha = !(alpha_images.size()); - if(!ignore_alpha) - assert((unsigned)total_layers == alpha_images.size()); - - output_images->resize(total_layers); - - //duplicate input_images - vector<vector<float> > input; - for(unsigned i = 0; i < input_images.size(); i++) { - input.push_back(vector<float>(input_images.at(i))); - } - - //go in reverse order so can delete in constant time - for(int i = total_layers - 1; i >= 0; i--) { - FImagePtr img = FImagePtr(new FImage(bounds.at(i).size())); - const unsigned char *alpha; - if(!ignore_alpha) - alpha = alpha_images.at(i)->data(); - - for(int y = 0; y < img->height(); y++) { - int src_y = y + bounds.at(i).top(); - for(int x = 0; x < img->width(); x++) { - int src_x = x + bounds.at(i).left(); - - //if this px not transparent - if(ignore_alpha || *(alpha + y * img->width() + x)) { - vector<float> *src = &(input.at(src_y * width + src_x)); - assert(src->size()); - //pop last layer from this px in input - *((float *)img->data() + y * img->width() + x) = *(src->end()-1); - src->pop_back(); - } - }//end for x - }//end for y - - output_images->at(i) = img; - } -} - -void Bvectors2Images(const vector<Rect2D> &bounds, - const vector<BImagePtr> &alpha_images, - const vector<vector<char> > &input_images, - const int width, - vector<BImagePtr> *output_images) -{ - int total_layers = bounds.size(); - int height = input_images.size() / width; - bool ignore_alpha = !(alpha_images.size()); - if(!ignore_alpha) - assert((unsigned)total_layers == alpha_images.size()); - - for(int i = 0; i < total_layers; i++) { - output_images->push_back(BImagePtr(new BImage(bounds.at(i).size()))); - } - - for(int y = 0; y < height; y++) { - for(int x = 0; x < width; x++) { - Point2D pt(x, y); - unsigned ind = 0; - vector<char> pixel_layers = input_images.at(y * width + x); - - for(int i = 0; i < total_layers && ind < pixel_layers.size(); i++) { - Rect2D img = bounds.at(i); - if(img.contains(pt)) { - int real_x = x - img.left(); - int real_y = y - img.top(); - - if(ignore_alpha || *(alpha_images.at(i)->data() + - real_y * img.width() + real_x)) { - - char *realpt = (char *)(output_images->at(i)->data()); - realpt += real_y * img.width() + real_x; - *realpt = input_images.at(y * img.width() + x).at(ind++); - } - } - }//end for i - }//end for x - }//end for y -} - } // namespace deghosting Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 11:34:17 UTC (rev 3983) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 11:56:09 UTC (rev 3984) @@ -119,46 +119,6 @@ bool loadImages(std::vector<std::string> prep, std::string app, std::vector<FImagePtr> *images); -/** remaps a vector of FImages or BImages to a vector of vector of floats or - * chars, respectively, for faster reads/writes - * @param file_info Objects containing the images' offset information - * @param alpha_images BImages that indicate transparency of input images, - * in the same order as the input images - * @param input_images Input images to be remapped - * @param return_images Places to store remapped input_images - * @param output_bounds Rectangles that store each image's offset and size - * @return The width of the composite image - */ -int Fimages2Vectors(const std::vector<std::string> &input_files, - const std::vector<BImagePtr> &alpha_images, - const std::vector<FImagePtr> &input_images, - std::vector<std::vector<float> > *return_image, - std::vector<vigra::Rect2D> *output_bounds = NULL); -int Bimages2Vectors(const std::vector<std::string> &input_files, - const std::vector<BImagePtr> &alpha_images, - const std::vector<BImagePtr> &input_images, - std::vector<std::vector<char> > *return_image, - std::vector<vigra::Rect2D> *output_bounds = NULL); - -/** reverses effect of F/Bimages2Vectors: remaps a vector of vector of - * floats or chars back to FImages or BImages, respectively - * @param bounds Rectangles that store each image's offset and size - * @param alpha_images BImages that indicate transparency of output images - * @param input_images Input vector to be remapped - * @param width The width of the composite image represented by - * input_images - * @param output_images Images converted from input_images - */ -void Fvectors2Images(const std::vector<vigra::Rect2D> &bounds, - const std::vector<BImagePtr> &alpha_images, - const std::vector<std::vector<float> > &input_images, - const int width, std::vector<FImagePtr> *output_images); -void Bvectors2Images(const std::vector<vigra::Rect2D> &bounds, - const std::vector<BImagePtr> &alpha_images, - const std::vector<std::vector<char> > &input_images, - const int width, - std::vector<BImagePtr> *output_images); - } // namespace deghosting #endif /* SUPPORT_H_ */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-02 13:10:29
|
Revision: 3985 http://hugin.svn.sourceforge.net/hugin/?rev=3985&view=rev Author: stativ Date: 2009-07-02 12:47:44 +0000 (Thu, 02 Jul 2009) Log Message: ----------- Divide all values by 100 when importing images, so it doesn't have to be computed for every pixel all the time. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 11:56:09 UTC (rev 3984) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 12:47:44 UTC (rev 3985) @@ -119,6 +119,8 @@ RGB2LabFunctor<float> RGB2Lab; FLabImagePtr LabImage(new FLabImage(imgInfo.size())); transformImage(srcImageRange(*pInputImg), destImage(*LabImage), RGB2Lab); + // divide values by 100 + transformImage(srcImageRange(*LabImage), destImage(*LabImage), DivideFunctor<AlgTinyVector<float, 3> >(100)); LabImages.push_back(LabImage); weights.push_back(weight); @@ -180,7 +182,7 @@ if (verbosity > 2) cout << "processing pixel (" << x << "," << y << ")" << endl; // set pixel vector - X = *sx/100; + X = *sx; // loop through all layers for (unsigned int j = 0; j < LabImages.size(); j++) { @@ -235,7 +237,7 @@ // now we can construct pixel vector // should omit the middle pixel, ie use only neighbours if (ndx != ndy != 0) { - wpqsKhsum += (*weightx * Kh(X-(*neighbx)/100)); + wpqsKhsum += (*weightx * Kh(X-(*neighbx))); wpqssum += *weightx; } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 11:56:09 UTC (rev 3984) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 12:47:44 UTC (rev 3985) @@ -100,6 +100,21 @@ } }; +/** Fuctor which divide given object by a number + * quite similar to the STL divides but requires only one number + */ +template <class T> +class DivideFunctor +{ + public: + DivideFunctor(int d): div(d) {} + T operator()(T const & t) const { + return (t/div); + } + protected: + int div; +}; + /** compute output image when given source images */ bool weightedAverageOfImageFiles(const vector<string> inputFiles, int width, int height, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-02 13:18:31
|
Revision: 3986 http://hugin.svn.sourceforge.net/hugin/?rev=3986&view=rev Author: stativ Date: 2009-07-02 13:18:24 +0000 (Thu, 02 Jul 2009) Log Message: ----------- Revert part of the previous commit. It's not necessary to divide anything by 100, only change to sigma is necessary. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 12:47:44 UTC (rev 3985) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 13:18:24 UTC (rev 3986) @@ -119,8 +119,6 @@ RGB2LabFunctor<float> RGB2Lab; FLabImagePtr LabImage(new FLabImage(imgInfo.size())); transformImage(srcImageRange(*pInputImg), destImage(*LabImage), RGB2Lab); - // divide values by 100 - transformImage(srcImageRange(*LabImage), destImage(*LabImage), DivideFunctor<AlgTinyVector<float, 3> >(100)); LabImages.push_back(LabImage); weights.push_back(weight); Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 12:47:44 UTC (rev 3985) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-02 13:18:24 UTC (rev 3986) @@ -100,21 +100,6 @@ } }; -/** Fuctor which divide given object by a number - * quite similar to the STL divides but requires only one number - */ -template <class T> -class DivideFunctor -{ - public: - DivideFunctor(int d): div(d) {} - T operator()(T const & t) const { - return (t/div); - } - protected: - int div; -}; - /** compute output image when given source images */ bool weightedAverageOfImageFiles(const vector<string> inputFiles, int width, int height, This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-02 14:11:15
|
Revision: 3989 http://hugin.svn.sourceforge.net/hugin/?rev=3989&view=rev Author: stativ Date: 2009-07-02 13:50:25 +0000 (Thu, 02 Jul 2009) Log Message: ----------- Add option to set sigma value to the deghosting_mask Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-02 13:26:39 UTC (rev 3988) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-02 13:50:25 UTC (rev 3989) @@ -35,18 +35,8 @@ //<< " khan (default)" << endl << " -o prefix prefix for output masks" << endl << " -i number of iterations, default is 1" << endl - /*<< " -s file debug files to save each iteration, can be one of:" << endl - << " a - all debug files (can only be used alone)" << endl - << " w - calculated weights from each iteration" << endl - << " l - L*a*b images used for processing" << endl - << " -a calcs apply one or more advanced caculations, can be one or more of:" << endl - << " b - biasing weights logarithmically" << endl - << " c - choose pixels with heighest weight instead of averaging" << endl - << " (overrides options -a b and -a d)" << endl - << " d - choose a pixel with the heighest weight instead of" << endl - << " averaging when all pixel weights are within 10% of eachother" << endl - << " h - favor a high signal to noise ratio" << endl - << " i - ignore alpha channel" << endl*/ + << " -s value of sigma in probability density funtion" << endl + << " default is 50" << endl << " -r use camera response specified in EMoR format" << endl << " -h display this help" << endl << " -v verbose, repeat for more verbose output" << endl; @@ -61,6 +51,7 @@ string algorithm = "khan"; int iterations = 1; + double sigma = 50; uint16_t flags = 0; uint16_t debugFlags = 0; EMoR response(0.0f); @@ -83,20 +74,7 @@ iterations = atoi(optarg); break; case 's': - for(char *c = optarg; *c; c++) { - switch(*c) { - case 'w': - debugFlags += SAVE_WEIGHTS; - break; - case 'p': - debugFlags += SAVE_PROBABILITIES; - break; - default: - cerr << "Invalid argument for option -s: " << *c << std::endl; - usage(argv[0]); - return 1; - } - } + sigma = atof(optarg); break; case 'a': for(char *c = optarg; *c; c++) { @@ -135,11 +113,11 @@ Deghosting* deghoster = NULL; - Khan khanDeghoster(inputFiles, flags, debugFlags, iterations, response); + Khan khanDeghoster(inputFiles, flags, debugFlags, iterations, verbosity, response); + khanDeghoster.setSigma(sigma); deghoster = &khanDeghoster; - deghoster->setVerbosity(verbosity); deghoster->createWeightMasks(); } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 13:26:39 UTC (rev 3988) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 13:50:25 UTC (rev 3989) @@ -18,13 +18,14 @@ using std::cout; namespace deghosting { - Khan::Khan(std::vector<std::string>& setInputFiles, const uint16_t setFlags, const uint16_t setDebugFlags, int setIterations, EMoR setResponse) { + Khan::Khan(std::vector<std::string>& setInputFiles, const uint16_t setFlags, const uint16_t setDebugFlags, + int setIterations, int setVerbosity, EMoR setResponse) { inputFiles = setInputFiles; flags = setFlags; debugFlags = setDebugFlags; iterations = setIterations; response = setResponse; - verbosity = 0; + verbosity = setVerbosity; sigma = 50; PIPOW = sigma*std::sqrt(2*PI); denom = 1/PIPOW; @@ -53,6 +54,10 @@ void Khan::setVerbosity(int newVerbosity) { verbosity = newVerbosity; } + + void Khan::setSigma(double newSigma) { + sigma = newSigma; + } float Khan::hat(RGBValue<float> pixel) { double value = (pixel[0]+pixel[1]+pixel[2])/3; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-02 13:26:39 UTC (rev 3988) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-02 13:50:25 UTC (rev 3989) @@ -35,7 +35,7 @@ class Khan : public Deghosting { public: - Khan(std::vector< std::string >& inputFiles, const uint16_t flags, const uint16_t debugFlags, int iterations, EMoR response); + Khan(std::vector< std::string >& inputFiles, const uint16_t flags, const uint16_t debugFlags, int iterations, int verbosity, EMoR response); std::vector<FImagePtr> createWeightMasks(); void loadImages(std::vector<std::string>& inputFiles); void setFlags(const uint16_t flagslags); @@ -43,6 +43,7 @@ void setIterationNum(const int iterations); void setCameraResponse(EMoR newResponse); void setVerbosity(int verbosity); + void setSigma(double sigma); ~Khan() {} private: std::vector<std::string> inputFiles; @@ -74,6 +75,7 @@ */ void linearizeRGB(std::string, FRGBImage* pInputImg); /** kernel function + * Standard probability density function */ inline double Kh(deghosting::AlgTinyVector< float, 3 > x); }; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-03 09:20:47
|
Revision: 3991 http://hugin.svn.sourceforge.net/hugin/?rev=3991&view=rev Author: stativ Date: 2009-07-03 09:20:46 +0000 (Fri, 03 Jul 2009) Log Message: ----------- Change sigma defaul to 30. Added different kernel function for testing, can be enabled during compile time by defining ATAN_KH. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-02 17:00:22 UTC (rev 3990) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-03 09:20:46 UTC (rev 3991) @@ -51,7 +51,7 @@ string algorithm = "khan"; int iterations = 1; - double sigma = 50; + double sigma = 30; uint16_t flags = 0; uint16_t debugFlags = 0; EMoR response(0.0f); Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-02 17:00:22 UTC (rev 3990) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-03 09:20:46 UTC (rev 3991) @@ -8,6 +8,9 @@ // neded for zeroNegative() #include <vigra_ext/ImageTransforms.h> +// neded for atan and abs +#include <cmath> + #include <panotools/PanoToolsInterface.h> // for snprintf @@ -26,7 +29,7 @@ iterations = setIterations; response = setResponse; verbosity = setVerbosity; - sigma = 50; + sigma = 30; PIPOW = sigma*std::sqrt(2*PI); denom = 1/PIPOW; } @@ -70,7 +73,13 @@ } double Khan::Kh(deghosting::AlgTinyVector< float, 3 > x) { - return (std::exp(-(x*x)/(2*sigma*sigma)) * denom); + #ifdef ATAN_KH + // good choice for sigma for this function is around 600 + return std::atan(-std::abs(x*x)+sigma)/PI + 0.5; + #else + // good choice for sigma for this function is around 30 + return (std::exp(-(x*x)/(2*sigma*sigma)) * denom); + #endif } void Khan::linearizeRGB(std::string inputFile,FRGBImage *pInputImg) { Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-02 17:00:22 UTC (rev 3990) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-03 09:20:46 UTC (rev 3991) @@ -23,6 +23,10 @@ // ie. 1 for neighbourhood of size 3x3, 2 for 5x5 etc. #define NEIGHB_DIST 1 +// define for use atan based kernel function +// leave undefined for gaussian normal distribution function +#define ATAN_KH + using namespace vigra; namespace deghosting This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-03 10:50:11
|
Revision: 3992 http://hugin.svn.sourceforge.net/hugin/?rev=3992&view=rev Author: stativ Date: 2009-07-03 10:50:10 +0000 (Fri, 03 Jul 2009) Log Message: ----------- First work on improving it with HDR input. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-03 09:20:46 UTC (rev 3991) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-03 10:50:10 UTC (rev 3992) @@ -3,6 +3,7 @@ #include <vigra/impex.hxx> #include <vigra_ext/impexalpha.hxx> +// for EMoR #include <photometric/ResponseTransform.h> // neded for zeroNegative() @@ -11,6 +12,9 @@ // neded for atan and abs #include <cmath> +// for GammaFunctor +#include <vigra/transformimage.hxx> + #include <panotools/PanoToolsInterface.h> // for snprintf @@ -127,6 +131,23 @@ // linearize RGB and convert it to L*a*b image //linearizeRGB(inputFiles[i], pInputImg); + + // take logarithm or gamma correction if the input images are HDR + // I'm not sure if it's the right way how to + // find out if they are HDR + if ( (!strcmp(imgInfo.getFileType(),"TIFF") && strcmp(imgInfo.getPixelType(),"UINT8")) || + !strcmp(imgInfo.getFileType(),"EXR") || + !strcmp(imgInfo.getPixelType(),"FLOAT")) + { + // take logarithm + transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0)); + // use gamma 2.2 + // GammaFunctor is only in vigra 1.6 GRRR + // I have to use BrightnessContrastFunctor + // TODO: change to the GammaFunctor in the future + //transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0)); + } + // generate initial weights using hat function transformImage(srcImageRange(*pInputImg),destImage(*weight),hat); // convert from linear RGB to L*a*b // Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-03 09:20:46 UTC (rev 3991) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-03 10:50:10 UTC (rev 3992) @@ -44,6 +44,40 @@ using namespace vigra; using namespace vigra::functor; +/** Logarithm functor + */ +template <class PixelType> +class LogarithmFunctor { + public: + LogarithmFunctor(PixelType off=0) : offset(off) {} + + PixelType operator()(PixelType const& v) const { + return std::log(v + offset); + } + protected: + PixelType offset; +}; + +/** Logarithm functor + * specialization for RGBValue + */ +template <class ComponentType> +class LogarithmFunctor<RGBValue<ComponentType> > { + public: + LogarithmFunctor(ComponentType off=0) : offset(off) {} + + RGBValue<ComponentType> operator()(RGBValue<ComponentType> const& v) const { + RGBValue<ComponentType> retVal; + retVal[0] = log(v[0] + offset); + retVal[1] = log(v[1] + offset); + retVal[2] = log(v[2] + offset); + //cout << retVal[0] << "," << retVal[1] << "," << retVal[2] << endl; + return retVal; + } + protected: + ComponentType offset; +}; + /** Fixed size vector with scalar multiplication and element-wise substraction and addition */ template <class T, int SIZE> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-07 11:32:43
|
Revision: 4003 http://hugin.svn.sourceforge.net/hugin/?rev=4003&view=rev Author: stativ Date: 2009-07-07 11:32:37 +0000 (Tue, 07 Jul 2009) Log Message: ----------- Move saving of weights to the deghosting_mask Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-07 11:25:24 UTC (rev 4002) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-07 11:32:37 UTC (rev 4003) @@ -192,5 +192,13 @@ deghoster = &khanDeghoster; - deghoster->createWeightMasks(); + vector<FImagePtr> weights = deghoster->createWeightMasks(); + + // save weights + for (unsigned int i=0; i<weights.size(); ++i) { + char tmpfn[100]; + snprintf(tmpfn, 99, "%s_%d.tiff", outputPrefix.c_str(), i); + ImageExportInfo exWeights(tmpfn); + exportImage(srcImageRange(*weights[i]), exWeights.setPixelType("UINT8")); + } } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-07 11:25:24 UTC (rev 4002) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-07 11:32:37 UTC (rev 4003) @@ -284,15 +284,6 @@ } } - - // save debug weights - // save weights for testing purposes - { - char tmpfn[100]; - snprintf(tmpfn, 99, "weights_%d.tiff", i); - ImageExportInfo exWeights(tmpfn); - exportImage(srcImageRange(*weights[i]), exWeights.setPixelType("UINT8")); - } } } return weights; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-07 11:54:59
|
Revision: 4004 http://hugin.svn.sourceforge.net/hugin/?rev=4004&view=rev Author: stativ Date: 2009-07-07 11:54:57 +0000 (Tue, 07 Jul 2009) Log Message: ----------- Move preprocessing of images to the separate function Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-07 11:32:37 UTC (rev 4003) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-07 11:54:57 UTC (rev 4004) @@ -114,10 +114,7 @@ } } - std::vector<FImagePtr> Khan::createWeightMasks() { - // load images - // convert them to L*a*b - // and create initial weights + void Khan::preprocessImages() { for (unsigned int i = 0; i < inputFiles.size(); i++) { cout << "Loading image number " << i << endl; // I should reimplement it without using VIGRA @@ -168,6 +165,10 @@ delete pInputImg; pInputImg = 0; } + } + + std::vector<FImagePtr> Khan::createWeightMasks() { + preprocessImages(); cout << endl << "Running khan algorithm" << endl; // and we can run khan algorithm Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-07 11:32:37 UTC (rev 4003) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.h 2009-07-07 11:54:57 UTC (rev 4004) @@ -82,6 +82,12 @@ * Standard probability density function */ inline double Kh(deghosting::AlgTinyVector< float, 3 > x); + /** function to preprocess input images + * This function loads images, linearizes them using EMoR, + * tranform them using logarithm or gamm if input images are HDR + * fills vector<FImagePtr> weights and vector<FLabImagePtr> LabImages + */ + void preprocessImages(); }; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-09 18:05:54
|
Revision: 4016 http://hugin.svn.sourceforge.net/hugin/?rev=4016&view=rev Author: stativ Date: 2009-07-09 18:05:51 +0000 (Thu, 09 Jul 2009) Log Message: ----------- Add some advanced options to the CLI Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-07-09 17:25:41 UTC (rev 4015) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-07-09 18:05:51 UTC (rev 4016) @@ -23,8 +23,8 @@ typedef boost::shared_ptr<vigra::FImage> FImagePtr; // constants for advanced modes - const uint16_t ADV_BIAS = 1; - const uint16_t ADV_SNR = 2; + const uint16_t ADV_LOGARITHM = 1; + const uint16_t ADV_GAMMA = 2; const uint16_t ADV_UNAVG = 4; const uint16_t ADV_UNAVG2 = 8; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-09 17:25:41 UTC (rev 4015) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-09 18:05:51 UTC (rev 4016) @@ -37,6 +37,11 @@ << " -s, --sigma=SIGMA standard deviation of Gaussian weighting" << endl << " function (SIGMA > 0); default: 30" << endl << " -r, --response=E:M:o:R use camera response specified in EMoR format" << endl + << " -a, --advanced=SET advanced settings. Possible options are:" << endl + << " l use logarithm on input if input images are HDR," << endl + << " cannot be combined with g" << endl + << " g use gamma 2.2 correction on input if input images are HDR," << endl + << " cannot be combined with l" << endl << " -b BLOCKSIZE image cache BLOCKSIZE in kilobytes; default: " << (CachedFileImageDirector::v().getBlockSize() / 1024LL) << "KB" << endl << " -m CACHESIZE set image CACHESIZE in megabytes; default: " << @@ -46,7 +51,7 @@ } int main(int argc, char *argv[]) { - const char * optstring = "o:i:s:a:r:b:m:hv"; + const char * optstring = "o:i:s:r:a:b:m:hv"; opterr = 0; int c; @@ -65,17 +70,19 @@ iterationsID, sigmaID, responseID, + advancedID, helpID, verboseID }; static struct option longOptions[] = { - {"output", 1, 0, StringArgument}, // 0 - {"iterations", 1, 0, IntegerArgument}, // 1 - {"sigma", 1, 0, DoubleArgument}, // 2 - {"response", 1, 0, ArrayArgument}, // 3 - {"help", 0, 0, NoArgument}, // 4 - {"verbose", 0, 0, NoArgument}, // 5 + {"output", 1, 0, StringArgument}, + {"iterations", 1, 0, IntegerArgument}, + {"sigma", 1, 0, DoubleArgument}, + {"response", 1, 0, ArrayArgument}, + {"advanced", 1, 0, StringArgument}, + {"help", 0, 0, NoArgument}, + {"verbose", 0, 0, NoArgument}, {0, 0, 0, 0} }; @@ -119,6 +126,29 @@ case outputID: outputPrefix = optarg; break; + case advancedID: + for(char *c = optarg; *c; c++) { + switch(*c) { + case 'g': + if (flags & ADV_LOGARITHM) { + cerr << "g cannot be combined with l" << endl; + return 1; + } + flags += ADV_GAMMA; + break; + case 'l': + if (flags & ADV_GAMMA) { + cerr << "l cannot be combined with g" << endl; + return 1; + } + flags += ADV_LOGARITHM; + break; + default: + cerr<< "Error: unknown option" << endl; + return 1; + } + } + break; default: cerr << "There's a problem with parsing options" << endl; return 1; @@ -171,6 +201,29 @@ case 'r': // TODO break; + case 'a': + for(char *c = optarg; *c; c++) { + switch(*c) { + case 'g': + if (flags & ADV_LOGARITHM) { + cerr << "g cannot be combined with l" << endl; + return 1; + } + flags += ADV_GAMMA; + break; + case 'l': + if (flags & ADV_GAMMA) { + cerr << "l cannot be combined with g" << endl; + return 1; + } + flags += ADV_LOGARITHM; + break; + default: + cerr<< "Error: unknown option" << endl; + return 1; + } + } + break; case 'b': { const int kilobytes = atoi(optarg); if (kilobytes < 1) { Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-09 17:25:41 UTC (rev 4015) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-09 18:05:51 UTC (rev 4016) @@ -137,12 +137,18 @@ !strcmp(imgInfo.getPixelType(),"FLOAT")) { // take logarithm - transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0)); + if (flags & ADV_LOGARITHM) { + transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),LogarithmFunctor<RGBValue<float> >(1.0)); + } // use gamma 2.2 - // GammaFunctor is only in vigra 1.6 GRRR - // I have to use BrightnessContrastFunctor - // TODO: change to the GammaFunctor in the future - //transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0)); + else if (flags & ADV_GAMMA) { + // GammaFunctor is only in vigra 1.6 GRRR + // I have to use BrightnessContrastFunctor + // TODO: change to the GammaFunctor in the future + vigra::FindMinMax<float> minmax; + vigra::inspectImage(srcImageRange(*pInputImg), minmax); + transformImage(srcImageRange(*pInputImg),destImage(*pInputImg),BrightnessContrastFunctor<RGBValue<float> >(0.45,1.0,minmax.min, minmax.max)); + } } // generate initial weights using hat function This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-09 18:09:55
|
Revision: 4017 http://hugin.svn.sourceforge.net/hugin/?rev=4017&view=rev Author: stativ Date: 2009-07-09 18:09:53 +0000 (Thu, 09 Jul 2009) Log Message: ----------- Add files where I'm going to implement threshold function Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt Added Paths: ----------- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt 2009-07-09 18:05:51 UTC (rev 4016) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/CMakeLists.txt 2009-07-09 18:09:53 UTC (rev 4017) @@ -1,6 +1,6 @@ # various command line utilities -add_executable(deghosting_mask deghosting_mask.cpp khan.cpp jbu.cpp support.cpp) +add_executable(deghosting_mask deghosting_mask.cpp khan.cpp jbu.cpp support.cpp threshold.cpp) target_link_libraries(deghosting_mask ${common_libs} ${image_libs}) install(TARGETS deghosting_mask DESTINATION ${BINDIR}) Added: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp (rev 0) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp 2009-07-09 18:09:53 UTC (rev 4017) @@ -0,0 +1,8 @@ + +#include "threshold.h" + + + +vector<BImagePtr> thresshold(const vector<FImagePtr>, const int threshold, uint16_t flags) { + +} \ No newline at end of file Added: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h (rev 0) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h 2009-07-09 18:09:53 UTC (rev 4017) @@ -0,0 +1,31 @@ +/** + * thresshold + */ + +#include <vector> +#include <stdint.h> + +#include <boost/shared_ptr.hpp> +#include <vigra/stdimage.hxx> + +using std::vector; +using namespace vigra; + +typedef boost::shared_ptr<BImage> BImagePtr; +typedef boost::shared_ptr<FImage> FImagePtr; + +const uint16_t ONE_UNMASKED = 1; +const uint16_t ONE_MASKED = 2; + +/** Threshold function + * used for creating alpha masks for images + * @param const vector<FImagePtr> vector of images + * @param const int threshold threshold + * @param const uint16_t flags flags for setting the behavior + * possible values are: + * 0 – applies only threshold + * ONE_UNMASKED – if pixel should be black in all images after applying threshold + * leave it in one image (where the pixel value is highest) white + * ONE_MASKED – make the pixel black only in one image where it's value is lowest + */ +vector<BImagePtr> thresshold(const vector<FImagePtr>, const int threshold, const uint16_t flags); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-10 14:27:22
|
Revision: 4020 http://hugin.svn.sourceforge.net/hugin/?rev=4020&view=rev Author: stativ Date: 2009-07-10 14:27:20 +0000 (Fri, 10 Jul 2009) Log Message: ----------- Some test code Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-10 00:15:11 UTC (rev 4019) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-10 14:27:20 UTC (rev 4020) @@ -1,12 +1,14 @@ #include <iostream> #include <string> +#include <cstring> #include <hugin_config.h> #include <hugin_version.h> #include "deghosting.h" #include "support.h" +#include "threshold.h" // deghosting algorithms #include "khan.h" @@ -37,6 +39,7 @@ << " -s, --sigma=SIGMA standard deviation of Gaussian weighting" << endl << " function (SIGMA > 0); default: 30" << endl << " -r, --response=E:M:o:R use camera response specified in EMoR format" << endl + << " -t threshold" << endl << " -a, --advanced=SET advanced settings. Possible options are:" << endl << " l use logarithm on input if input images are HDR," << endl << " cannot be combined with g" << endl @@ -51,7 +54,7 @@ } int main(int argc, char *argv[]) { - const char * optstring = "o:i:s:r:a:b:m:hv"; + const char * optstring = "o:i:s:r:t:a:b:m:hv"; opterr = 0; int c; @@ -93,6 +96,7 @@ uint16_t debugFlags = 0; EMoR response(0.0f); int verbosity = 0; + int thresholdLim = 128; response.resize(5); response[0] = -3.59f; response[1] = -0.93f; @@ -201,6 +205,9 @@ case 'r': // TODO break; + case 't': + thresholdLim = atof(optarg); + break; case 'a': for(char *c = optarg; *c; c++) { switch(*c) { @@ -286,4 +293,13 @@ ImageExportInfo exWeights(tmpfn); exportImage(srcImageRange(*weights[i]), exWeights.setPixelType("UINT8")); } + + // TEST treshold + vector<BImagePtr> thresholded = threshold(weights, thresholdLim, 0); + for (unsigned int i=0; i<weights.size(); ++i) { + char tmpfn[100]; + snprintf(tmpfn, 99, "threshold_%d.tiff", i); + ImageExportInfo exWeights(tmpfn); + exportImage(srcImageRange(*thresholded[i]), exWeights.setPixelType("UINT8")); + } } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp 2009-07-10 00:15:11 UTC (rev 4019) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp 2009-07-10 14:27:20 UTC (rev 4020) @@ -1,8 +1,38 @@ #include "threshold.h" +#include <vigra/transformimage.hxx> +#include <vigra/imageinfo.hxx> +// just for testing +#include <vigra/inspectimage.hxx> -vector<BImagePtr> thresshold(const vector<FImagePtr>, const int threshold, uint16_t flags) { - -} \ No newline at end of file +using namespace vigra; +using namespace std; + +vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags) { + vector<BImagePtr> retVal; + for (unsigned int i=0; i < inputImages.size(); ++i) { + if (flags & ONE_MASKED) { + // TODO + exit(0); + } + else if (flags & ONE_UNMASKED) { + // TODO + exit(0); + } + else { + // don't care about masking + // TEST begin + vigra::FindMinMax<float> minmax; + vigra::inspectImage(srcImageRange(*(inputImages[i])), minmax); + cout << minmax.max << endl; + // TEST end + BImagePtr tmpImg(new BImage(inputImages[i]->size())); + transformImage(srcImageRange(*(inputImages[i])), destImage(*tmpImg), + Threshold<FImage::PixelType, BImage::PixelType>(threshold, 255, 0, 255)); + retVal.push_back(tmpImg); + } + } + return retVal; +} Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h 2009-07-10 00:15:11 UTC (rev 4019) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h 2009-07-10 14:27:20 UTC (rev 4020) @@ -8,19 +8,19 @@ #include <boost/shared_ptr.hpp> #include <vigra/stdimage.hxx> +#include "deghosting.h" + using std::vector; using namespace vigra; +using namespace deghosting; -typedef boost::shared_ptr<BImage> BImagePtr; -typedef boost::shared_ptr<FImage> FImagePtr; - const uint16_t ONE_UNMASKED = 1; const uint16_t ONE_MASKED = 2; /** Threshold function * used for creating alpha masks for images * @param const vector<FImagePtr> vector of images - * @param const int threshold threshold + * @param const int threshold all pixels above this thresshold are set to 255, others to 0 * @param const uint16_t flags flags for setting the behavior * possible values are: * 0 – applies only threshold @@ -28,4 +28,4 @@ * leave it in one image (where the pixel value is highest) white * ONE_MASKED – make the pixel black only in one image where it's value is lowest */ -vector<BImagePtr> thresshold(const vector<FImagePtr>, const int threshold, const uint16_t flags); +vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-10 14:33:33
|
Revision: 4021 http://hugin.svn.sourceforge.net/hugin/?rev=4021&view=rev Author: stativ Date: 2009-07-10 14:33:29 +0000 (Fri, 10 Jul 2009) Log Message: ----------- changed threshold to be double, it's better for experimenting Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-10 14:27:20 UTC (rev 4020) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-10 14:33:29 UTC (rev 4021) @@ -96,7 +96,7 @@ uint16_t debugFlags = 0; EMoR response(0.0f); int verbosity = 0; - int thresholdLim = 128; + double thresholdLim = 128; response.resize(5); response[0] = -3.59f; response[1] = -0.93f; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp 2009-07-10 14:27:20 UTC (rev 4020) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.cpp 2009-07-10 14:33:29 UTC (rev 4021) @@ -10,7 +10,7 @@ using namespace vigra; using namespace std; -vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags) { +vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags) { vector<BImagePtr> retVal; for (unsigned int i=0; i < inputImages.size(); ++i) { if (flags & ONE_MASKED) { Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h 2009-07-10 14:27:20 UTC (rev 4020) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/threshold.h 2009-07-10 14:33:29 UTC (rev 4021) @@ -28,4 +28,4 @@ * leave it in one image (where the pixel value is highest) white * ONE_MASKED – make the pixel black only in one image where it's value is lowest */ -vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const int threshold, uint16_t flags); +vector<BImagePtr> threshold(const vector<FImagePtr> &inputImages, const double threshold, uint16_t flags); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-11 10:21:09
|
Revision: 4024 http://hugin.svn.sourceforge.net/hugin/?rev=4024&view=rev Author: stativ Date: 2009-07-11 10:21:08 +0000 (Sat, 11 Jul 2009) Log Message: ----------- Normalize weights Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-10 17:49:27 UTC (rev 4023) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-11 10:21:08 UTC (rev 4024) @@ -176,6 +176,8 @@ std::vector<FImagePtr> Khan::createWeightMasks() { preprocessImages(); + float maxWeight = 0; + cout << endl << "Running khan algorithm" << endl; // and we can run khan algorithm // khan iteration @@ -287,12 +289,18 @@ // compute probability and set weight //cout << "P=" << (float) wpqsKhsum/wpqssum << endl; *wx *= (float) wpqsKhsum/wpqssum; + if (maxWeight < *wx) + maxWeight = *wx; wpqsKhsum = wpqssum = 0; } } } } + // normalize weights + for (unsigned int i=0; i<weights.size(); ++i) { + transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(maxWeight, 255)); + } return weights; } } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-10 17:49:27 UTC (rev 4023) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-11 10:21:08 UTC (rev 4024) @@ -78,6 +78,37 @@ ComponentType offset; }; +/** Fuctor to normalize values + */ +template <class PixelType> +class NormalizeFunctor { + public: + NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : foo(newMaxValue/oldMaxValue) {} + + PixelType operator()(PixelType const &v) const { + return v*foo; + } + protected: + PixelType foo; +}; + +/** Fuctor to normalize values + * specialization for RGBValue + */ +template <class ComponentType> +class NormalizeFunctor<RGBValue<ComponentType> > { + public: + NormalizeFunctor(RGBValue<ComponentType> oldMaxValue, RGBValue<ComponentType> newMaxValue) { + // TODO + } + + RGBValue<ComponentType> operator()(RGBValue<ComponentType> const &v) { + // TODO + } + protected: + RGBValue<ComponentType> foo; +}; + /** Fixed size vector with scalar multiplication and element-wise substraction and addition */ template <class T, int SIZE> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-11 12:05:03
|
Revision: 4027 http://hugin.svn.sourceforge.net/hugin/?rev=4027&view=rev Author: stativ Date: 2009-07-11 12:04:56 +0000 (Sat, 11 Jul 2009) Log Message: ----------- Added constructor to the NormalizeFunctor which do not compute scale factor for every pixel. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/support.h Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-11 10:25:21 UTC (rev 4026) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-11 12:04:56 UTC (rev 4027) @@ -300,8 +300,9 @@ if (verbosity > 1) cout << "normalizing weights" << endl; + double factor = 255.0f/maxWeight; for (unsigned int i=0; i<weights.size(); ++i) { - transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(maxWeight, 255)); + transformImage(srcImageRange(*(weights[i])), destImage(*(weights[i])), NormalizeFunctor<float>(factor)); } return weights; } Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/support.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-11 10:25:21 UTC (rev 4026) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/support.h 2009-07-11 12:04:56 UTC (rev 4027) @@ -83,13 +83,14 @@ template <class PixelType> class NormalizeFunctor { public: - NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : foo(newMaxValue/oldMaxValue) {} + NormalizeFunctor(PixelType f) : factor(f) {} + NormalizeFunctor(PixelType oldMaxValue, PixelType newMaxValue) : factor(newMaxValue/oldMaxValue) {} PixelType operator()(PixelType const &v) const { - return v*foo; + return v*factor; } protected: - PixelType foo; + PixelType factor; }; /** Fuctor to normalize values This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <st...@us...> - 2009-07-11 13:24:50
|
Revision: 4029 http://hugin.svn.sourceforge.net/hugin/?rev=4029&view=rev Author: stativ Date: 2009-07-11 13:24:49 +0000 (Sat, 11 Jul 2009) Log Message: ----------- Added option which disables computing initial weights using hat function. I'm not sure if it's usefull though. Modified Paths: -------------- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-07-11 12:05:39 UTC (rev 4028) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting.h 2009-07-11 13:24:49 UTC (rev 4029) @@ -23,9 +23,9 @@ typedef boost::shared_ptr<vigra::FImage> FImagePtr; // constants for advanced modes - const uint16_t ADV_LOGARITHM = 1; - const uint16_t ADV_GAMMA = 2; - const uint16_t ADV_UNAVG = 4; + const uint16_t ADV_LOGARITHM = 1; + const uint16_t ADV_GAMMA = 2; + const uint16_t ADV_NOINITWEIGHTS = 4; const uint16_t ADV_UNAVG2 = 8; // constants for debug modes Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-11 12:05:39 UTC (rev 4028) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/deghosting_mask.cpp 2009-07-11 13:24:49 UTC (rev 4029) @@ -45,6 +45,7 @@ << " cannot be combined with g" << endl << " g use gamma 2.2 correction on input if input images are HDR," << endl << " cannot be combined with l" << endl + << " n do not compute initial weigths" << endl << " -b BLOCKSIZE image cache BLOCKSIZE in kilobytes; default: " << (CachedFileImageDirector::v().getBlockSize() / 1024LL) << "KB" << endl << " -m CACHESIZE set image CACHESIZE in megabytes; default: " << @@ -147,6 +148,9 @@ } flags += ADV_LOGARITHM; break; + case 'n': + flags += ADV_NOINITWEIGHTS; + break; default: cerr<< "Error: unknown option" << endl; return 1; @@ -225,6 +229,9 @@ } flags += ADV_LOGARITHM; break; + case 'n': + flags += ADV_NOINITWEIGHTS; + break; default: cerr<< "Error: unknown option" << endl; return 1; Modified: hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp =================================================================== --- hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-11 12:05:39 UTC (rev 4028) +++ hugin/branches/gsoc2009_deghosting/src/deghosting/khan.cpp 2009-07-11 13:24:49 UTC (rev 4029) @@ -152,7 +152,15 @@ } // generate initial weights using hat function - transformImage(srcImageRange(*pInputImg),destImage(*weight),hat); + if (flags & ADV_NOINITWEIGHTS) { + // convert image to grayscale (and take logarithm) + RGBToGrayAccessor<FRGBImage::PixelType> color2gray; + transformImage(srcImageRange(*pInputImg, color2gray), destImage(*weight), log(Arg1()+Param(1.0f))); + } + else { + transformImage(srcImageRange(*pInputImg),destImage(*weight),hat); + } + // convert from linear RGB to L*a*b // RGB2LabFunctor<float> RGB2Lab; FLabImagePtr LabImage(new FLabImage(imgInfo.size())); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |