visualizer: Fix overlapping labels and Simulation stop time

Author: Alberto Gallegos Ramonet

src/visualizer/model/pyviz.cc

@@ -261,7 +261,7 @@ PyViz::CallbackStopSimulation()
     NS_LOG_FUNCTION_NOARGS();
     if (m_runUntil <= Simulator::Now())
     {
-        Simulator::Stop(Seconds(0)); // Stop right now
+        Simulator::Stop(); // Stop right now
         m_stop = true;
     }
 }
@@ -307,6 +307,7 @@ PyViz::SimulatorRunUntil(Time time)
     {
         return;
     }
+
     // Schedule a dummy callback function for the target time, to make
     // sure we stop at the right time.  Otherwise, simulations with few
     // events just appear to "jump" big chunks of time.
@@ -330,6 +331,14 @@ PyViz::SimulatorRunUntil(Time time)
     }
 }
 
+Time
+PyViz::GetSimulatorStopTime()
+{
+    Ptr<SimulatorImpl> impl = Simulator::GetImplementation();
+    Ptr<VisualSimulatorImpl> visualImpl = DynamicCast<VisualSimulatorImpl>(impl);
+    return visualImpl->GetStopTime();
+}
+
 bool
 PyViz::TransmissionSampleKey::operator<(const PyViz::TransmissionSampleKey& other) const
 {

src/visualizer/model/pyviz.h

@@ -71,6 +71,12 @@ class PyViz
      */
     void SimulatorRunUntil(Time time);
 
+    /**
+     * Get the stop time of the underlying visual simulator implementation.
+     * @return The stop time of the visual simulator implementation.
+     */
+    Time GetSimulatorStopTime();
+
     /**
      * Pause function
      * @param message the pause message

src/visualizer/model/visual-simulator-impl.cc

@@ -132,9 +132,16 @@ VisualSimulatorImpl::Stop()
 EventId
 VisualSimulatorImpl::Stop(const Time& delay)
 {
+    m_stopTime = delay;
     return m_simulator->Stop(delay);
 }
 
+Time
+VisualSimulatorImpl::GetStopTime()
+{
+    return m_stopTime;
+}
+
 //
 // Schedule an event for a _relative_ time in the future.
 //

src/visualizer/model/visual-simulator-impl.h

@@ -62,6 +62,12 @@ class VisualSimulatorImpl : public SimulatorImpl
     uint32_t GetContext() const override;
     uint64_t GetEventCount() const override;
 
+    /**
+     * Get the simulator implementation stop time.
+     * @returns The stop time of the simulation implementation.
+     */
+    Time GetStopTime();
+
     /// calls Run() in the wrapped simulator
     void RunRealSimulator();
 
@@ -70,8 +76,9 @@ class VisualSimulatorImpl : public SimulatorImpl
     void NotifyConstructionCompleted() override;
 
   private:
-    Ptr<SimulatorImpl> m_simulator;       ///< the simulator implementation
-    ObjectFactory m_simulatorImplFactory; ///< simulator implementation factory
+    Ptr<SimulatorImpl> m_simulator;       //!< The simulator implementation
+    ObjectFactory m_simulatorImplFactory; //!< Simulator implementation factory
+    Time m_stopTime;                      //!< The stop time of the simulation
 };
 
 } // namespace ns3

src/visualizer/visualizer/core.py

@@ -83,9 +83,6 @@
     transform_point_simulation_to_canvas,
 )
 
-PI_OVER_2 = math.pi / 2
-PI_TIMES_2 = math.pi * 2
-
 
 ## Node class
 class Node(PyVizObject):
@@ -712,18 +709,19 @@ def run(self):
             # print "sim: Acquire lock"
             self.lock.acquire()
             try:
-                if 0:
-                    if ns3.Simulator.IsFinished():
-                        self.viz.play_button.set_sensitive(False)
-                        break
                 # print "sim: Current time is %f; Run until: %f" % (ns3.Simulator.Now ().GetSeconds (), self.target_time)
-                # if ns3.Simulator.Now ().GetSeconds () > self.target_time:
                 #    print "skipping, model is ahead of view!"
                 self.sim_helper.SimulatorRunUntil(ns.Seconds(self.target_time))
                 # print "sim: Run until ended at current time: ", ns3.Simulator.Now ().GetSeconds ()
                 self.pause_messages.extend(self.sim_helper.GetPauseMessages())
                 GLib.idle_add(self.viz.update_model, priority=PRIORITY_UPDATE_MODEL)
-                # print "sim: Run until: ", self.target_time, ": finished."
+
+                if (
+                    ns.Simulator.Now().GetSeconds()
+                    >= self.sim_helper.GetSimulatorStopTime().GetSeconds()
+                ):
+                    GLib.idle_add(self.viz._on_simulation_finished)
+                    break
             finally:
                 self.lock.release()
             # print "sim: Release lock, loop."
@@ -1435,18 +1433,24 @@ def _update_transmissions_view(self):
                 visibility_threshold=0.5,
                 font=("Sans Serif %f" % int(1 + BITRATE_FONT_SIZE * k)),
             )
+
             angle = math.atan2((pos2_y - pos1_y), (pos2_x - pos1_x))
-            if -PI_OVER_2 <= angle <= PI_OVER_2:
+            if angle > math.pi / 2 or angle < -math.pi / 2:
+                # Normalize the angle, in essence, adjust the angle to keep
+                # it from rotating beyond +/- 90 degrees. In this way, the
+                # direction of the label remain always readable regardless of
+                # the angle.
+                angle += math.pi
                 label.set_properties(
-                    text=("%.2f kbit/s →" % (kbps,)),
+                    text=("← %.2f kbit/s" % (kbps,)),
                     alignment=Pango.Alignment.CENTER,
                     anchor=GooCanvas.CanvasAnchorType.S,
                     x=0,
                     y=-line_width / 2,
                 )
             else:
                 label.set_properties(
-                    text=("← %.2f kbit/s" % (kbps,)),
+                    text=("%.2f kbit/s →" % (kbps,)),
                     alignment=Pango.Alignment.CENTER,
                     anchor=GooCanvas.CanvasAnchorType.N,
                     x=0,
@@ -1544,6 +1548,14 @@ def _update_drops_view(self):
 
         self._drop_arrows = new_arrows + old_arrows
 
+    def _on_simulation_finished(self):
+        print("Simulation finished.")
+        if self._update_timeout_id is not None:
+            GLib.source_remove(self._update_timeout_id)
+            self._update_timeout_id = None
+        self.play_button.set_active(False)
+        self.play_button.set_sensitive(False)
+
     def update_view_timeout(self):
         # print "view: update_view_timeout called at real time ", time.time()