cost_algorithms.h

Go to the documentation of this file.

 
 
#ifndef COST_ALGORITHMS_H
#define COST_ALGORITHMS_H
 
#include <vector>
#include <string>
 
#include "Constants.h"
 
namespace HF::SpatialStructures {
    struct Node;
    struct Edge;
    struct EdgeSet;
    struct IntEdge;
    class Graph;
    struct Subgraph;
}
 
namespace HF::SpatialStructures::CostAlgorithms {
    double to_radians(double degrees);
    
    double to_degrees(double radians);
 
    template <size_t dimension, typename float_precision = float>
    float_precision euclidean_distance(float_precision point_a[], float_precision point_b[]) {
        float_precision sum = 0;
        
        for (size_t i = 0; i < dimension; i++) {
            float_precision difference = point_b[i] - point_a[i];
            sum += std::pow(difference, 2.0);
        }
 
        return std::sqrt(sum);
    }
 
    template <size_t dimension, typename float_precision = float>
    float_precision dot_product(float_precision vec_U[], float_precision vec_V[]) {
        float_precision sum = 0;
 
        for (size_t i = 0; i < dimension; i++) {
            sum += vec_U[i] * vec_V[i];
        }
 
        return sum;
    }
 
    template <size_t dimension, typename float_precision = float>
    bool is_perpendicular(float_precision vec_U[], float_precision vec_V[]) {
        // Mathematically,
        // two vectors are perpendicular if their dot product is
        // equal to zero. But since it is a mortal sin to test
        // floating point numbers for equality (using operator==) --
        // we can test if the dot product of
        // vector_a and vector_b is 'close enough' to zero,
        // by determining if our dot_product calculation
        // is less than our ROUNDING_PRECISION constant.
        // (which is 0.0001)    
        return std::abs(dot_product<dimension, float_precision>(vec_U, vec_V)) 
            < HF::SpatialStructures::ROUNDING_PRECISION;
    }
 
    template <size_t dimension, typename float_precision = float>
    std::vector<Edge> GetPerpendicularEdges(const Subgraph& sg, const Node& child_node_a) {
        std::vector<Edge> perpendicular_edges;
 
        auto& parent_node = sg.m_parent;
        auto& edges = sg.m_edges;
 
        for (Edge edge_b : edges) {
            Node child_node_b = edge_b.child;
            // We iterate over all children by parent_node.
            // The goal is to compare the vector formed by parent_node and child_a,
            // with the vectors formed by parent_node and all other child node by this parent, all other child_b's.
 
            /*
            std::cout << "parent " << parent_node.id << " has child " << edge_b.child.id
                << " with data " << edge_b.score << std::endl;
            */
 
            if (child_node_a != child_node_b) {
                //
                //  Here -- we should assess the step_type field for edge_b.
                //
                //  /// <summary> Describes the type of step an edge connects to. </summary>
                //  enum STEP {
                //      NOT_CONNECTED = 0, ///< No connection between parent and child.
                //      NONE = 1,        ///< Parent and child are on the same plane and no step is required.
                //      UP = 2,         ///< A step up is required to get from parent to child.
                //      DOWN = 3,       ///< A step down is required to get from parent to child.
                //      OVER = 4        ///< A step over something is required to get from parent to child.
                //  };
                //
 
                // Retrieve the { x, y, z } components of the vectors formed by
                //  parent_node and child_node_a
                //  parent_node and child_node_b
                auto vector_a = parent_node.directionTo(child_node_a);
                auto vector_b = parent_node.directionTo(child_node_b);
 
                if (is_perpendicular<dimension, float_precision>(vector_a.data(), vector_b.data())) {
                    // If this evaluates true,
                    // we add edge_b to perpendicular_edges.
                    perpendicular_edges.push_back(edge_b);
                }
            }
            else {
                /*
                // If child_node_b is the same as the child_node we passed in, skip it.
                std::cout << " *** SKIPPED ***" << std::endl;
                */
            }
        }
 
        return perpendicular_edges;
    }
 
    std::vector<IntEdge> CalculateCrossSlope(const Subgraph& sg);
 
    std::vector<std::vector<IntEdge>> CalculateCrossSlope(const Graph& g);
 
 
    
    EdgeSet CalculateEnergyExpenditure(const Subgraph& sg);
 
    std::vector<EdgeSet> CalculateEnergyExpenditure(const Graph& g);
 
    /*
        \summary Calculates the slope between two nodes 
        \param parent A Node
        \param child A Node
        \returns A double of the Angle
    */
    double CalculateSlope(Node& parent, Node& child);
}
 
#endif