Added comments to 45 functions across 6 files

Author: komment-ai[bot]

agents/g2o_agent/src/g2o_visualizer.py

@@ -5,6 +5,15 @@
 
 class G2OVisualizer:
     def __init__(self, title):
+        """
+        initializes a Figure and Axes object for the visualization of data using
+        Matplotlib. It sets up the graphical interface, defines the title, sets
+        limits for the axes, and flushes events to display the figure on the screen.
+
+        Args:
+            title (str): title of the graphical window displayed by Matplotlib.
+
+        """
         self.title = title
 
         # Configurar la ventana gráfica interactiva de Matplotlib
@@ -22,12 +31,70 @@ def __init__(self, title):
         # self.ax.set_ylim([-3000, 3000])  # Por ejemplo, límites para el eje y de 0 a 10
 
     def edges_coord(self, edges, dim):
+        """
+        takes an iterable of edges and a dimension, it returns a sequence of floats
+        representing the coordinates of the vertices of each edge, followed by
+        three `None` values to indicate the end of the sequence.
+
+        Args:
+            edges (iterable/collection containing edges as its values.): 2-D graph
+                edges, which are used to estimate their corresponding coordinate
+                values for each dimension.
+                
+                		- `edges` is an instance of `List[Edge']`, where `Edge' =
+                Tuple[Void, Void]`.
+                		- Each element in `edges` represents a pair of vertices connected
+                by an edge. The first element in each pair is the start vertex,
+                while the second element is the end vertex.
+                		- The `dim` parameter specifies the dimensionality of the
+                coordinates for each vertex in the edges.
+            dim (int): dimensionality of the space in which the coordinates are estimated.
+
+        """
         for e in edges:
             yield e.vertices()[0].estimate()[dim]
             yield e.vertices()[1].estimate()[dim]
             yield None
 
     def update_graph(self, optimizer, ground_truth=None):
+        """
+        updates the graph shown on a figure with the latest measurements from an
+        optimizer, ground truth data (if provided), and poses of the vertices.
+
+        Args:
+            optimizer (`g2o.Optimizer` object, as seen by inspecting it directly
+                with Python's built-in `inspect` module, without further evaluation
+                or contextualizing.): 3D object pose optimization instance, which
+                provides the updated vertices and edges information through the
+                `edges()` and `vertices()` methods.
+                
+                	1/ `edges`: A list of edges in the graph, where each edge is an
+                instance of `g2o.Edge`.
+                	2/ `vertices`: A dictionary containing the positions of the
+                vertices in the graph, where each key is a vertex index and each
+                value is a 3D vector representing the vertex position.
+                	3/ `edges_coord`: A function that maps an edge list to a 2D list
+                of coordinate pairs, where each pair represents a point on the edge.
+                	4/ `poses`: A list of 3D vectors representing the poses of the
+                vertices in the graph.
+                	5/ `measurments`: A list of 2D points representing the measurements
+                obtained from the optimizer.
+                	6/ `rotation`: An instance of `g2o.Quaternion` representing the
+                rotation of each vertex in the graph.
+            ground_truth (ndarray or a Python object representing a 2D numpy array
+                containing the ground truth pose coordinates for the objects in
+                the scene.): 3D positions of the robot's body or reference points,
+                which are used to compare and visualize the estimated poses from
+                the optimization process.
+                
+                		- If `ground_truth` is not `None`, it represents the ground truth
+                data for the robot pose and measurement edges.
+                		- `ground_truth[0]` and `ground_truth[1]` denote the positions
+                of the robot in SE(2) format, i.e., (x, y, z) where x, y, and z
+                are the coordinates in the world frame.
+                		- `ground_truth.shape` gives the number of pose data points.
+
+        """
         self.ax.clear()
         # Fijar límites de los ejes
         # self.ax.set_xlim([-3000, 3000])  # Por ejemplo, límites para el eje x de 0 a 10

agents/g2o_agent/src/genericworker.py

@@ -45,6 +45,39 @@ class GenericWorker(QtWidgets.QWidget):
     kill = QtCore.Signal()
 
     def __init__(self, mprx):
+        """
+        sets up a worker object's user interface, creates a mutex for synchronization,
+        and initializes a timer to periodically check the system status every 30
+        seconds.
+
+        Args:
+            mprx (`Ui_guiDlg`.): GUI widget used for initializing the UI of the
+                `GenericWorker` class.
+                
+                		- `super(GenericWorker, self).__init__()` calls the constructor
+                of the base class, which sets up the necessary objects and members.
+                		- `self.ui = Ui_guiDlg()` creates a new instance of the `Ui_guiDlg`
+                class, which is a user interface class. The `Ui_guiDlg` object is
+                then set as a member of the current instance using the assignment
+                operator (`=`).
+                		- `self.ui.setupUi(self)` calls a method on the `Ui_guiDlg` class
+                to set up the user interface for the current instance.
+                		- `self.show()` displays the user interface of the current instance.
+                		- `self.mutex = QtCore.QMutex(QtCore.QMutex.Recursive)` creates
+                a new instance of the `QMutex` class, which is used to synchronize
+                access to the methods of the current instance. The `QMutex.Recursive`
+                argument specifies that the mutex should be recursive, meaning
+                that it can be acquired and released multiple times during its lifetime.
+                		- `self.Period = 30` sets a variable called `Period` to the value
+                30. This variable represents the interval at which the current
+                instance will execute its timer function.
+                		- `self.timer = QtCore.QTimer(self)` creates a new instance of
+                the `QTimer` class, which is used to schedule execution of methods
+                on the current instance at a later time. The `QTimer` object is
+                set as a member of the current instance using the assignment
+                operator (`=`).
+
+        """
         super(GenericWorker, self).__init__()
 
 
@@ -59,13 +92,27 @@ def __init__(self, mprx):
 
     @QtCore.Slot()
     def killYourSelf(self):
+        """
+        emits the `kill` signal, which is catchable and causes an immediate
+        termination of the program.
+
+        """
         rDebug("Killing myself")
         self.kill.emit()
 
     # \brief Change compute period
     # @param per Period in ms
     @QtCore.Slot(int)
     def setPeriod(self, p):
+        """
+        sets the ` Period ` attribute and starts a timer with the new period using
+        the `timer.start()` method.
+
+        Args:
+            p (int): new period value, which is then assigned to the instance
+                attribute ` Period ` and used to set the timer interval.
+
+        """
         print("Period changed", p)
         self.Period = p
         self.timer.start(self.Period)