Added draw method to LispTreeExpr class

* Create a graph with pygraphviz and networkx tools

Author: Ezetowers

MLC/Common/LispTreeExpr/LispTreeExpr.py

@@ -20,11 +20,15 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>
 
 import MLC.Log.log as lg
+import networkx as nx
+import matplotlib.pyplot as plt
 import re
+
 from MLC.mlc_parameters.mlc_parameters import Config
 from MLC.Common.Operations import Operations
 from MLC.Common.LispTreeExpr.TreeNodes import LeafNode, InternalNode
 from MLC.Common.LispTreeExpr.OperationNodes import OpNodeFactory
+from PyQt5.QtCore import Qt
 
 
 class ExprException(Exception):
@@ -75,10 +79,18 @@ def __init__(self, expression):
 
 
 class LispTreeExpr(object):
+    class NodeIdGenerator(object):
+        def __init__(self):
+            self._node_id_counter = 0
+
+        def next_node_id(self):
+            node_id = self._node_id_counter
+            self._node_id_counter += 1
+            return node_id
 
     def __init__(self, expr):
+        self._node_id_generator = LispTreeExpr.NodeIdGenerator()
         self._nodes = []
-
         self._expanded_tree = expr
 
         # Remove the root part of the node
@@ -193,6 +205,28 @@ def simplify_tree(self):
         self._simplified_tree = '(root ' + self._root.to_string() + ')'
         lg.logger_.debug("[LISP_TREE_EXPR] Simplified Expression: " + self._simplified_tree)
 
+    def draw(self):
+        tree = nx.DiGraph()
+        self._root.construct_tree(tree)
+
+        fig = plt.figure()
+        # Put figure window on top of all other windows
+        fig.canvas.manager.window.setWindowModality(Qt.ApplicationModal)
+        fig.canvas.manager.window.setWindowTitle("Individual Tree Representation")
+        ax = fig.add_axes([0, 0, 1, 1])
+        ax.axis('off')
+
+        labels = {}
+        for node_id in tree:
+            labels[node_id] = tree.node[node_id]['value']
+        pos = nx.nx_pydot.graphviz_layout(tree, prog='dot')
+
+        nodes = nx.draw_networkx_nodes(tree, pos, node_size=1000, node_color='#D3D3D3')
+        nodes.set_edgecolor('k')
+        nx.draw_networkx_edges(tree, pos, arrows=False)
+        nx.draw_networkx_labels(tree, pos, labels, font_size=12)
+        plt.show()
+
     def calculate_expression(self, sensor_replacement_list):
         class Replace_Sensors_Visitor(TreeVisitor):
 
@@ -291,23 +325,27 @@ def _generate_leaf_node(self, expr, parent_depth, expr_index):
         else:
             param_len = len(expr)
 
-        leaf = LeafNode(expr[:param_len])
+        leaf = LeafNode(self._node_id_generator.next_node_id(), expr[:param_len])
         leaf.set_depth(parent_depth)
         leaf.set_expr_index(expr_index)
         leaf.set_subtreedepth(0)
         self._nodes.append(leaf)
         return leaf, param_len + 1
 
     # As a precondition, the expression must be well-formed
-    def _generate_node(self, expr, is_root_expression=False, parent_depth=0, expr_index=0):
+    def _generate_node(self, 
+                       expr, 
+                       is_root_expression=False, 
+                       parent_depth=0, 
+                       expr_index=0):
         if expr[0] != '(':
             return self._generate_leaf_node(expr, parent_depth, expr_index)
 
         # We are in the presence of an internal node. Get the operation
         op = self._get_operation(expr, is_root_expression)
 
         # Generate the arguments of the internal node as Child Nodes
-        node = OpNodeFactory.make(op["op"])
+        node = OpNodeFactory.make(op["op"], self._node_id_generator.next_node_id())
         node.set_depth(parent_depth + 1)
         node.set_expr_index(expr_index)
         expr_offset = 0
@@ -320,11 +358,13 @@ def _generate_node(self, expr, is_root_expression=False, parent_depth=0, expr_in
             next_arg_pos = 1 + len(op["op"]) + 1 + expr_offset
 
             if expr[next_arg_pos] == '(':
-                child_node, offset = self._generate_node(
-                    expr[next_arg_pos:], parent_depth=parent_depth + 1, expr_index=expr_index + next_arg_pos)
+                child_node, offset = self._generate_node(expr[next_arg_pos:], 
+                                                         parent_depth=parent_depth + 1, 
+                                                         expr_index=expr_index + next_arg_pos)
             else:
-                child_node, offset = self._generate_leaf_node(
-                    expr[next_arg_pos:], parent_depth=parent_depth + 1, expr_index=expr_index + next_arg_pos)
+                child_node, offset = self._generate_leaf_node(expr[next_arg_pos:],
+                                                              parent_depth=parent_depth + 1,
+                                                              expr_index=expr_index + next_arg_pos)
 
             node.add_child(child_node)
             child_subtreedepth = max(child_subtreedepth, child_node.get_subtreedepth())

MLC/Common/LispTreeExpr/OperationNodes.py

@@ -53,23 +53,23 @@ def execute_op_without_warnings(op, log_prefix, exception_msg, arg1, arg2=None):
 
 class PlusNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "+", 1)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "+", 1)
 
     def formal(self):
         return "(" + self._nodes[0].formal() + " + " + self._nodes[1].formal() + ")"
 
     def op_simplify(self):
         # If one of the arguments is zero, avoid the operation
         if self._node_arg_x_is_y(0, 0):
-            return LeafNode(self._nodes[1].to_string())
+            return LeafNode(self._node_id, self._nodes[1].to_string())
         elif self._node_arg_x_is_y(1, 0):
-            return LeafNode(self._nodes[0].to_string())
+            return LeafNode(self._node_id, self._nodes[0].to_string())
 
         # Non of the arguments are zero. Make the operation if they are not sensors
         if not self._nodes[0].is_sensor() and not self._nodes[1].is_sensor():
             arg = float(self._nodes[0].to_string()) + float(self._nodes[1].to_string())
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -86,25 +86,25 @@ def op_compute(self, arg_list):
 
 class MinusNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "-", 1)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "-", 1)
 
     def formal(self):
         return "(" + self._nodes[0].formal() + " - " + self._nodes[1].formal() + ")"
 
     def op_simplify(self):
         # if both arguments are equals, return 0
         if self._nodes[0].to_string() == self._nodes[1].to_string():
-            return LeafNode(process_float(0))
+            return LeafNode(self._node_id, process_float(0))
 
         # If the second argument is zero, avoid the operation.
         if self._node_arg_x_is_y(1, 0):
-            return LeafNode(self._nodes[0].to_string())
+            return LeafNode(self._node_id, self._nodes[0].to_string())
 
         # Non of the arguments are zero. Make the operation if they are not sensors
         if not self._nodes[0].is_sensor() and not self._nodes[1].is_sensor():
             arg = float(self._nodes[0].to_string()) - float(self._nodes[1].to_string())
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -121,26 +121,26 @@ def op_compute(self, arg_list):
 
 class MultNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "*", 1)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "*", 1)
 
     def formal(self):
         return "(" + self._nodes[0].formal() + " .* " + self._nodes[1].formal() + ")"
 
     def op_simplify(self):
         # If one or both of the arguments are zero, return zero
         if self._node_arg_x_is_y(0, 0) or self._node_arg_x_is_y(1, 0):
-            return LeafNode(process_float(0))
+            return LeafNode(self._node_id, process_float(0))
 
         # If one of the arguments is zero, avoid the operation
         if self._node_arg_x_is_y(0, 1):
-            return LeafNode(self._nodes[1].to_string())
+            return LeafNode(self._node_id, self._nodes[1].to_string())
         elif self._node_arg_x_is_y(1, 1):
-            return LeafNode(self._nodes[0].to_string())
+            return LeafNode(self._node_id, self._nodes[0].to_string())
 
         if not self._nodes[0].is_sensor() and not self._nodes[1].is_sensor():
             arg = float(self._nodes[0].to_string()) * float(self._nodes[1].to_string())
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -159,8 +159,8 @@ class DivisionNode(InternalNode):
     PROTECTION = 0.001
     SIMPLIFY_PROTECTION = 0.01
 
-    def __init__(self):
-        InternalNode.__init__(self, "/", 1)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "/", 1)
 
     def formal(self):
         return "(my_div(" + self._nodes[0].formal() + "," + self._nodes[1].formal() + "))"
@@ -178,19 +178,19 @@ def _process_division(self, dividend, divisor):
     def op_simplify(self):
         # If the first argument is zero, return zero
         if self._node_arg_x_is_y(0, 0):
-            return LeafNode(process_float(0))
+            return LeafNode(self._node_id, process_float(0))
 
         # If the second argument is one, return the first argument
         if self._node_arg_x_is_y(1, 1):
-            return LeafNode(self._nodes[0].to_string())
+            return LeafNode(self._node_id, self._nodes[0].to_string())
 
         if not self._nodes[0].is_sensor() and not self._nodes[1].is_sensor():
             # FIXME: Harcoded number. Change it
             if abs(float(self._nodes[1].to_string())) < DivisionNode.SIMPLIFY_PROTECTION:
-                return LeafNode(process_float(0))
+                return LeafNode(self._node_id, process_float(0))
             else:
                 arg = float(self._nodes[0].to_string()) / float(self._nodes[1].to_string())
-                return LeafNode(process_float(arg))
+                return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -207,16 +207,16 @@ def op_compute(self, arg_list):
 
 class SineNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "sin", 3)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "sin", 3)
 
     def formal(self):
         return "sin(" + self._nodes[0].formal() + ")"
 
     def op_simplify(self):
         if not self._nodes[0].is_sensor():
             arg = np.sin(float(self._nodes[0].to_string()))
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -232,16 +232,16 @@ def op_compute(self, arg_list):
 
 class CosineNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "cos", 3)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "cos", 3)
 
     def formal(self):
         return "cos(" + self._nodes[0].formal() + ")"
 
     def op_simplify(self):
         if not self._nodes[0].is_sensor():
             arg = np.cos(float(self._nodes[0].to_string()))
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -259,8 +259,8 @@ class LogarithmNode(InternalNode):
     PROTECTION = 0.00001
     SIMPLIFY_PROTECTION = 0.01
 
-    def __init__(self):
-        InternalNode.__init__(self, "log", 5)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "log", 5)
 
     def formal(self):
         return "my_log(" + self._nodes[0].formal() + ")"
@@ -281,7 +281,7 @@ def op_simplify(self):
             else:
                 arg = np.log(float(self._nodes[0].to_string()))
 
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -297,8 +297,8 @@ def op_compute(self, arg_list):
 
 class ExponentialNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "exp", 5)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "exp", 5)
 
     def formal(self):
         return "exp(" + self._nodes[0].formal() + ")"
@@ -311,9 +311,9 @@ def op_simplify(self):
             except OverflowError:
                 # FIXME: See what to do with this expression, because there are problems when
                 # an infinite value is the argument of a sinusoidal function
-                return LeafNode(process_float(float("inf")))
+                return LeafNode(self._node_id, process_float(float("inf")))
 
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -329,16 +329,16 @@ def op_compute(self, arg_list):
 
 class TanhNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "tanh", 5)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "tanh", 5)
 
     def formal(self):
         return "tanh(" + self._nodes[0].formal() + ")"
 
     def op_simplify(self):
         if not self._nodes[0].is_sensor():
             arg = np.tanh(float(self._nodes[0].to_string()))
-            return LeafNode(process_float(arg))
+            return LeafNode(self._node_id, process_float(arg))
         else:
             return self
 
@@ -354,8 +354,8 @@ def op_compute(self, arg_list):
 
 class RootNode(InternalNode):
 
-    def __init__(self):
-        InternalNode.__init__(self, "", 0)
+    def __init__(self, node_id):
+        InternalNode.__init__(self, node_id, "", 0)
 
     def to_string(self):
         return " ".join([n.to_string() for n in self._nodes])
@@ -389,9 +389,9 @@ def accept(self, visitor):
 class OpNodeFactory:
 
     @staticmethod
-    def make(op):
+    def make(op, node_id):
         if op == 'root':
-            return RootNode()
+            return RootNode(node_id)
 
         # instatiate node from string
         operation = Operations.get_instance().get_operation_from_op_string(op)
@@ -401,4 +401,4 @@ def make(op):
         node_module = importlib.import_module(node_module_name)
         node_class = getattr(node_module, node_class_name)
 
-        return node_class()
+        return node_class(node_id)