view_analysis.cpp

Go to the documentation of this file.

 
 
#include <view_analysis.h>
 
#include <vector>
#include <array>
#include <cmath>
 
#include <embree_raytracer.h>
#include <RayRequest.h>
#include <node.h>
 
 
using namespace HF::RayTracer;
using std::vector;
using HF::SpatialStructures::Node;
#undef min
#undef max
namespace HF::ViewAnalysis {
 
    constexpr float ConvertToRadians(float num_in_degrees) {
        return num_in_degrees * (static_cast<float>(M_PI) / 180.00f);
    }
 
    inline void Normalize(std::array<float, 3> & vec) {
        float& x = vec[0];
        float& y = vec[1];
        float& z = vec[2];
 
        float magnitude = sqrt(
            pow(x, 2) + pow(y, 2) + pow(z, 2)
        );
        vec[0] /= magnitude;
        vec[1] /= magnitude;
        vec[2] /= magnitude;
 
    }
 
    inline bool AltitudeWithinRange(const std::array<float, 3>& vec, float max_angle, float min_angle) {
        float x = vec[0]; float y = vec[1]; float z = vec[2];
        float r = sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));
        float phi = acos(z / r);
 
        return (phi >= min_angle && phi <= max_angle);
    }
 
    vector<std::array<float, 3>> FibbonacciDist(int num_points, float upwards_fov, float downward_fov) 
    {
 
        // Convert limits to radians
        const float upperlimit = ConvertToRadians(upwards_fov);
        const float lowerlimit = ConvertToRadians(downward_fov);
 
        // Calculate maximum and minimum altitude
        const float max_phi = static_cast<float>(M_PI_2) + lowerlimit;
        const float min_phi = static_cast<float>(M_PI_2) - upperlimit;
 
        const int n = num_points;
        std::vector<std::array<float, 3>> out_points;
        float offset = 2.0f / float(n);
        const float increment = static_cast<float>(M_PI)* (3.0f - sqrtf(5.0f));
 
        for (int i = 5; i < n + 5; i++) {
            float y = ((float(i) * offset) - 1.0f) - (offset / 0.2f);
            float r = sqrtf(1.0f - powf(y, 2));
            
            float phi = (float(i + 1) * increment);
            float x = cosf(phi) * r;
            float z = sinf(phi) * r;
 
            // Check for nans. These can sometimes occur at the beginning and end of the result set
            // due to imprecision.
            if (!isnan(x) && !isnan(y) && !isnan(z)) {
                auto new_point = std::array<float, 3>{x, y, z};
                Normalize(new_point);
                if (AltitudeWithinRange(new_point, max_phi, min_phi))
                    out_points.emplace_back(new_point);
            }
        }
        return out_points;
 
    }
 
    vector<std::array<float, 3>> FibbonacciDistributePoints(int num_points, float upwards_fov, float downward_fov)
    {
        // Generate initial set of directions
        auto out_points = FibbonacciDist(num_points, upwards_fov, downward_fov);
        
        // Calculate a percentage of points discarded. 
        int points_removed = num_points - out_points.size();
        double percent_removed = static_cast<double>(points_removed) / static_cast<double>(num_points);
 
        // Calculate a new total based on percentage of points removed
        int new_out_points = (num_points / (1.0 - percent_removed));
        
        // Generate a set of points with the new total.
        out_points.clear();
        return FibbonacciDist(new_out_points, upwards_fov, downward_fov);
    }
}