Update examples and test with brain implementation

doc/source/example/processing/apcv.py

 import matplotlib.pyplot as plt
 from navipy.database import DataBaseLoad
 import navipy.processing as processing
-from navipy.sensors import Senses
+from navipy import Brain
 import pkg_resources
 
 # 1) Connect to the database
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
+mybrain = Brain(renderer=mydb)
 # 2) Define the position-orinetation at which
 # we want the image
 posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
-my_apcv = processing.pcode.apcv(mysenses.vision.scene,
-                                mysenses.vision.viewing_directions)
+mybrain.update(posorient)
+my_apcv = processing.pcode.apcv(mybrain.vision.scene,
+                                mybrain.vision.viewing_directions)
 
 my_apcv_sph = processing.tools.cartesian_to_spherical(x=my_apcv[..., 0],
                                                       y=my_apcv[..., 1],

doc/source/example/processing/contrast_weighted_nearness.py

 import matplotlib.pyplot as plt
 from navipy.database import DataBaseLoad
 import navipy.processing as processing
-from navipy.sensors import Senses
+from navipy import Brain
 import pkg_resources
 
 
@@ -9,13 +9,13 @@ import pkg_resources
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
+mybrain = Brain(renderer=mydb)
 # 2) Define the position-orinetation at which
 # we want the image
 posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
+mybrain.update(posorient)
 my_contrast = processing.pcode.contrast_weighted_nearness(
-    mysenses.vision.scene)
+    mybrain.vision.scene)
 
 f, axarr = plt.subplots(2, 2, figsize=(15, 8))
 axarr = axarr.flatten()

doc/source/example/processing/michelson_contrast.py

 import matplotlib.pyplot as plt
 from navipy.database import DataBaseLoad
 import navipy.processing as processing
-from navipy.sensors import Senses
+from navipy import Brain
 import pkg_resources
 
 # 1) Connect to the database
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
+mybrain = Brain(renderer=mydb)
 # 2) Define the position-orinetation at which
 # we want the image
 posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
-my_contrast = processing.pcode.michelson_contrast(mysenses.vision.scene)
+mybrain.update(posorient)
+my_contrast = processing.pcode.michelson_contrast(mybrain.vision.scene)
 
 f, axarr = plt.subplots(2, 2, figsize=(15, 8))
 axarr = axarr.flatten()

doc/source/example/processing/pcv.py

 # import matplotlib.pyplot as plt
 from navipy.database import DataBaseLoad
 import navipy.processing as processing
-from navipy.sensors import Senses
+from navipy import Brain
 import pkg_resources
 
 # 1) Connect to the database
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
+mybrain = Brain(renderer=mydb)
 # 2) Define the position-orinetation at which
 # we want the image
 posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
-my_pcv = processing.pcode.pcv(mysenses.vision.scene,
-                              mysenses.vision.viewing_directions)
+mybrain.update(posorient)
+my_pcv = processing.pcode.pcv(mybrain.vision.scene,
+                              mybrain.vision.viewing_directions)

doc/source/example/processing/skyline.py

 import matplotlib.pyplot as plt
 from navipy.database import DataBaseLoad
 import navipy.processing as processing
-from navipy.sensors import Senses
+from navipy import Brain
 import pkg_resources
 
 # 1) Connect to the database
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
+mybrain = Brain(renderer=mydb)
 # 2) Define the position-orinetation at which
 # we want the image
 posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
-my_skyline = processing.pcode.skyline(mysenses.vision.scene)
+mybrain.update(posorient)
+my_skyline = processing.pcode.skyline(mybrain.vision.scene)
 
 f, axarr = plt.subplots(1, 2, figsize=(15, 4))
 for chan_i, chan_n in enumerate(mydb.channels):

doc/source/example/tutorials/asv_homing_grid.py

@@ -5,27 +5,41 @@ import pkg_resources
 from navipy.database import DataBaseLoad
 from navipy.processing.pcode import apcv
 from navipy.moving.agent import GridAgent
-from navipy.sensors import Senses
-
+from navipy import Brain
+
+
+# 0) Define a class heriting from Brain
+class ASVBrain(Brain):
+    def __init__(self, renderer=None):
+        Brain.__init__(self,renderer=renderer)
+        # Init memory
+        posorient = mydb.posorients.loc[12, :]
+        mybrain.update(posorient)
+        self.memory = apcv(mybrain.vision.scene,
+                      mybrain.vision.viewing_directions)
+
+    def velocity(self):
+        asv = apcv(self.vision.scene,
+                   self.vision.viewing_directions)
+        homing_vector = self.memory - asv
+        homing_vector = np.squeeze(homing_vector[..., 0, :])
+        velocity = pd.Series(data=0,
+                         index=['dx', 'dy', 'dz',
+                                'dalpha_0', 'dalpha_1', 'dalpha_2'])
+        velocity[['dx', 'dy', 'dz']] = homing_vector
+        return velocity
+    
 # 1) Connect to the database
 mydb_filename = pkg_resources.resource_filename(
     'navipy', 'resources/database.db')
 mydb = DataBaseLoad(mydb_filename)
-mysenses = Senses(renderer=mydb)
-# 2) Define the position-orinetation at which
-# we want the image
-posorient = mydb.posorients.loc[12, :]
-mysenses.update(posorient)
-memory = apcv(mysenses.vision.scene,
-              mysenses.vision.viewing_directions)
-
-
+mybrain = ASVBrain(renderer=mydb)
 # Create a grid agent
-my_agent = GridAgent(mydb_filename)
+my_agent = GridAgent(mybrain)
 
 # init position
 rowid = 1
-initpos = mydb.posorients.loc[rowid]
+initpos = mybrain.posorients.loc[rowid]
 my_agent.posorient = initpos
 
 # Mode of motion
@@ -35,23 +49,6 @@ mode_of_motion['param'] = dict()
 mode_of_motion['param']['grid_spacing'] = 1
 my_agent.mode_of_motion = mode_of_motion
 
-# Define a motion function
-
-
-def asv_homing(posorient_vel, senses, memory):
-    asv = apcv(senses.vision.scene,
-               senses.vision.viewing_directions)
-    homing_vector = memory - asv
-    homing_vector = np.squeeze(homing_vector[..., 0, :])
-    velocity = pd.Series(data=0,
-                         index=['dx', 'dy', 'dz',
-                                'dalpha_0', 'dalpha_1', 'dalpha_2'])
-    velocity[['dx', 'dy', 'dz']] = homing_vector
-    return velocity
-
-
-my_agent.motion = asv_homing
-my_agent.motion_param = {'memory': memory}
 # Run
 max_nstep = 100
 trajectory = my_agent.fly(max_nstep, return_tra=True)

navipy/__init__.py

@@ -20,12 +20,8 @@ Then the senses can be updated at a new position orientation:
 .. literalinclude:: example/processing/apcv.py
    :lines: 15
 
-Renderer
---------
-.. automodule:: navipy.sensors.renderer
-
 """
-from database import DataBaseLoad
+from navipy.database import DataBaseLoad
 
 class Bunch:
     def __init__(self, **kwds):
@@ -48,6 +44,7 @@ class Brain():
         raise NotImplementedError("Subclasses should implement this")
 
     def update(self, posorient):
+        self.posorient = posorient
         if self.renderer is not None:
             self.vision.scene = self.renderer.scene(posorient)
 

navipy/moving/agent.py

@@ -11,13 +11,14 @@
 """
 import numpy as np
 import pandas as pd
+import copy
 import networkx as nx
 import multiprocessing
 from multiprocessing import Queue, JoinableQueue, Process
 import inspect
 from navipy.database import DataBaseLoad
 import navipy.moving.maths as navimomath
-from navipy.sensors import Senses
+from navipy import Brain
 
 version = float(nx.__version__)
 
@@ -27,18 +28,20 @@ def defaultcallback(*args, **kwargs):
     raise NameError('No Callback')
 
 
-class DefaultSensors():
+class DefaultBrain():
     def __init__(self):
         pass
 
     def update(self, posorient):
         raise NameError('No Callback')
 
+    def velocity(self):
+        raise NameError('No Callback')
+
 
 class AbstractAgent():
     def __init__(self):
-        self._brian = DefaultSensors()
-        self._motion_param = None
+        self._brain = DefaultBrain()
         self._alter_posorientvel = defaultcallback
         self._posorient_col = ['x', 'y', 'z',
                                'alpha_0', 'alpha_1', 'alpha_2']
@@ -93,7 +96,7 @@ class AbstractAgent():
 
     def move(self):
         self._brain.update(self.posorient)
-        self.velocity = self._brian.velocity()
+        self.velocity = self._brain.velocity()
         alteredpos = self._alter_posorientvel(self._posorient_vel)
         self.posorient = alteredpos
         self.velocity = alteredpos
@@ -193,7 +196,7 @@ GridAgent is a close loop agent here its position is snap to a grid.
             move_mode=self._mode_move['mode'],
             move_param=self._mode_move['param'])
         tmp = navimomath.closest_pos(
-            posorient_vel, self._posorients)
+            posorient_vel, self._brain.posorients)
         posorient_vel.loc[self._posorient_col] = \
             tmp.loc[self._posorient_col]
         posorient_vel.name = tmp.name
@@ -248,8 +251,8 @@ the agent motion, or
 2. pre-computed agent-motion
     """
 
-    def __init__(self, brian):
-        self._brain = copy.deepcopy(brain)
+    def __init__(self, brain):
+        self._brain = copy.copy(brain)
         # Init the graph
         self._graph = nx.DiGraph()
         for row_id, posor in self._brain.posorients.iterrows():
@@ -284,7 +287,7 @@ the agent motion, or
 
         # Start ndatabase loader
         num_agents = ncpu
-        agents = [GridAgent(copy.deepcopy(self._brain),
+        agents = [GridAgent(copy.copy(self._brain),
                             posorients_queue=posorients_queue,
                             results_queue=results_queue)
                   for _ in range(num_agents)]

navipy/moving/test_agent.py

@@ -6,6 +6,7 @@ import pandas as pd
 import networkx as nx
 import navipy.moving.agent as naviagent
 import navipy.database as navidb
+from navipy import Brain
 import pkg_resources
 
 import unittest
@@ -13,18 +14,29 @@ import unittest
 version = float(nx.__version__)
 
 
-class TestNavipyMovingAgent(unittest.TestCase):
+class BrainTest(Brain):
+    def __init__(self, renderer=None):
+        Brain.__init__(self,renderer=renderer)
+        self.__posorient_col = ['x', 'y', 'z',
+                            'alpha_0', 'alpha_1', 'alpha_2']
+        self.__velocity_col = ['d' + col for col in self.__posorient_col]
+        self.__posorient_vel_col = self.__posorient_col
+        self.__posorient_vel_col.extend(self.__velocity_col)
+
+    def velocity(self):
+        return pd.Series(data=0,index=self.__posorient_vel_col)
 
+class TestNavipyMovingAgent(unittest.TestCase):
     def setUp(self):
         self.mydb_filename = pkg_resources.resource_filename(
             'navipy', 'resources/database.db')
         self.mydb = navidb.DataBaseLoad(self.mydb_filename)
+        self.brain = BrainTest(self.mydb)
         self.__posorient_col = ['x', 'y', 'z',
                                 'alpha_0', 'alpha_1', 'alpha_2']
         self.__velocity_col = ['d' + col for col in self.__posorient_col]
         self.__posorient_vel_col = self.__posorient_col
         self.__posorient_vel_col.extend(self.__velocity_col)
-
     #
     # AbstractAgent
     #
@@ -42,15 +54,12 @@ class TestNavipyMovingAgent(unittest.TestCase):
     # GridAgent
     #
     def test_move_gridagent(self):
-        agent = naviagent.GridAgent(self.mydb_filename)
-        initposorient = agent.db.posorients.loc[13, :]
+        agent = naviagent.GridAgent(self.brain)
+        initposorient = self.brain.posorients.loc[13, :]
         initposovel = pd.Series(data=0,
                                 index=self.__posorient_vel_col)
         initposovel.loc[initposorient.index] = initposorient
         agent.posorient = initposovel
-        agent.motion = lambda posorient, scene:\
-            pd.Series(data=0,
-                      index=self.__posorient_vel_col)
         with self.assertRaises(AttributeError):
             agent.move()
         mode_move = {'mode': 'on_cubic_grid',
@@ -64,15 +73,12 @@ class TestNavipyMovingAgent(unittest.TestCase):
             obtained, initposorient.loc[obtained.index]))
 
     def test_fly_gridagent(self):
-        agent = naviagent.GridAgent(self.mydb_filename)
-        initposorient = agent.db.posorients.loc[13, :]
+        agent = naviagent.GridAgent(self.brain)
+        initposorient = self.brain.posorients.loc[13, :]
         initposovel = pd.Series(data=0,
                                 index=self.__posorient_vel_col)
         initposovel.loc[initposorient.index] = initposorient
         agent.posorient = initposovel
-        agent.motion = lambda posorient, scene:\
-            pd.Series(data=0,
-                      index=self.__posorient_vel_col)
         with self.assertRaises(AttributeError):
             agent.fly(max_nstep=10)
         mode_move = {'mode': 'on_cubic_grid',
@@ -90,7 +96,7 @@ class TestNavipyMovingAgent(unittest.TestCase):
     #
 
     def test_init_graphagent(self):
-        agent = naviagent.GraphAgent(self.mydb_filename)
+        agent = naviagent.GraphAgent(self.brain)
         if version < 2:
             graph_nodes = list(agent.graph.nodes())
         else:
@@ -100,7 +106,7 @@ class TestNavipyMovingAgent(unittest.TestCase):
                          'Init of graph failed. Node missmatch')
 
     def test_graph_setter(self):
-        agent = naviagent.GraphAgent(self.mydb_filename)
+        agent = naviagent.GraphAgent(self.brain)
         if version < 2:
             graph_nodes = list(agent.graph.nodes())
         else:
@@ -128,7 +134,7 @@ class TestNavipyMovingAgent(unittest.TestCase):
         3 Two loops attractors
         """
         # Test all node to first
-        agent = naviagent.GraphAgent(self.mydb_filename)
+        agent = naviagent.GraphAgent(self.brain)
 
         if version < 2:
             graph_nodes = list(agent.graph.nodes())
@@ -193,7 +199,7 @@ class TestNavipyMovingAgent(unittest.TestCase):
         2. Saddle points
         3. Local minima
         """
-        agent = naviagent.GraphAgent(self.mydb_filename)
+        agent = naviagent.GraphAgent(self.brain)
         # Local maxima
         if version < 2:
             graph_nodes = list(agent.graph.nodes())

navipy/sensors/__init__.py

-"""
-Every agent comes with a battery of senses (biological agent) \
-or sensors (technical agent). The senses of agents in navipy are limited
-to:
-
-* 4d vision (brighness + depth)
-
-The 4d vision sense is controlled by rendering module, either an \
-online rendering or loaded from a database containing pre-rendered images.
-
-For example to use pre-rendered images from a database:
-
-.. literalinclude:: example/processing/apcv.py
-   :lines: 10-11
-
-Then the senses can be updated at a new position orientation:
-
-.. literalinclude:: example/processing/apcv.py
-   :lines: 15
-
-Renderer
---------
-.. automodule:: navipy.sensors.renderer
-
-"""
-
-
-class Bunch:
-    def __init__(self, **kwds):
-        self.__dict__.update(kwds)
-
-
-class Senses():
-    def __init__(self,
-                 renderer=None):
-        self.vision = Bunch(scene=None,
-                            viewing_directions=None,
-                            channels=None)
-        self.renderer = renderer
-        if self.renderer is not None:
-            self.vision.scene = None
-            self.vision.viewing_directions = renderer.viewing_directions
-            self.vision.channels = renderer.channels
-
-    def update(self, posorient):
-        if self.renderer is not None:
-            self.vision.scene = self.renderer.scene(posorient)