hsi_PhotometricOptimizer.cpp

Go to the documentation of this file.

 
#include "hsi_PhotometricOptimizer.h"
 
#include <fstream>
#include <stdexcept>
#include <vector>
 
#include <appbase/ProgressDisplay.h>
#include <algorithms/optimizer/PhotometricOptimizer.h>
#include <algorithms/basic/CalculateMeanExposure.h>
#include <panodata/ImageVariableGroup.h>
#include <panodata/StandardImageVariableGroups.h>
 
// header-only helper shared with autooptimiser/vig_optimize, loads the
// source images and samples point correspondences across their overlaps
#include <tools/ExtractPoints.h>
 
namespace HuginBase
{
 
namespace
{
// loadImgsAndExtractPoints() loads images inside a #pragma omp parallel
// for loop; an exception (e.g. vigra::PreconditionViolation for a missing
// file) thrown from within that loop cannot cross the OpenMP boundary and
// aborts the process instead of propagating. Check what we can up front,
// outside any parallel region, so the common failure (bad path) raises a
// normal exception instead.
void CheckImagesReadable(const Panorama& pano)
{
    for (size_t i = 0; i < pano.getNrOfImages(); i++)
    {
        const std::string filename = pano.getImage(i).getFilename();
        std::ifstream f(filename.c_str());
        if (!f.good())
        {
            throw std::runtime_error("cannot open image file: " + filename);
        }
    }
}
} // namespace
 
double RunPhotometricOptimizer(Panorama& pano)
{
    CheckImagesReadable(pano);
 
    AppBase::DummyProgressDisplay progress;
 
    const int nPoints = 200 * static_cast<int>(pano.getNrOfImages());
    std::vector<vigra_ext::PointPairRGB> points;
    float imageStepSize;
    loadImgsAndExtractPoints(pano, nPoints, 3, true, progress, points, 0, imageStepSize);
 
    if (points.empty())
    {
        throw std::runtime_error("no overlapping points found for photometric optimization");
    }
 
    // ensure vignetting and response coefficients are linked across each lens,
    // so the optimizer treats all images from the same lens consistently
    const ImageVariableGroup::ImageVariableEnum linkedVars[] =
    {
        ImageVariableGroup::IVE_EMoRParams,
        ImageVariableGroup::IVE_ResponseType,
        ImageVariableGroup::IVE_VigCorrMode,
        ImageVariableGroup::IVE_RadialVigCorrCoeff,
        ImageVariableGroup::IVE_RadialVigCorrCenterShift
    };
    StandardImageVariableGroups variableGroups(pano);
    ImageVariableGroup& lenses = variableGroups.getLenses();
    for (size_t i = 0; i < lenses.getNumberOfParts(); i++)
    {
        for (const auto var : linkedVars)
        {
            if (!lenses.getVarLinkedInPart(var, i))
            {
                lenses.linkVariablePart(var, i);
            }
        }
    }
 
    PanoramaOptions opts = pano.getOptions();
    SmartPhotometricOptimizer::PhotometricOptimizeMode optMode =
        SmartPhotometricOptimizer::OPT_PHOTOMETRIC_LDR_WB;
    if (opts.outputMode == PanoramaOptions::OUTPUT_HDR ||
        variableGroups.getStacks().getNumberOfParts() < pano.getNrOfImages())
    {
        optMode = SmartPhotometricOptimizer::OPT_PHOTOMETRIC_HDR;
    }
 
    SmartPhotometricOptimizer photoOpt(pano, &progress, pano.getOptimizeVector(), points, imageStepSize, optMode);
    photoOpt.run();
 
    opts.outputExposureValue = CalculateMeanExposure::calcMeanExposure(pano);
    pano.setOptions(opts);
 
    return photoOpt.getResultError();
}
 
} // namespace HuginBase