From 026c3e10379c5c670b8db1f0aae36a1a80051738 Mon Sep 17 00:00:00 2001
From: hagrid67 <jdhwatson@gmail.com>
Date: Sat, 11 May 2019 19:19:52 +0100
Subject: [PATCH] improvements to editor2.ipynb

---
 examples/play_model.py                   |  26 ++--
 flatland/core/env_observation_builder.py |   2 +-
 flatland/envs/agent_utils.py             |   2 +-
 flatland/envs/rail_env.py                |  27 ++--
 flatland/utils/editor.py                 | 147 +++++++++++++++++-----
 flatland/utils/graphics_layer.py         |  20 +--
 flatland/utils/render_qt.py              |   3 +-
 flatland/utils/rendertools.py            |  50 ++++----
 notebooks/Editor2.ipynb                  | 151 ++++++++++++++++++++---
 9 files changed, 323 insertions(+), 105 deletions(-)

diff --git a/examples/play_model.py b/examples/play_model.py
index 9c67b0b..c7c8074 100644
--- a/examples/play_model.py
+++ b/examples/play_model.py
@@ -39,9 +39,9 @@ class Player(object):
         # self.obs = self.env.reset()
         self.env.obs_builder.reset()
         self.obs = self.env._get_observations()
-        for a in range(self.env.number_of_agents):
-            norm = max(1, max_lt(self.obs[a], np.inf))
-            self.obs[a] = np.clip(np.array(self.obs[a]) / norm, -1, 1)
+        for envAgent in self.env.get_agent_handles():
+            norm = max(1, max_lt(self.obs[envAgent], np.inf))
+            self.obs[envAgent] = np.clip(np.array(self.obs[envAgent]) / norm, -1, 1)
 
         # env.obs_builder.util_print_obs_subtree(tree=obs[0], num_elements_per_node=5)
 
@@ -52,23 +52,25 @@ class Player(object):
         env = self.env
 
         # Pass the (stored) observation to the agent network and retrieve the action
-        for a in range(env.number_of_agents):
-            action = self.agent.act(np.array(self.obs[a]), eps=self.eps)
+        for handle in env.get_agent_handles():
+            action = self.agent.act(np.array(self.obs[handle]), eps=self.eps)
             self.action_prob[action] += 1
-            self.action_dict.update({a: action})
+            self.action_dict.update({handle: action})
 
         # Environment step - pass the agent actions to the environment,
         # retrieve the response - observations, rewards, dones
         next_obs, all_rewards, done, _ = self.env.step(self.action_dict)
 
-        for a in range(env.number_of_agents):
-            norm = max(1, max_lt(next_obs[a], np.inf))
-            next_obs[a] = np.clip(np.array(next_obs[a]) / norm, -1, 1)
+        for handle in env.get_agent_handles():
+            norm = max(1, max_lt(next_obs[handle], np.inf))
+            next_obs[handle] = np.clip(np.array(next_obs[handle]) / norm, -1, 1)
 
         # Update replay buffer and train agent
-        for a in range(self.env.number_of_agents):
-            self.agent.step(self.obs[a], self.action_dict[a], all_rewards[a], next_obs[a], done[a], train=False)
-            self.score += all_rewards[a]
+        for handle in self.env.get_agent_handles():
+            self.agent.step(self.obs[handle], self.action_dict[handle],
+                all_rewards[handle], next_obs[handle], done[handle],
+                train=False)
+            self.score += all_rewards[handle]
 
         self.iFrame += 1
 
diff --git a/flatland/core/env_observation_builder.py b/flatland/core/env_observation_builder.py
index 43884a4..a357f42 100644
--- a/flatland/core/env_observation_builder.py
+++ b/flatland/core/env_observation_builder.py
@@ -77,7 +77,7 @@ class TreeObsForRailEnv(ObservationBuilder):
         self.location_has_target = {}
         # for loc in self.env.agents_target:
         #    self.location_has_target[(loc[0], loc[1])] = 1
-        self.location_has_target = {agent.position: 1 for agent in agents}
+        self.location_has_target = {tuple(agent.target): 1 for agent in agents}
 
     def _distance_map_walker(self, position, target_nr):
         """
diff --git a/flatland/envs/agent_utils.py b/flatland/envs/agent_utils.py
index da36fe7..6ef8aa4 100644
--- a/flatland/envs/agent_utils.py
+++ b/flatland/envs/agent_utils.py
@@ -10,7 +10,7 @@ class EnvDescription(object):
     height = attrib()
     width = attrib()
     rail_generator = attrib()
-    obs_builder = attrib()
+    obs_builder = attrib()   # not sure if this should closer to the agent than the env
 
 
 @attrs
diff --git a/flatland/envs/rail_env.py b/flatland/envs/rail_env.py
index 9767bba..e2a7510 100644
--- a/flatland/envs/rail_env.py
+++ b/flatland/envs/rail_env.py
@@ -101,30 +101,38 @@ class RailEnv(Environment):
         # self.agents_position = []
         # self.agents_target = []
         # self.agents_direction = []
-        self.agents = []
+        self.agents = []  # live agents
+        self.agents_static = []  # static agent information
         self.num_resets = 0
         self.reset()
-        self.num_resets = 0
+        self.num_resets = 0   # yes, set it to zero again!
 
         self.valid_positions = None
 
     def get_agent_handles(self):
         return self.agents_handles
 
+    def add_agent_static(self, agent_static):
+        """ Add static info for a single agent.
+            Returns the index of the new agent.
+        """
+        self.agents_static.append(agent_static)
+        return len(self.agents_static) - 1
+
     def reset(self, regen_rail=True, replace_agents=True):
         """
         TODO: replace_agents is ignored at the moment; agents will always be replaced.
         """
+        tRailAgents = self.rail_generator(self.width, self.height, self.agents_handles, self.num_resets)
+
         if regen_rail or self.rail is None:
-            self.rail, agents_position, agents_direction, agents_target = self.rail_generator(
-                self.width,
-                self.height,
-                self.agents_handles,
-                self.num_resets)
+            self.rail = tRailAgents[0]
 
         if replace_agents:
-            self.agents_static = EnvAgentStatic.from_lists(agents_position, agents_direction, agents_target)
-            self.agents = EnvAgent.list_from_static(self.agents_static[:len(self.agents_handles)])
+            self.agents_static = EnvAgentStatic.from_lists(*tRailAgents[1:4])
+
+        # Take the agent static info and put (live) agents at the start positions
+        self.agents = EnvAgent.list_from_static(self.agents_static[:len(self.agents_handles)])
 
         self.num_resets += 1
 
@@ -288,3 +296,4 @@ class RailEnv(Environment):
         # TODO:
         pass
 
+    
\ No newline at end of file
diff --git a/flatland/utils/editor.py b/flatland/utils/editor.py
index f97cb6d..a48c6b9 100644
--- a/flatland/utils/editor.py
+++ b/flatland/utils/editor.py
@@ -15,14 +15,16 @@ import os
 # from ipywidgets import IntSlider, link, VBox
 
 from flatland.envs.rail_env import RailEnv, random_rail_generator
+from flatland.envs.generators import complex_rail_generator
 # from flatland.core.transitions import RailEnvTransitions
 from flatland.core.env_observation_builder import TreeObsForRailEnv
 import flatland.utils.rendertools as rt
 from examples.play_model import Player
 from flatland.envs.env_utils import mirror
+from flatland.envs.agent_utils import EnvAgent, EnvAgentStatic
 
 import ipywidgets
-from ipywidgets import IntSlider, VBox, HBox, Checkbox, Output, Text
+from ipywidgets import IntSlider, VBox, HBox, Checkbox, Output, Text, RadioButtons, Tab
 import jpy_canvas
 
 
@@ -54,7 +56,8 @@ class View(object):
         return self.wMain
 
     def init_canvas(self):
-        self.oRT = rt.RenderTool(self.editor.env, gl=self.sGL)
+        # update the rendertool with the env
+        self.new_env()
         plt.figure(figsize=(10, 10))
         self.oRT.renderEnv(spacing=False, arrows=False, sRailColor="gray", show=False)
         img = self.oRT.getImage()
@@ -96,14 +99,34 @@ class View(object):
         self.wSize = IntSlider(value=10, min=5, max=30, step=5, description="Regen Size")
         self.wSize.observe(self.controller.setRegenSize, names="value")
 
+        # Number of Agents when regenerating
+        self.wNAgents = IntSlider(value=1, min=0, max=20, step=1, description="# Agents")
+
+        self.wRegenMethod = RadioButtons(description="Regen\nMethod", options=["Random Cell", "Path-based"])
+        self.wReplaceAgents = Checkbox(value=True, description="Replace Agents")
+
+        self.wTab = Tab()
+        tab_contents = ["Debug", "Regen"]
+        for i, title in enumerate(tab_contents):
+            self.wTab.set_title(i, title)
+        self.wTab.children = [
+            VBox([self.wDebug, self.wDebug_move]),
+            VBox([self.wRegenMethod, self.wReplaceAgents])
+            ]
+
         # Progress bar intended for stepping in the background (not yet working)
         self.wProg_steps = ipywidgets.IntProgress(value=0, min=0, max=20, step=1, description="Step")
 
         # abbreviated description of buttons and the methods they call
         ldButtons = [
-            dict(name="Refresh", method=self.controller.refresh),
-            dict(name="Clear", method=self.controller.clear),
-            dict(name="Regenerate", method=self.controller.regenerate),
+            dict(name="Refresh", method=self.controller.refresh, tip="Redraw only"),
+            dict(name="Clear", method=self.controller.clear, tip="Clear rails and agents"),
+            dict(name="Reset", method=self.controller.reset,
+                tip="Standard env reset, including regen rail + agents"),
+            dict(name="Restart Agents", method=self.controller.restartAgents,
+                tip="Move agents back to start positions"),
+            dict(name="Regenerate", method=self.controller.regenerate,
+                tip="Regenerate the rails using the method selected below"),
             dict(name="Load", method=self.controller.load),
             dict(name="Save", method=self.controller.save),
             dict(name="Step", method=self.controller.step),
@@ -112,7 +135,8 @@ class View(object):
 
         self.lwButtons = []
         for dButton in ldButtons:
-            wButton = ipywidgets.Button(description=dButton["name"])
+            wButton = ipywidgets.Button(description=dButton["name"],
+                tooltip=dButton["tip"] if "tip" in dButton else dButton["name"])
             wButton.on_click(dButton["method"])
             self.lwButtons.append(wButton)
 
@@ -120,8 +144,10 @@ class View(object):
             self.wFilename,  # self.wDrawMode,
             *self.lwButtons,
             self.wSize,
-            self.wDebug, self.wDebug_move,
-            self.wProg_steps])
+            self.wNAgents,
+            self.wProg_steps,
+            self.wTab
+            ])
 
         self.wMain = HBox([self.wImage, self.wVbox_controls])
 
@@ -129,17 +155,20 @@ class View(object):
         pass
 
     def new_env(self):
-        self.oRT = rt.RenderTool(self.editor.env)
+        """ Tell the view to update its graphics when a new env is created.
+        """
+        self.oRT = rt.RenderTool(self.editor.env, gl=self.sGL)
 
     def redraw(self):
         # TODO: bit of a hack - can we suppress the console messages from MPL at source?
         # with redirect_stdout(stdout_dest):
         with self.wOutput:
-            plt.figure(figsize=(10, 10))
-            self.oRT.renderEnv(spacing=False, arrows=False, sRailColor="gray", show=False)
+            # plt.figure(figsize=(10, 10))
+            self.oRT.renderEnv(spacing=False, arrows=False, sRailColor="gray",
+                show=False, iSelectedAgent=self.model.iSelectedAgent)
             img = self.oRT.getImage()
-            plt.clf()
-            plt.close()
+            # plt.clf()
+            # plt.close()
 
             self.wImage.data = img
             self.writableData = np.copy(self.wImage.data)
@@ -193,7 +222,7 @@ class Controller(object):
         bShift = event["shiftKey"]
         bCtrl = event["ctrlKey"]
         if bCtrl and not bShift:
-            self.model.add_agent(rcCell)
+            self.model.click_agent(rcCell)
         elif bShift and bCtrl:
             self.model.add_target(rcCell)
 
@@ -271,8 +300,18 @@ class Controller(object):
     def clear(self, event):
         self.model.clear()
 
+    def reset(self, event):
+        self.log("Reset - nAgents:", self.view.wNAgents.value)
+        self.model.reset(replace_agents=self.view.wReplaceAgents.value,
+                         nAgents=self.view.wNAgents.value)
+
+    def restartAgents(self, event):
+        self.log("Restart Agents - nAgents:", self.view.wNAgents.value)
+        self.model.restartAgents()
+
     def regenerate(self, event):
-        self.model.regenerate()
+        method = self.view.wRegenMethod.value
+        self.model.regenerate(method)
 
     def setRegenSize(self, event):
         self.model.setRegenSize(event["new"])
@@ -315,7 +354,7 @@ class EditorModel(object):
         self.drawMode = "Draw"
         self.env_filename = "temp.npy"
         self.set_env(env)
-        self.iAgent = None
+        self.iSelectedAgent = None
         self.player = None
         self.thread = None
 
@@ -325,8 +364,8 @@ class EditorModel(object):
         """
         self.env = env
         self.yxBase = array([6, 21])  # pixel offset
-        self.nPixCell = 700 / self.env.rail.width  # 35
-        self.oRT = rt.RenderTool(env)
+        # self.nPixCell = 700 / self.env.rail.width  # 35
+        # self.oRT = rt.RenderTool(env)
 
     def setDebug(self, bDebug):
         self.bDebug = bDebug
@@ -489,14 +528,25 @@ class EditorModel(object):
     def clear(self):
         self.env.rail.grid[:, :] = 0
         self.env.number_of_agents = 0
-        self.env.agents_position = []
-        self.env.agents_direction = []
+        self.env.agents = []
+        self.env.agents_static = []
         self.env.agents_handles = []
-        self.env.agents_target = []
         self.player = None
 
         self.redraw()
 
+    def reset(self, replace_agents=False, nAgents=0):
+        if replace_agents:
+            self.env.agents_handles = range(nAgents)
+        self.env.reset(regen_rail=True, replace_agents=replace_agents)
+        self.player = Player(self.env)
+        self.redraw()
+
+    def restartAgents(self):
+        self.env.agents = EnvAgent.list_from_static(self.env.agents_static)
+        self.player = Player(self.env)
+        self.redraw()
+
     def setFilename(self, filename):
         self.log("filename = ", filename, type(filename))
         self.env_filename = filename
@@ -515,11 +565,17 @@ class EditorModel(object):
         self.log("save to ", self.env_filename, " working dir: ", os.getcwd())
         self.env.rail.save_transition_map(self.env_filename)
 
-    def regenerate(self):
+    def regenerate(self, method=None):
         self.log("Regenerate size", self.regen_size)
+
+        if method is None or method == "Random Cell":
+            fnMethod = random_rail_generator(cell_type_relative_proportion=[1] * 11)
+        else:
+            fnMethod = complex_rail_generator(nr_start_goal=5, nr_extra=20, min_dist=12)
+
         self.env = RailEnv(width=self.regen_size,
                            height=self.regen_size,
-                           rail_generator=random_rail_generator(cell_type_relative_proportion=[1, 1] + [0.5] * 6),
+                           rail_generator=fnMethod,
                            number_of_agents=self.env.number_of_agents,
                            obs_builder_object=TreeObsForRailEnv(max_depth=2))
         self.env.reset(regen_rail=True)
@@ -532,14 +588,49 @@ class EditorModel(object):
     def setRegenSize(self, size):
         self.regen_size = size
 
-    def add_agent(self, rcCell):
-        self.iAgent = self.env.add_agent(rcCell, rcCell, None)
-        self.player = None  # will need to start a new player
+    def find_agent_at(self, rcCell):
+        for iAgent, agent in enumerate(self.env.agents_static):
+            if tuple(agent.position) == tuple(rcCell):
+                return iAgent
+        return None
+
+    def click_agent(self, rcCell):
+        """ The user has clicked on a cell -
+            - If there is an agent, select it
+                - If that agent was already selected, then deselect it
+            - If there is no agent selected, and no agent in the cell, create one
+            - If there is an agent selected, and no agent in the cell, move the selected agent to the cell
+        """
+
+        # Has the user clicked on an existing agent?
+        iAgent = self.find_agent_at(rcCell)
+        
+        if iAgent is None:
+            # No
+            if self.iSelectedAgent is None:
+                # Create a new agent and select it.
+                agent_static = EnvAgentStatic(rcCell, 0, rcCell)
+                self.iSelectedAgent = self.env.add_agent_static(agent_static)
+                self.player = None  # will need to start a new player
+            else:
+                # Move the selected agent to this cell
+                agent_static = self.env.agents_static[self.iSelectedAgent]
+                agent_static.position = rcCell
+        else:
+            # Yes
+            # Have they clicked on the agent already selected?
+            if self.iSelectedAgent is not None and iAgent == self.iSelectedAgent:
+                # Yes - deselect the agent
+                self.iSelectedAgent = None
+            else:
+                # No - select the agent
+                self.iSelectedAgent = iAgent
+
         self.redraw()
 
     def add_target(self, rcCell):
-        if self.iAgent is not None:
-            self.env.agents_target[self.iAgent] = rcCell
+        if self.iSelectedAgent is not None:
+            self.env.agents_static[self.iSelectedAgent].target = rcCell
             self.redraw()
 
     def step(self):
diff --git a/flatland/utils/graphics_layer.py b/flatland/utils/graphics_layer.py
index 6268e84..b96538d 100644
--- a/flatland/utils/graphics_layer.py
+++ b/flatland/utils/graphics_layer.py
@@ -37,18 +37,24 @@ class GraphicsLayer(object):
     def getImage(self):
         pass
 
-    def adaptColor(self, color):
-        if color == "red" or color == "r":
-            color = (255, 0, 0)
-        elif color == "gray":
-            color = (128, 128, 128)
+    def adaptColor(self, color, lighten=False):
+        if type(color) is str:
+            if color == "red" or color == "r":
+                color = (255, 0, 0)
+            elif color == "gray":
+                color = (128, 128, 128)
         elif type(color) is list:
             color = tuple((array(color) * 255).astype(int))
         elif type(color) is tuple:
-            gcolor = array(color)
-            color = tuple((gcolor[:3] * 255).astype(int))
+            if type(color[0]) is not int:
+                gcolor = array(color)
+                color = tuple((gcolor[:3] * 255).astype(int))
         else:
             color = self.tColGrid
+        
+        if lighten:
+            color = tuple([int(255 - (255 - iRGB) / 3) for iRGB in color])
+
         return color
 
     def get_cmap(self, *args, **kwargs):
diff --git a/flatland/utils/render_qt.py b/flatland/utils/render_qt.py
index 29fdec5..19982f2 100644
--- a/flatland/utils/render_qt.py
+++ b/flatland/utils/render_qt.py
@@ -36,7 +36,7 @@ class QTGL(GraphicsLayer):
         self.qtr.pop()
         self.qtr.endFrame()
 
-    def plot(self, gX, gY, color=None, linewidth=2, **kwargs):
+    def plot(self, gX, gY, color=None, lw=2, **kwargs):
         color = self.adaptColor(color)
 
         self.qtr.setLineColor(*color)
@@ -54,6 +54,7 @@ class QTGL(GraphicsLayer):
         else:
             # print(gX, gY)
             gPoints = np.stack([array(gX), -array(gY)]).T * self.cell_pixels
+            self.qtr.setLineWidth(5)
             self.qtr.drawPolyline(gPoints)
 
     def scatter(self, gX, gY, color=None, marker="o", s=50, *args, **kwargs):
diff --git a/flatland/utils/rendertools.py b/flatland/utils/rendertools.py
index c2fcb73..86917f3 100644
--- a/flatland/utils/rendertools.py
+++ b/flatland/utils/rendertools.py
@@ -61,12 +61,13 @@ class MPLGL(GraphicsLayer):
 
     def clf(self):
         plt.clf()
+        plt.close()
 
     def get_cmap(self, *args, **kwargs):
         return plt.get_cmap(*args, **kwargs)
 
     def beginFrame(self):
-        # plt.figure(figsize=(10, 10))
+        plt.figure(figsize=(10, 10))
         pass
 
     def endFrame(self):
@@ -125,29 +126,7 @@ class RenderTool(object):
         in direction iDir.
         Returns a list of Visits which are the nodes / vertices in the tree.
         """
-        # gGrid = np.meshgrid(np.arange(10), -np.arange(10))
         rt = self.__class__
-        # plt.scatter(*rt.gCentres, s=5, color="r")
-
-        if False:
-            for iAgent in range(self.env.number_of_agents):
-                sColor = rt.lColors[iAgent]
-
-                rcPos = self.env.agents_position[iAgent]
-                iDir = self.env.agents_direction[iAgent]  # agent dir index
-
-                self.plotAgent(rcPos, iDir, sColor)
-
-                # gTransRCAg = self.getTransRC(rcPos, iDir)
-                # self.plotTrans(rcPos, gTransRCAg, color=color)
-
-                if False:
-                    # TODO: this was `rcDir' but it was undefined
-                    rcNext = rcPos + iDir
-                    # transition for next cell
-                    tbTrans = self.env.rail.get_transitions((*rcNext, iDir))
-                    giTrans = np.where(tbTrans)[0]  # RC list of transitions
-                    gTransRCAg = rt.gTransRC[giTrans]
 
         for visit in lVisits:
             # transition for next cell
@@ -156,8 +135,15 @@ class RenderTool(object):
             gTransRCAg = rt.gTransRC[giTrans]
             self.plotTrans(visit.rc, gTransRCAg, depth=str(visit.iDepth), color=color)
 
-    def plotAgents(self, targets=True):
-        cmap = self.gl.get_cmap('hsv', lut=self.env.number_of_agents + 1)
+    def plotAgents(self, targets=True, iSelectedAgent=None):
+        cmap = self.gl.get_cmap('hsv',
+            lut=max(len(self.env.agents), len(self.env.agents_static) + 1))
+
+        for iAgent, agent in enumerate(self.env.agents_static):
+            oColor = cmap(iAgent)
+            self.plotAgent(agent.position, agent.direction, oColor, target=agent.target if targets else None,
+                static=True, selected=iAgent == iSelectedAgent)
+
         for iAgent, agent in enumerate(self.env.agents):
             oColor = cmap(iAgent)
             self.plotAgent(agent.position, agent.direction, oColor, target=agent.target if targets else None)
@@ -198,7 +184,7 @@ class RenderTool(object):
         else:
             return gTransRCAg
 
-    def plotAgent(self, rcPos, iDir, color="r", target=None):
+    def plotAgent(self, rcPos, iDir, color="r", target=None, static=False, selected=False):
         """
         Plot a simple agent.
         Assumes a working graphics layer context (cf a MPL figure).
@@ -209,11 +195,16 @@ class RenderTool(object):
         xyDir = np.matmul(rcDir, rt.grc2xy)          # agent direction in xy
 
         xyPos = np.matmul(rcPos - rcDir / 2, rt.grc2xy) + rt.xyHalf
+
+        if static:
+            color = self.gl.adaptColor(color, lighten=True)
+
         # print("Agent:", rcPos, iDir, rcDir, xyDir, xyPos)
         self.gl.scatter(*xyPos, color=color, marker="o", s=100)            # agent location
-
         xyDirLine = array([xyPos, xyPos + xyDir / 2]).T  # line for agent orient.
         self.gl.plot(*xyDirLine, color=color, lw=5, ms=0, alpha=0.6)
+        if selected:
+            self._draw_square(xyPos, 1, color)
 
         if target is not None:
             rcTarget = array(target)
@@ -464,7 +455,8 @@ class RenderTool(object):
     def renderEnv(
             self, show=False, curves=True, spacing=False,
             arrows=False, agents=True, sRailColor="gray",
-            frames=False, iEpisode=None, iStep=None):
+            frames=False, iEpisode=None, iStep=None,
+            iSelectedAgent=None):
         """
         Draw the environment using matplotlib.
         Draw into the figure if provided.
@@ -591,7 +583,7 @@ class RenderTool(object):
         # Draw each agent + its orientation + its target
         if agents:
             cmap = self.gl.get_cmap('hsv', lut=env.number_of_agents + 1)
-            self.plotAgents(targets=True)
+            self.plotAgents(targets=True, iSelectedAgent=iSelectedAgent)
 
         if False:
             for i in range(env.number_of_agents):
diff --git a/notebooks/Editor2.ipynb b/notebooks/Editor2.ipynb
index 5a24530..4921182 100644
--- a/notebooks/Editor2.ipynb
+++ b/notebooks/Editor2.ipynb
@@ -12,6 +12,16 @@
    "execution_count": 1,
    "metadata": {},
    "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "from numpy import array\n",
@@ -22,13 +32,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/html": [
-       "<style>.container { width:90% !important; }</style>"
+       "<style>.container { width:95% !important; }</style>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -39,12 +49,12 @@
     }
    ],
    "source": [
-    "display(HTML(\"<style>.container { width:90% !important; }</style>\"))"
+    "display(HTML(\"<style>.container { width:95% !important; }</style>\"))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -61,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -75,7 +85,7 @@
     }
    ],
    "source": [
-    "mvc = EditorMVC()"
+    "mvc = EditorMVC(sGL=\"PIL\")"
    ]
   },
   {
@@ -95,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {
     "scrolled": false
    },
@@ -103,7 +113,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6518d395e78c4cd1af6e8c56b54ffa1c",
+       "model_id": "e8a334cd72b94510b53b5fd0b4abaaf2",
        "version_major": 2,
        "version_minor": 0
       },
@@ -121,15 +131,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {
-    "scrolled": true
+    "scrolled": false
    },
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "22473299922b4ccab0a6cf507db54152",
+       "model_id": "96e78fa758b64ea7827c695beef03bf2",
        "version_major": 2,
        "version_minor": 0
       },
@@ -148,18 +158,125 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mvc.editor.env.get_agent_handles()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mvc.editor.env._get_observations()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.figure(figsize=(10,10))\n",
+    "#ipv.view(0, 90, 1)\n",
+    "nBranchFactor = 4\n",
+    "\n",
+    "# A point in xyz representing the root node\n",
+    "gP0 = array([[0,0,0]]).T\n",
+    "nDepth = 3\n",
+    "\n",
+    "# iterate over layers / depths:\n",
+    "for i in range(nDepth):\n",
+    "    nDepthNodes = nBranchFactor**i   # number of nodes at this depth\n",
+    "    rScale = nBranchFactor ** (nDepth - i)\n",
+    "    rShrinkDepth = 1/(i+1)    # shrink the horizontal scale as we go deeper\n",
+    "\n",
+    "    # x,y,z coords for the nodes\n",
+    "    gX1 = np.linspace(-(nDepthNodes-1), (nDepthNodes-1), nDepthNodes) * rShrinkDepth\n",
+    "    gY1 = np.ones((nDepthNodes)) * i\n",
+    "    gZ1 = np.zeros((nDepthNodes))\n",
+    "    \n",
+    "    #ipv.scatter(gX1, gZ1, -gY1, marker=\"sphere\")\n",
+    "    \n",
+    "    #gP0rep = np.repeat(gP0, nBranchFactor, axis=1)\n",
+    "    \n",
+    "    # All the new points\n",
+    "    gP1 = array([gX1, gY1, gZ1])\n",
+    "    \n",
+    "    # The points from both the previous depth and this one\n",
+    "    gP01 = np.append(gP0, gP1, axis=1)\n",
+    "    \n",
+    "    if nDepthNodes > 1:\n",
+    "        nDepthNodesPrev = nDepthNodes / nBranchFactor\n",
+    "        giP0 = np.repeat(np.arange(nDepthNodesPrev), nBranchFactor)\n",
+    "        giP1 = np.arange(0, nDepthNodes) + nDepthNodesPrev\n",
+    "        giLinePoints = np.stack([giP0, giP1]).ravel(\"F\")\n",
+    "        #print(gP01[:,:10])\n",
+    "        #print(giLinePoints)\n",
+    "        for iLine in range(0, len(giLinePoints), 2):\n",
+    "            iP0 = int(giLinePoints[iLine])\n",
+    "            iP1 = int(giLinePoints[iLine+1])\n",
+    "            p0 = [ gP01[0, iP0], gP01[1, iP0] ]\n",
+    "            p1 = [ gP01[0, iP1], gP01[1, iP1] ]\n",
+    "            \n",
+    "            gLine = array([p0, p1]).T\n",
+    "            #print(p0, p1, gLine)\n",
+    "            #plt.plot(gP01[0], gP01[2], -gP01[1], lines=giLinePoints, color=\"gray\")\n",
+    "            plt.plot(*gLine, color=\"gray\")\n",
+    "            #ipv.plot(gP01[0], gP01[2], -gP01[1], lines=giLinePoints)\n",
+    "\n",
+    "    gP0 = array([gX1, gY1, gZ1])\n",
+    "    "
+   ]
   }
  ],
  "metadata": {
   "hide_input": false,
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "ve367",
    "language": "python",
-   "name": "python3"
+   "name": "ve367"
   },
   "language_info": {
    "codemirror_mode": {
@@ -171,7 +288,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.6.7"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,
-- 
GitLab