algorithm.cpp

// This file is part of the AliceVision project.
// Copyright (c) 2016 AliceVision contributors.
// Copyright (c) 2012 openMVG contributors.
// Copyright (c) 2011-12 Zhe Liu and Pierre Moulon.
// This file was initially part of the KVLD library under the terms of the BSD license (see the COPYING file).
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.

/** @basic structures implementation
 ** @author Zhe Liu
 **/

#include "algorithm.h"

#include <boost/math/constants/constants.hpp>

IntegralImages::IntegralImages(const aliceVision::image::Image<float>& I)
{
    map.resize(I.width() + 1, I.height() + 1);
    map.fill(0);
    for (int y = 0; y < I.height(); y++)
    {
        for (int x = 0; x < I.width(); x++)
        {
            map(y + 1, x + 1) = double(I(y, x)) + map(y, x + 1) + map(y + 1, x) - map(y, x);
        }
    }
}

float getRange(const aliceVision::image::Image<float>& I, int a, const float p)
{
    float range = sqrt(float(3.f * I.height() * I.width()) / (p * a * boost::math::constants::pi<float>()));
    return range;
}

//=============================IO interface======================//

std::ofstream& writeDetector(std::ofstream& out, const aliceVision::feature::PointFeature& feature)
{
    out << feature.x() << " " << feature.y() << " " << feature.scale() << " " << feature.orientation() << std::endl;
    return out;
}

std::ifstream& readDetector(std::ifstream& in, aliceVision::feature::PointFeature& point)
{
    in >> point.x() >> point.y() >> point.scale() >> point.orientation();
    return in;
}

bool anglefrom(float x, float y, float& angle)
{
    using namespace boost::math;

    if (x != 0)
        angle = std::atan(y / x);
    else if (y > 0)
        angle = constants::pi<float>() / 2;
    else if (y < 0)
        angle = -constants::pi<float>() / 2;
    else
        return false;

    if (x < 0)
        angle += constants::pi<float>();
    while (angle < 0)
        angle += 2 * constants::pi<float>();
    while (angle >= 2 * constants::pi<float>())
        angle -= 2 * constants::pi<float>();
    assert(angle >= 0 && angle < 2 * constants::pi<float>());
    return true;
}

double angle_difference(double angle1, double angle2)
{
    using namespace boost::math;

    double angle = angle1 - angle2;
    while (angle < 0)
        angle += 2 * constants::pi<double>();
    while (angle >= 2 * constants::pi<double>())
        angle -= 2 * constants::pi<double>();

    assert(angle <= 2 * constants::pi<double>() && angle >= 0);
    return std::min(angle, 2 * constants::pi<double>() - angle);
}