view_analysis.h

Go to the documentation of this file.

 
 
#include <vector>
#include <array>
#include <cmath>
#include <iostream>
#include <assert.h>
#include <limits>
 
#ifndef VIEW_ANALYSIS_G
#define VIEW_ANALYSIS_G
 
// Forward Declares
namespace HF {
    namespace SpatialStructures {
        struct Node;
    }
    namespace RayTracer {
        class EmbreeRayTracer;
        struct RayRequest;
    }
}
 
namespace HF::ViewAnalysis {
    enum class AGGREGATE_TYPE {
        COUNT = 0,
        SUM = 1,
        AVERAGE = 2,
        MAX = 3,
        MIN = 4
    };
 
    
 
    std::vector<std::array<float, 3>> FibbonacciDistributePoints(
        int num_points,
        float upwards_fov = 50.0f,
        float downward_fov = 70.0f
    );
 
    inline void Aggregate(float& out_total, float new_value, const AGGREGATE_TYPE agg_type, int count = 0) {
        switch (agg_type) {
            case AGGREGATE_TYPE::COUNT:
                if (new_value > 0) out_total += 1;
                break;
            case AGGREGATE_TYPE::SUM:
                out_total += new_value;
                break;
            case AGGREGATE_TYPE::AVERAGE: {
                int n = count - 1;
                out_total = (n * (out_total)+new_value) / count;
                break;
            }
            case AGGREGATE_TYPE::MAX: {
                out_total = std::max<float>(out_total, new_value);
                break;
            }
            case AGGREGATE_TYPE::MIN: {
                out_total = std::min<float>(out_total, new_value);
                break;
            }
            default:
                throw std::out_of_range("Unimplemented aggregation type");
                break;
        } // End Switch
        assert(out_total == 0 || isnormal(out_total));
        return;
    }
 
 
    template <typename RES, typename RT, typename N>
    std::vector<RES> SphericalViewAnalysis(
        RT& ray_tracer,
        const std::vector<N>& Nodes,
        int num_rays,
        float upward_limit = 50.0f,
        float downward_limit = 70.0f,
        float height = 1.7f)
    {
        // Calculate directions then perform a quick check to see if we can even hold this vector
        const auto directions = FibbonacciDistributePoints(num_rays, upward_limit, downward_limit);
        int required_vector_size = directions.size() * Nodes.size();
        std::vector<RES> out_results;
 
        // Throw if we can't fit the results into a single vector. This will change based on the implementation
        // of std::vector being used.
        if (out_results.max_size() < required_vector_size) {
            std::cout << "The desired view analysis setting exceed the maximum vector size!" << std::endl;
            throw std::bad_array_new_length();
        }
        out_results.resize(required_vector_size);
 
        // Size of the vector is the number of rays
        num_rays = directions.size();
 
        #pragma omp parallel
        {
        // Start parallel intersections
        #pragma omp for schedule(dynamic) 
            for (int i = 0; i < Nodes.size(); i++)
            {
                // Reset out values to temporarily store results. Kept private by defining here
                float out_distance = 0;
                int out_mid = 0;
 
                auto node = Nodes[i];
                node[2] += height;
                int os = directions.size() * i;
 
                // Iterate through every direction and cast a ray for it
                for (int k = 0; k < directions.size(); k++)
                {
                    int idx = os + k;
                    // Call the result's SetHit if it intersected.
                    if (ray_tracer.IntersectOutputArguments(node, directions[k], out_distance, out_mid))
                    {
                        out_results[idx].SetHit(node, directions[k], out_distance, out_mid);
                    }
                } // End direction loop
            } // End node loop
        } // End omp space
 
        return out_results;
    }
 
// To use numeric limits, need to undefine max
#undef max
 
 
    template<typename RT, typename N>
    std::vector<float> SphericalRayshootWithAnyRTForDistance(
        RT& ray_tracer,
        const std::vector<N>& Nodes,
        int num_rays,
        float upward_limit = 50.0f,
        float downward_limit = 70.0f,
        float height = 1.7f,
        const AGGREGATE_TYPE aggregation = AGGREGATE_TYPE::SUM)
    {
        // Allocate score array and calculate directions
        std::vector<float> out_scores(Nodes.size());
        const auto directions = FibbonacciDistributePoints(num_rays, upward_limit, downward_limit);
 
        #pragma omp parallel
        {
            // Start parallel intersections
        #pragma omp for schedule(dynamic) 
            for (int i = 0; i < Nodes.size(); i++)
            {
                const auto& node = Nodes[i];
 
                // Get a reference to the value in the score array, reset score and count to zero
                float& score = out_scores[i];
                int count = 1;
 
                // If the aggregation type is min, set the score to some large value
                if (aggregation == AGGREGATE_TYPE::MIN){
                    score = std::numeric_limits<float>::max();
                }
                else {
                    score = 0;
                }
 
                // Cast a ray for every direction in directions
                for (const auto& direction : directions)
                {
                    // Create a copy of the node to offset.
                    auto node_copy = node;
                    node_copy[2] += height;
                    //float distance = 0;
 
                    // If the ray intersects any geometry, calculate distance to the intersection point
                    // then plug that into the aggregation method.
                    if (ray_tracer.PointIntersection(
                            node_copy[0], node_copy[1], node_copy[2],
                            direction[0], direction[1], direction[2]))
                    {
                        // Add the height back to the original node so the distance check is accurate
                        float distance = sqrtf(
                                                  powf((node[0]        - node_copy[0]), 2) 
                                                + powf((node[1]        - node_copy[1]), 2) 
                                                + powf((node[2] + height - node_copy[2]), 2));
 
                        // Based on aggregation method, check this new value against the last
                        Aggregate(score, distance, aggregation, count);
                        count++;
                    }
                }// End FOR over directions
            } // End FOR over Nodes
        }// End OMP
        return out_scores;
    }
}
 
#endif