removed redundant EdgeOrientation

Author: ettoh

include/dmsc/edge.hpp

@@ -8,8 +8,6 @@
 
 namespace dmsc {
 
-using EdgeOrientation = std::pair<glm::vec3, glm::vec3>;
-
 class InterSatelliteLink {
   public:
     InterSatelliteLink(const uint32_t& v1_idx, const uint32_t& v2_idx, const std::vector<Satellite>& satellites,
@@ -70,22 +68,22 @@ class InterSatelliteLink {
      * @param t [sec] Time when the satellites have to face each other.
      */
     bool canAlign(const TimelineEvent<glm::vec3>& sat1, const TimelineEvent<glm::vec3>& sat2, const float t) const {
-        EdgeOrientation target = getOrientation(t);
+        glm::vec3 target = getOrientation(t);
         float angle_sat1 = .0f;
         float angle_sat2 = .0f;
         float time_sat1 = .0f;
         float time_sat2 = .0f;
 
         // calc angle between orientations; direction vectors must be length 1
         if (sat1.isValid()) {
-            angle_sat1 = std::acos(glm::dot(sat1.data, target.first)); // [rad]
+            angle_sat1 = std::acos(glm::dot(sat1.data, target)); // [rad]
             time_sat1 = sat1.t_begin;
         } else {
             time_sat1 = 0.f; // event is invalid, so assume that sat1 was not part of a communication yet
         }
 
         if (sat2.isValid()) {
-            angle_sat2 = std::acos(glm::dot(sat2.data, target.second)); // [rad]
+            angle_sat2 = std::acos(glm::dot(sat2.data, -target)); // [rad]
             time_sat2 = sat2.t_begin;
         } else {
             time_sat2 = 0.f; // event is invalid, so assume that sat1 was not part of a communication yet
@@ -104,15 +102,15 @@ class InterSatelliteLink {
     }
 
     /**
-     * @brief Calculate the directions for both satellites to face each other.
+     * @brief Calculate the directions for both satellites to face each other. Because both satellites have to face each
+     * other, the direction of satellite A is the negative direction of satellite B.
      * @param t [sec] time
-     * @return Two direction vectors at the time when they face each other.
+     * @return Direction vector for one of the satellites (origin) at the time when they face each other.
      */
-    EdgeOrientation getOrientation(const float time) const {
+    glm::vec3 getOrientation(const float time) const {
         glm::vec3 sat1 = v1->cartesian_coordinates(time);
         glm::vec3 sat2 = v2->cartesian_coordinates(time);
-
-        return {glm::normalize(sat2 - sat1), glm::normalize(sat1 - sat2)};
+        return glm::normalize(sat2 - sat1);
     }
 
     // GETTER

src/opengl_widgets.cpp

@@ -699,12 +699,12 @@ void OpenGLWidget::prepareSolutionScene(const PhysicalInstance& instance, const
 
         float t = scan.second; // time when edge is scheduled
         const InterSatelliteLink& isl = problem_instance.getISLs().at(scan.first);
-        EdgeOrientation needed_orientation = isl.getOrientation(t);
+        glm::vec3 needed_orientation = isl.getOrientation(t);
 
         // add corresponding events for both satellites where they have to face in the needed
         // direction in order to perform the scan
-        TimelineEvent<glm::vec3> orientation_sat1 = TimelineEvent<glm::vec3>(t, t, needed_orientation.first);
-        TimelineEvent<glm::vec3> orientation_sat2 = TimelineEvent<glm::vec3>(t, t, needed_orientation.second);
+        TimelineEvent<glm::vec3> orientation_sat1 = TimelineEvent<glm::vec3>(t, t, needed_orientation);
+        TimelineEvent<glm::vec3> orientation_sat2 = TimelineEvent<glm::vec3>(t, t, -needed_orientation);
         bool res_1 = satellite_orientations[&isl.getV1()].insert(orientation_sat1);
         bool res_2 = satellite_orientations[&isl.getV2()].insert(orientation_sat2);
 

src/solver/greedy_next.cpp

@@ -46,9 +46,9 @@ Solution GreedyNext::solve() {
 
         // refresh orientation of chosen satellites.
         const InterSatelliteLink* e = remaining_edges.at(best_edge_pos);
-        EdgeOrientation new_orientations = e->getOrientation(t_next);
-        satellite_orientation[&e->getV1()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations.first);
-        satellite_orientation[&e->getV2()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations.second);
+        glm::vec3 new_orientations = e->getOrientation(t_next);
+        satellite_orientation[&e->getV1()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations);
+        satellite_orientation[&e->getV2()] = TimelineEvent<glm::vec3>(t_next, t_next, -new_orientations);
 
         // map position in remaining edges to position in all edges
         std::ptrdiff_t edge_index = remaining_edges[best_edge_pos] - &instance.getISLs()[0];

src/solver/greedy_next_khop.cpp

@@ -100,9 +100,9 @@ Solution GreedyNextKHop::solve() {
         }
 
         // update satellite orientations
-        EdgeOrientation new_orientations = isl->getOrientation(t_next);
-        satellite_orientation[&isl->getV1()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations.first);
-        satellite_orientation[&isl->getV2()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations.second);
+        glm::vec3 new_orientations = isl->getOrientation(t_next);
+        satellite_orientation[&isl->getV1()] = TimelineEvent<glm::vec3>(t_next, t_next, new_orientations);
+        satellite_orientation[&isl->getV2()] = TimelineEvent<glm::vec3>(t_next, t_next, -new_orientations);
 
         // update time
         curr_time = t_next;