From 50730c6bfca4dbe5ce843b23e3d6581aeac2a0aa Mon Sep 17 00:00:00 2001
From: "Olivier J.N. Bertrand" <olivier.bertrand@uni-bielefeld.de>
Date: Mon, 1 Jan 2018 20:44:47 +0100
Subject: [PATCH] remove backup files
---
doc/source/example/processing/testblubb.py~ | 22 -
navipy/__init__.py~ | 0
navipy/__pycache__/__init__.cpython-35.pyc | Bin 156 -> 0 bytes
navipy/comparing/__init__.py~ | 143 ----
.../__pycache__/__init__.cpython-35.pyc | Bin 4868 -> 0 bytes
.../comparing/__pycache__/test.cpython-35.pyc | Bin 7702 -> 0 bytes
navipy/comparing/test.py~ | 236 -------
navipy/database/__init__.py~ | 623 ------------------
.../__pycache__/__init__.cpython-35.pyc | Bin 18847 -> 0 bytes
.../__pycache__/database.cpython-35.pyc | Bin 13869 -> 0 bytes
.../__pycache__/__init__.cpython-35.pyc | Bin 163 -> 0 bytes
.../moving/__pycache__/agent.cpython-35.pyc | Bin 11057 -> 0 bytes
.../moving/__pycache__/maths.cpython-35.pyc | Bin 3306 -> 0 bytes
.../__pycache__/test_agent.cpython-35.pyc | Bin 6987 -> 0 bytes
.../__pycache__/test_maths.cpython-35.pyc | Bin 3655 -> 0 bytes
navipy/moving/agent.py~ | 361 ----------
navipy/moving/maths.py~ | 30 -
.../Scene_processing.cpython-35.pyc | Bin 9276 -> 0 bytes
.../__pycache__/__init__.cpython-35.pyc | Bin 1820 -> 0 bytes
.../__pycache__/constants.cpython-35.pyc | Bin 592 -> 0 bytes
.../__pycache__/pcode.cpython-35.pyc | Bin 6530 -> 0 bytes
.../__pycache__/processing.cpython-35.pyc | Bin 7709 -> 0 bytes
.../__pycache__/scene.cpython-35.pyc | Bin 1233 -> 0 bytes
.../__pycache__/test.cpython-35.pyc | Bin 10450 -> 0 bytes
.../__pycache__/tools.cpython-35.pyc | Bin 5262 -> 0 bytes
navipy/processing/constants.py~ | 22 -
navipy/processing/test.py~ | 368 -----------
navipy/processing/tools.py~ | 165 -----
.../__pycache__/DataBase.cpython-35.pyc | Bin 10254 -> 0 bytes
.../__pycache__/__init__.cpython-35.pyc | Bin 166 -> 0 bytes
navipy/rendering/bee_sampling.py~ | 164 -----
navipy/rendering/cyber_bee.py~ | 379 -----------
32 files changed, 2513 deletions(-)
delete mode 100644 doc/source/example/processing/testblubb.py~
delete mode 100644 navipy/__init__.py~
delete mode 100644 navipy/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/comparing/__init__.py~
delete mode 100644 navipy/comparing/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/comparing/__pycache__/test.cpython-35.pyc
delete mode 100644 navipy/comparing/test.py~
delete mode 100644 navipy/database/__init__.py~
delete mode 100644 navipy/database/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/database/__pycache__/database.cpython-35.pyc
delete mode 100644 navipy/moving/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/moving/__pycache__/agent.cpython-35.pyc
delete mode 100644 navipy/moving/__pycache__/maths.cpython-35.pyc
delete mode 100644 navipy/moving/__pycache__/test_agent.cpython-35.pyc
delete mode 100644 navipy/moving/__pycache__/test_maths.cpython-35.pyc
delete mode 100644 navipy/moving/agent.py~
delete mode 100644 navipy/moving/maths.py~
delete mode 100644 navipy/processing/__pycache__/Scene_processing.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/constants.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/pcode.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/processing.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/scene.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/test.cpython-35.pyc
delete mode 100644 navipy/processing/__pycache__/tools.cpython-35.pyc
delete mode 100644 navipy/processing/constants.py~
delete mode 100644 navipy/processing/test.py~
delete mode 100644 navipy/processing/tools.py~
delete mode 100644 navipy/rendering/__pycache__/DataBase.cpython-35.pyc
delete mode 100644 navipy/rendering/__pycache__/__init__.cpython-35.pyc
delete mode 100644 navipy/rendering/bee_sampling.py~
delete mode 100644 navipy/rendering/cyber_bee.py~
diff --git a/doc/source/example/processing/testblubb.py~ b/doc/source/example/processing/testblubb.py~
deleted file mode 100644
index e675572..0000000
--- a/doc/source/example/processing/testblubb.py~
+++ /dev/null
@@ -1,22 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-
-import os
-import sys
-sys.path.insert(0, '/media/luiza/Daten/Repos/toolbox-navigation/src/database')
-from database import DataBaseLoad
-sys.path.insert(0, '/media/luiza/Daten/Repos/toolbox-navigation/src/processing')
-import processing
-
-
-# 1) Connect to the database
-mydb_filename = os.path.abspath('../database.db')
-mydb = DataBaseLoad(mydb_filename)
-# 2) Define the position-orinetation at which
-# we want the image and get the scene
-rowid = 5000
-my_scene = processing.scene(mydb, rowid=rowid)
-
-print(my_scene.shape)
-print(my_scene.type)
-print('elevation' in my_scene)
diff --git a/navipy/__init__.py~ b/navipy/__init__.py~
deleted file mode 100644
index e69de29..0000000
diff --git a/navipy/__pycache__/__init__.cpython-35.pyc b/navipy/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index d77138ae6ab15a1ae937595049e7b6a9a1c3fc02..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 156
zcmWgR<>lJ!WEsT(1dl-k3@`#24nSPY0whux7=kq!{Z=v*frJsnFHim4)RfFb{hZRw
zsziO4#FErJ{h-u>{9^r*+=9HsvdpCX3jLD&{2U;y3*x6ImSpDV>4TUBmHP4VnR%Hd
Z@$q^EmA5!-a`RJ4b5iX<Ruls<0{{zBC`14N
diff --git a/navipy/comparing/__init__.py~ b/navipy/comparing/__init__.py~
deleted file mode 100644
index dcc7e6f..0000000
--- a/navipy/comparing/__init__.py~
+++ /dev/null
@@ -1,143 +0,0 @@
-"""
-The Place comparator list different methods to
-compare a current place to a memorised place or
-memorised places.
-"""
-import numpy as np
-from navipy.processing.tools import is_ibpc, is_obpc
-from navipy.processing.tools import check_scene
-
-
-def simple_imagediff(current, memory):
- """Compute the difference between
-the current and memorised place code
-
- :param current: current place code
- :param memory: memorised place code
- :returns: the image difference
- :rtype: float
-
- ..ref: Zeil, J., 2012. Visual homing: an insect perspective.
- Current opinion in neurobiology
-
- """
- if not isinstance(current, np.ndarray):
- raise TypeError('current place code should be a numpy array')
- if not isinstance(memory, np.ndarray):
- raise TypeError('memory place code should be a numpy array')
- if not np.all(current.shape == memory.shape):
- raise Exception('memory and current place code should\
- have the same shape')
- check_scene(current)
- check_scene(memory)
- diff = current - memory
- if is_ibpc(current):
- return diff
- elif is_obpc(current):
- return diff
- else:
- raise TypeError('place code is neither an ibpc nor obpc')
-
-
-def imagediff(current, memory):
- """Compute the root mean square difference between
-the current and memorised place code
-
- :param current: current place code
- :param memory: memorised place code
- :returns: the image difference
- :rtype: float #array(1,4) for ibpc and float for obpc
-
- ..ref: Zeil, J., 2012. Visual homing: an insect perspective.
- Current opinion in neurobiology
-
- """
- simple_diff = simple_imagediff(current, memory)
- diff = np.power(simple_diff, 2)
- if is_ibpc(current):
- return np.sqrt(diff.mean(axis=0).mean(axis=0)) # 1
- elif is_obpc(current):
- return np.sqrt(diff.mean(axis=0).mean(axis=0))
- else:
- raise TypeError('place code is neither an ibpc nor obpc')
-
-
-def rot_imagediff(current, memory):
- """Compute the rotational image difference between
-the current and memorised place code.
-
- :param current: current place code
- :param memory: memorised place code
- :returns: the rotational image difference
- :rtype: (np.ndarray)
-
- ..ref: Zeil, J., 2012. Visual homing: an insect perspective.
- Current opinion in neurobiology
- ..note: assume that the image is periodic along the x axis
- (the left-right axis)
- """
- if not is_ibpc(current): # and not is_obpc(current):
- raise TypeError('The current and memory place code\
- should be image based')
- if not is_ibpc(memory): # and not is_obpc(memory):
- raise TypeError('The current and memory place code\
- should be image based')
- check_scene(current)
- check_scene(memory)
- ridf = np.zeros((current.shape[1], current.shape[2]))
- for azimuth_i in range(0, current.shape[1]):
- rot_im = np.roll(current, azimuth_i, axis=1)
- ridf[azimuth_i, :] = np.squeeze(imagediff(rot_im, memory)) # rot_im
- return ridf
-
-
-def diff_optic_flow(current, memory):
- """Computes the direction of motion from current
-to memory by using the optic flow under the
-constrain that the brightness is constant, (small movement),
-using a taylor expansion and solving the equation:
-0=I_t+\delta I*<u,v> or I_x+I_y+I_t=0
-
-afterwards the aperture problem is solved by a
-Matrix equation Ax=b, where x=(u,v) and
-A=(I_x,I_y) and b = I_t
-
- :param current: current place code
- :param memory: memorised place code
- :returns: a directional vectors
- :rtype: (np.ndarray)
-
- ..ref: aperture problem:
- Shimojo, Shinsuke, Gerald H. Silverman, and Ken Nakayama:
- "Occlusion and the solution to the aperture problem for motion."
- Vision research 29.5 (1989): 619-626.
- optic flow:
- Horn, Berthold KP, and Brian G. Schunck.:
- "Determining optical flow."
- Artificial intelligence 17.1-3 (1981): 185-203.
- """
- if not is_ibpc(current): # and not is_obpc(current):
- raise TypeError('The current and memory place code\
- should be image based')
- if not is_ibpc(memory): # and not is_obpc(memory):
- raise TypeError('The current and memory place code\
- should be image based')
- check_scene(current)
- check_scene(memory)
- currroll = np.roll(current, 1, axis=1)
- dx = current - currroll
- memroll = np.roll(memory, 1, axis=1)
- dy = memory - memroll
- dy = np.reshape(dy, (np.prod(dy.shape), 1))
- dx = np.reshape(dx, (np.prod(dx.shape), 1))
- di = current - memory
- di = np.reshape(di, (np.prod(di.shape), 1))
- a_matrix = np.column_stack([dy, dx])
- a_matrix_sqr = np.dot(np.transpose(a_matrix), a_matrix)
- b_vector = np.dot(np.transpose(a_matrix), di)
- res = np.linalg.solve(a_matrix_sqr, b_vector)
- return res
-
-
-def gradient(current, memory):
- return 0
diff --git a/navipy/comparing/__pycache__/__init__.cpython-35.pyc b/navipy/comparing/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index bfeb1d2527d0e393eb86a95df0bfb32e98f70153..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 4868
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
bRK7=4Sy0y+QsDF6xpMP+%?r)fn>+soCX@Ho
diff --git a/navipy/comparing/__pycache__/test.cpython-35.pyc b/navipy/comparing/__pycache__/test.cpython-35.pyc
deleted file mode 100644
index 9107a89e8de76c262b55ba81868acec9bb1438bf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 7702
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
diff --git a/navipy/comparing/test.py~ b/navipy/comparing/test.py~
deleted file mode 100644
index 041eba0..0000000
--- a/navipy/comparing/test.py~
+++ /dev/null
@@ -1,236 +0,0 @@
-import unittest
-import numpy as np
-import navipy.database as database
-import navipy.comparing as comparing
-from navipy.processing.tools import is_numeric_array
-import pkg_resources
-
-
-class TestCase(unittest.TestCase):
- def setUp(self):
- self.mydb_filename = pkg_resources.resource_filename(
- 'navipy', 'resources/database.db')
- self.mydb = database.DataBaseLoad(self.mydb_filename)
-
- def test_imagediff_curr(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- curr2 = curr.copy()
- curr2[3, 5, 2, 0] = np.nan
- curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- curr3 = [curr3, curr3, curr3]
- curr3 = np.array(curr3)
- curr4 = np.zeros((3, 4, 5, 0))
-
- # put useless stuff here
- with self.assertRaises(ValueError):
- comparing.imagediff(curr2, mem)
- with self.assertRaises(Exception):
- comparing.imagediff(curr3, mem)
- with self.assertRaises(Exception):
- comparing.imagediff(curr4, mem)
-
- # should be working -> check if result is correct
- for s in [curr]:
- diff = comparing.imagediff(s, mem)
- # self.assertTrue(diff.shape[1] == 1)
- self.assertTrue(diff.shape[0] > 0)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
-
- def test_imagediff_memory(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- mem2 = curr.copy()
- mem2[3, 5, 2] = np.nan
- mem3 = [[1, 2], [1, 2], [1, 2]]
- mem3 = [mem3, mem3, mem3]
- mem3 = np.array(mem3)
- mem4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.imagediff(curr, mem2)
- with self.assertRaises(Exception):
- comparing.imagediff(curr, mem3)
- with self.assertRaises(Exception):
- comparing.imagediff(curr, mem4)
-
- # should be working -> check if result is correct
- for s in [mem]:
- diff = comparing.imagediff(curr, s)
- self.assertFalse(diff.shape[0] <= 0)
- # self.assertTrue(diff.shape[1] == 1)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
-
- def test_rot_imagediff_curr(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- curr2 = curr.copy()
- curr2[3, 5, 2] = np.nan
- curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- curr3 = [curr3, curr3, curr3]
- curr3 = np.array(curr3)
- curr4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.rot_imagediff(curr2, mem)
- with self.assertRaises(Exception):
- comparing.rot_imagediff(curr3, mem)
- with self.assertRaises(Exception):
- comparing.rot_imagediff(curr4, mem)
-
- # should be working -> check if result is correct
- for s in [curr]:
- diff = comparing.rot_imagediff(s, mem)
- self.assertFalse(diff.shape[0] <= 0)
- self.assertTrue(diff.shape[1] == 4)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
-
- def test_rotimagediff_memory(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- mem2 = curr.copy()
- mem2[3, 5, 2] = np.nan
- mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- mem3 = [mem3, mem3, mem3]
- mem3 = np.array(mem3)
- mem4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.rot_imagediff(curr, mem2)
- with self.assertRaises(Exception):
- comparing.rot_imagediff(curr, mem3)
- with self.assertRaises(Exception):
- comparing.rot_imagediff(curr, mem4)
-
- # should be working -> check if result is correct
- for s in [mem]:
- diff = comparing.rot_imagediff(curr, s)
- self.assertFalse(diff.shape[0] <= 0)
- self.assertTrue(diff.shape[1] == 4)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
-
- def test_simple_imagediff_curr(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- curr2 = curr.copy()
- curr2[3, 5, 2] = np.nan
- curr3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- curr3 = [curr3, curr3, curr3]
- curr3 = np.array(curr3)
- curr4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.simple_imagediff(curr2, mem)
- with self.assertRaises(Exception):
- comparing.simple_imagediff(curr3, mem)
- with self.assertRaises(Exception):
- comparing.simple_imagediff(curr4, mem)
-
- # should be working -> check if result is correct
- for s in [curr]:
- diff = comparing.simple_imagediff(s, mem)
- self.assertFalse(diff.shape[0] <= 0)
- self.assertTrue(diff.shape[1] > 0)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
- self.assertTrue(diff.shape[2] == 4)
- # self.assertTrue(diff.shape[3] == 1)
-
- def test_simple_imagediff_mem(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- mem2 = curr.copy()
- mem2[3, 5, 2] = np.nan
- mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- mem3 = [mem3, mem3, mem3]
- mem3 = np.array(mem3)
- mem4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.simple_imagediff(curr, mem2)
- with self.assertRaises(Exception):
- comparing.simple_imagediff(curr, mem3)
- with self.assertRaises(Exception):
- comparing.simple_imagediff(curr, mem4)
-
- # should be working -> check if result is correct
- for s in [mem]:
- diff = comparing.simple_imagediff(curr, s)
- self.assertFalse(diff.shape[0] <= 0)
- self.assertTrue(diff.shape[1] > 0)
- self.assertFalse(np.any(np.isnan(diff)))
- self.assertTrue(is_numeric_array(diff))
- self.assertTrue(diff.shape[2] == 4)
- # self.assertTrue(diff.shape[3] == 1)
-
- def test_diff_optic_flow_memory(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- mem2 = curr.copy()
- mem2[3, 5, 2] = np.nan
- mem3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- mem3 = [mem3, mem3, mem3]
- mem3 = np.array(mem3)
- mem4 = np.zeros((3, 4, 5))
-
- with self.assertRaises(ValueError):
- comparing.diff_optic_flow(curr, mem2)
- with self.assertRaises(Exception):
- comparing.diff_optic_flow(curr, mem3)
- with self.assertRaises(Exception):
- comparing.diff_optic_flow(curr, mem4)
-
- # should be working -> check if result is correct
- for s in [mem]:
- vec = comparing.diff_optic_flow(curr, s)
- self.assertFalse(vec.shape[1] == (1, 2))
- self.assertFalse(np.any(np.isnan(vec)))
- self.assertTrue(is_numeric_array(vec))
-
- def test_diff_optic_flow_curr(self):
- curr = self.mydb.read_image(rowid=1)
- mem = self.mydb.read_image(rowid=2)
- curr = np.expand_dims(curr, axis=3)
- mem = np.expand_dims(mem, axis=3)
- curr2 = curr.copy()
- curr2[3, 5, 2] = np.nan
- curr3 = [[1, 2], [1, 2], [1, 2]]
- curr3 = [curr3, curr3, curr3]
- curr3 = np.array(curr3)
- curr4 = np.zeros((3, 4, 5, 1))
-
- with self.assertRaises(ValueError):
- comparing.diff_optic_flow(curr2, mem)
- with self.assertRaises(Exception):
- comparing.diff_optic_flow(curr3, mem)
- with self.assertRaises(Exception):
- comparing.diff_optic_flow(curr4, mem)
-
- # should be working -> check if result is correct
- for s in [mem]:
- vec = comparing.diff_optic_flow(s, curr)
- self.assertFalse(vec.shape[1] == (1, 2))
- self.assertFalse(np.any(np.isnan(vec)))
- self.assertTrue(is_numeric_array(vec))
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/navipy/database/__init__.py~ b/navipy/database/__init__.py~
deleted file mode 100644
index 2df8434..0000000
--- a/navipy/database/__init__.py~
+++ /dev/null
@@ -1,623 +0,0 @@
-"""
-Database are generated by the rendering module, and contains all \
-images and there corresponding position-orientations.
-
-* position_orientation: containing all position and orientation of where \
-images were rendered. The position-orientation is described by \
-['x','y','z','alpha_0','alpha_1','alpha_2']
-* image: containing all images ever rendered. Each channel of each image \
-are normalised, so to use the full coding range.
-* normalisation: the normalisation constantes
-
-
-How to load a database
-----------------------
-
-.. code-block:: python
-
- from database import DataBaseLoad
- mydb_filename = 'database.db'
- mydb = DataBaseLoad(mydb_filename)
-
-How to load all position-orientation
-------------------------------------
-
-The database contains all position-orientation \
-at which an image as been rendered. In certain \
-situation, it may be usefull to know all \
-position-orientation in the database. More technically \
-speaking, loading the full table of position-orientaiton.
-
-.. code-block:: python
-
- posorients = mydb.get_posorients()
- posorients.head()
-
-How to load an image
---------------------
-
-The database contains images which can be processed differently \
-depending on the navigation strategy beeing used.
-
-Images are at given position-orientations. To load an image \
-the position-orientation can be given. The DataBaseLoader will \
-look if this position-orientation has been rendered. If it is \
-the case, the image will be returned.
-
-.. code-block:: python
-
- posorient = pd.Series(index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
- posorient.x = -0.6
- posorient.y = -7.2
- posorient.z = 2.35
- posorient.alpha_0 = np.pi / 2
- posorient.alpha_1 = 0
- posorient.alpha_2 = 0
- image = mydb.read_image(posorient=posorient)
-
-.. plot:: example/database/load_image_posorient.py
-
-However, looking in the database if an image has already been \
-rendered at a given position-orientation can cost time. To speed up \
-certain calculation, image can instead be access by row number. \
-Indeed each position-orientation can be identified by a unique row \
-number. This number is consistant through the entire database. Thus, \
-an image can be loaded by providing the row number.
-
-.. code-block:: python
-
- rowid = 1000
- image = mydb.read_image(rowid=rowid)
-
-.. plot:: example/database/load_image_rowid.py
-
-
-
-.. todo: channels as part of database
-
-"""
-
-import os
-import numpy as np
-import pandas as pd
-import sqlite3
-import io
-import warnings
-import navipy.processing.tools as tools
-
-
-def adapt_array(arr):
- """
- http://stackoverflow.com/a/31312102/190597 (SoulNibbler)
- """
- if arr is None:
- raise ValueError('array must not be None')
- out = io.BytesIO()
- np.save(out, arr)
- out.seek(0)
- return sqlite3.Binary(out.read())
-
-
-def convert_array(text):
- if text is None:
- raise ValueError('text must not be None')
- out = io.BytesIO(text)
- out.seek(0)
- return np.load(out)
-
-
-# Converts np.array to TEXT when inserting
-sqlite3.register_adapter(np.ndarray, adapt_array)
-# Converts TEXT to np.array when selecting
-sqlite3.register_converter("array", convert_array)
-
-
-class DataBase():
- """DataBase is the parent class of DataBaseLoad and DataBaseSave.
-It creates three sql table on initialisation.
- """
- __float_tolerance = 1e-14
-
- def __init__(self, filename, channels=['R', 'G', 'B', 'D']):
- """Initialisation of the database """
- if not isinstance(filename, str):
- raise TypeError('filename should be a string')
- if not isinstance(channels, list):
- raise TypeError('nb_channel should be a list or np array')
- """for c in channels:
- if not c in ['R','G','B','D']:
- raise ValueError('channels
- must be either R,G,B or D (Distance)')"""
- self.filename = filename
- self.channels = channels
- self.normalisation_columns = list()
- for chan_n in self.channels:
- self.normalisation_columns.append(str(chan_n) + '_max')
- self.normalisation_columns.append(str(chan_n) + '_min')
- self.normalisation_columns.append(str(chan_n) + '_range')
-
- self.tablecolumns = dict()
- self.tablecolumns['position_orientation'] = dict()
- self.tablecolumns['position_orientation']['x'] = 'real'
- self.tablecolumns['position_orientation']['y'] = 'real'
- self.tablecolumns['position_orientation']['z'] = 'real'
- self.tablecolumns['position_orientation']['alpha_0'] = 'real'
- self.tablecolumns['position_orientation']['alpha_1'] = 'real'
- self.tablecolumns['position_orientation']['alpha_2'] = 'real'
- self.tablecolumns['image'] = dict()
- self.tablecolumns['image']['data'] = 'array'
- self.tablecolumns['normalisation'] = dict()
- for col in self.normalisation_columns:
- self.tablecolumns['normalisation'][col] = 'real'
-
- if os.path.exists(filename):
- # Check database
- self.db = sqlite3.connect(
- 'file:' + filename + '?cache=shared', uri=True,
- detect_types=sqlite3.PARSE_DECLTYPES,
- timeout=10)
- self.db_cursor = self.db.cursor()
- for tablename, _ in self.tablecolumns.items():
- if not self.table_exist(tablename):
- raise Exception('{} does not contain a table\
- named {}'.format(filename, tablename))
- elif self.create:
- # Create database
- self.db = sqlite3.connect(
- filename, detect_types=sqlite3.PARSE_DECLTYPES)
- self.db_cursor = self.db.cursor()
- for key, val in self.tablecolumns.items():
- columns = "(id integer primary key autoincrement"
- for colname, coltype in val.items():
- columns += ' , ' + colname + ' ' + coltype
- columns += ')'
- self.db_cursor.execute(
- "create table {} {}".format(key, columns))
- self.db.commit()
- else:
- raise NameError('Database {} does not exist'.format(filename))
-
- azimuth = np.linspace(-180, 180, 360)
- elevation = np.linspace(-90, 90, 180)
- [ma, me] = np.meshgrid(azimuth, elevation)
- self.viewing_directions = np.zeros((ma.shape[0], ma.shape[1], 2))
- self.viewing_directions[..., 0] = me
- self.viewing_directions[..., 1] = ma
-
- def table_exist(self, tablename):
- if not isinstance(tablename, str):
- raise TypeError('tablename should be a string')
- self.db_cursor.execute(
- """
- SELECT count(*)
- FROM sqlite_master
- WHERE type='table' and name=?;
- """, (tablename,))
- return bool(self.db_cursor.fetchone())
-
- def check_data_validity(self, rowid):
- if not isinstance(rowid, int):
- raise TypeError('rowid must be an integer')
- if rowid <= 0:
- raise ValueError('rowid must be greater zero')
- if rowid is np.nan:
- raise ValueError('rowid must not be nan')
- self.db_cursor.execute(
- """
- SELECT count(*)
- FROM position_orientation
- WHERE rowid=?;
- """, (rowid,))
- valid = bool(self.db_cursor.fetchone()[0])
- self.db_cursor.execute(
- """
- SELECT count(*)
- FROM normalisation
- WHERE rowid=?;
- """, (rowid,))
- valid = valid and bool(self.db_cursor.fetchone()[0])
- self.db_cursor.execute(
- """
- SELECT count(*)
- FROM image
- WHERE rowid=?;
- """, (rowid,))
- valid = valid and bool(self.db_cursor.fetchone()[0])
- return valid
-
- def get_posid(self, posorient):
- if not isinstance(posorient, pd.Series):
- raise TypeError('posorient should be a pandas Series')
- if posorient is not None:
- if not isinstance(posorient, pd.Series):
- raise TypeError('posorient should be a pandas Series')
- if posorient.empty:
- raise Exception('position must not be empty')
- if 'x' not in posorient.index:
- raise ValueError('missing index x')
- if 'y' not in posorient.index:
- raise ValueError('missing index y')
- if 'z' not in posorient.index:
- raise ValueError('missing index z')
- if 'alpha_0' not in posorient.index:
- raise ValueError('missing index alpha_0')
- if 'alpha_1' not in posorient.index:
- raise ValueError('missing index alpha_1')
- if 'alpha_2' not in posorient.index:
- raise ValueError('missing index alpha_2')
- if np.any(pd.isnull(posorient)):
- raise ValueError('posorient must not contain nan')
- where = """x>=? and x<=?"""
- where += """and y>=? and y<=?"""
- where += """and z>=? and z<=?"""
- where += """and alpha_0>=? and alpha_0<=?"""
- where += """and alpha_1>=? and alpha_1<=?"""
- where += """and alpha_2>=? and alpha_2<=?"""
- params = (
- posorient['x'] - self.__float_tolerance,
- posorient['x'] + self.__float_tolerance,
- posorient['y'] - self.__float_tolerance,
- posorient['y'] + self.__float_tolerance,
- posorient['z'] - self.__float_tolerance,
- posorient['z'] + self.__float_tolerance,
- posorient['alpha_0'] - self.__float_tolerance,
- posorient['alpha_0'] + self.__float_tolerance,
- posorient['alpha_1'] - self.__float_tolerance,
- posorient['alpha_1'] + self.__float_tolerance,
- posorient['alpha_2'] - self.__float_tolerance,
- posorient['alpha_2'] + self.__float_tolerance)
- self.db_cursor.execute(
- """
- SELECT count(*)
- FROM position_orientation
- WHERE {};""".format(where), params)
- exist = self.db_cursor.fetchone()[0] # [0] because of tupple
- if bool(exist):
- self.db_cursor.execute(
- """
- SELECT rowid
- FROM position_orientation
- WHERE {};
- """.format(where), params)
- return self.db_cursor.fetchone()[0]
- elif self.create:
- self.db_cursor.execute(
- """
- INSERT
- INTO position_orientation(x,y,z,alpha_0,alpha_1,alpha_2)
- VALUES (?,?,?,?,?,?)
- """, (
- posorient['x'],
- posorient['y'],
- posorient['z'],
- posorient['alpha_0'],
- posorient['alpha_1'],
- posorient['alpha_2']))
- rowid = self.db_cursor.lastrowid
- self.db.commit()
- return rowid
- else:
- print(posorient)
- raise ValueError('posorient not found')
-
- @property
- def create(self):
- return False
-
-
-class DataBaseLoad(DataBase):
- """A database generated by the rendering module is based on sqlite3.
- """
-
- def __init__(self, filename, channels=['R', 'G', 'B', 'D']):
- """Initialise the DataBaseLoader"""
- if not isinstance(filename, str):
- raise TypeError('filename should be a string')
- if not isinstance(channels, list):
- raise TypeError('nb_channel should be a list or np array')
- for c in channels:
- if c not in ['R', 'G', 'B', 'D']:
- raise ValueError('channels must be either\
- R,G,B or D (Distance)')
- DataBase.__init__(self, filename, channels=channels)
-
- @property
- def create(self):
- """use to decide weather to alter the database or not
- return False because we do not want
- to write on database (Load class)"""
- return False
-
- def iter_posorients(self):
- """Iter through all position orientation in the database
- """
- self.db_cursor.execute(
- """
- SELECT *
- FROM position_orientation
- """)
-
- columns_names = []
- for col in self.db_cursor.description:
- columns_names.append(col[0])
- for row in self.db_cursor:
- toyield = pd.Series(data=row, index=columns_names)
- toyield.name = toyield.id
- toyield.drop('id', inplace=True)
- yield toyield
-
- @property
- def posorients(self):
- """Return the position orientations of all points in the \
-database
- """
- posorient = pd.read_sql_query(
- "select * from position_orientation;", self.db)
- posorient.set_index('id', inplace=True)
- return posorient
-
- def read_posorient(self, posorient=None, rowid=None):
- if not isinstance(posorient, pd.Series):
- ('posorient should be a pandas Series')
- if posorient is not None:
- if not isinstance(posorient, pd.Series):
- raise TypeError('posorient should be a pandas Series')
- if posorient.empty:
- raise Exception('position must not be empty')
- if 'x' not in posorient.index:
- raise ValueError('missing index x')
- if 'y' not in posorient.index:
- raise ValueError('missing index y')
- if 'z' not in posorient.index:
- raise ValueError('missing index z')
- if 'alpha_0' not in posorient.index:
- raise ValueError('missing index alpha_0')
- if 'alpha_1' not in posorient.index:
- raise ValueError('missing index alpha_1')
- if 'alpha_2' not in posorient.index:
- raise ValueError('missing index alpha_2')
- if np.any(pd.isnull(posorient)):
- raise ValueError('posorient must not contain nan')
- if not isinstance(rowid, int):
- raise TypeError('rowid must be an integer')
- if rowid <= 0:
- raise ValueError('rowid must be greater zero')
- if rowid is np.nan:
- raise ValueError('rowid must not be nan')
- if (posorient is None) and (rowid is None):
- Exception('posorient and rowid can not be both None')
- if posorient is not None:
- rowid = self.get_posid(posorient)
- # Read images
- tablename = 'position_orientation'
- toreturn = pd.read_sql_query(
- """
- SELECT *
- FROM {}
- WHERE (rowid={})
- """.format(tablename, rowid), self.db)
- toreturn = toreturn.loc[0, :]
- toreturn.name = toreturn.id
- toreturn.drop('id')
- toreturn = toreturn.astype(float)
- return toreturn
-
- def read_image(self, posorient=None, rowid=None):
- if not isinstance(posorient, pd.Series):
- ('posorient should be a pandas Series')
- if posorient is not None:
- if not isinstance(posorient, pd.Series):
- raise TypeError('posorient should be a pandas Series')
- if posorient.empty:
- raise Exception('position must not be empty')
- if 'x' not in posorient.index:
- raise ValueError('missing index x')
- if 'y' not in posorient.index:
- raise ValueError('missing index y')
- if 'z' not in posorient.index:
- raise ValueError('missing index z')
- if 'alpha_0' not in posorient.index:
- raise ValueError('missing index alpha_0')
- if 'alpha_1' not in posorient.index:
- raise ValueError('missing index alpha_1')
- if 'alpha_2' not in posorient.index:
- raise ValueError('missing index alpha_2')
- if np.any(pd.isnull(posorient)):
- raise ValueError('posorient must not contain nan')
- if rowid is not None:
- if not isinstance(rowid, int):
- raise TypeError('rowid must be an integer')
- if rowid <= 0:
- raise ValueError('rowid must be greater zero')
- if rowid is np.nan:
- raise ValueError('rowid must not be nan')
- if (posorient is None) and (rowid is None):
- raise Exception('posorient and rowid can not be both None')
- if posorient is not None:
- rowid = self.get_posid(posorient)
- """Read an image at a given position-orientation or given id of row in the \
- database.
-
- :param posorient: a pandas Series with index \
- ['x','y','z','alpha_0','alpha_1','alpha_2']
- :param rowid: an integer
- :returns: an image
- :rtype: numpy.ndarray
- """
- if (posorient is None) and (rowid is None):
- Exception('posorient and rowid can not be both None')
- if posorient is not None:
- rowid = self.get_posid(posorient)
- # Read images
- tablename = 'image'
- self.db_cursor.execute(
- """
- SELECT data
- FROM {}
- WHERE (rowid=?)
- """.format(tablename), (rowid,))
- image = self.db_cursor.fetchone()[0]
- # Read cmaxminrange
- tablename = 'normalisation'
- cmaxminrange = pd.read_sql_query(
- """
- SELECT *
- FROM {}
- WHERE (rowid={})
- """.format(tablename, rowid), self.db)
- if cmaxminrange.shape[0] != 1:
- raise Exception('Error while reading normalisation factors')
- cmaxminrange = cmaxminrange.iloc[0, :]
- cmaxminrange.name = cmaxminrange.id
- cmaxminrange.drop('id')
- cmaxminrange = cmaxminrange.astype(float)
- return self.denormalise_image(image, cmaxminrange)
-
- def denormalise_image(self, image, cmaxminrange):
- if len(image.shape) != 3:
- raise Exception('image should be 3D array')
- if image.shape[2] != len(self.channels):
- raise Exception('image does not have the required\
- number of channels {}'.format(
- len(self.channels)))
- if not isinstance(cmaxminrange, pd.Series):
- raise Exception('cmaxminrange should be a pandas Series')
- if cmaxminrange.empty:
- raise Exception('cmaxminrange must not be empty')
- for chan_n in self.channels:
- if str(chan_n) + '_max' not in cmaxminrange.index:
- raise ValueError('cminmax range is missing index '
- + str(chan_n) + '_max')
- if str(chan_n) + '_min' not in cmaxminrange.index:
- raise ValueError('cminmax range is missing index '
- + str(chan_n) + '_min')
- if str(chan_n) + '_range' not in cmaxminrange.index:
- raise ValueError('cminmax range is missing index '
- + str(chan_n) + '_range')
- if np.any(np.isnan(cmaxminrange.loc[str(chan_n) + '_max'])):
- raise ValueError('cmaxminrange contains nans')
- if np.any(np.isnan(cmaxminrange.loc[str(chan_n) + '_min'])):
- raise ValueError('cmaxminrange contains nans')
- if np.any(np.isnan(cmaxminrange.loc[str(chan_n) + '_range'])):
- raise ValueError('cmaxminrange contains nans')
- denormed_im = np.zeros(image.shape, dtype=np.float)
- maxval_nim = np.iinfo(image.dtype).max
- #
- for chan_i, chan_n in enumerate(self.channels):
- cimage = image[:, :, chan_i].astype(float)
- cmax = cmaxminrange.loc[str(chan_n) + '_max']
- cmin = cmaxminrange.loc[str(chan_n) + '_min']
- crange = cmaxminrange.loc[str(chan_n) + '_range']
- cimage /= maxval_nim
- cimage *= crange
- cimage += cmin
- denormed_im[:, :, chan_i] = cimage
- if np.max(cimage) != cmax:
- print(cmaxminrange.name)
- # raise ValueError(
- # 'denormalisation failed {}!={}
- # '.format(np.max(cimage), cmax))
- return denormed_im
-
-
-class DataBaseSave(DataBase):
- def __init__(self, filename, channels=['R', 'G', 'B', 'D'],
- arr_dtype=np.uint8):
- """
- """
- DataBase.__init__(self, filename, channels=channels)
- self.arr_dtype = arr_dtype
-
- def create(self):
- """use to decide weather to alter the database or not
- return True because we will need
- to write on database (Save class)"""
- return True
-
- def write_image(self, posorient, image):
- normed_im, cmaxminrange = self.normalise_image(image, self.arr_dtype)
- rowid = self.get_posid(posorient)
- # Write image
- tablename = 'image'
- params = dict()
- params['rowid'] = rowid
- params['data'] = normed_im
- self.insert_replace(tablename, params)
- #
- tablename = 'normalisation'
- params = dict()
- params['rowid'] = rowid
- for chan_n in self.normalisation_columns:
- params[chan_n] = cmaxminrange.loc[chan_n]
- self.insert_replace(tablename, params)
-
- def insert_replace(self, tablename, params):
- if not isinstance(tablename, str):
- raise ValueError('table are named by string')
- if not isinstance(params, dict):
- raise ValueError('params should be dictionary columns:val')
- params_list = list()
- columns_str = ''
- for key, val in params.items():
- columns_str += key + ','
- params_list.append(val)
- columns_str = columns_str[:-1] # remove last comma
- if len(params_list) == 0:
- warnings.warn('nothing to be done in {}'.format(tablename))
- return
- questionsmarks = '?'
- for _ in range(1, len(params_list)):
- questionsmarks += ',?'
- self.db_cursor.execute(
- """
- INSERT OR REPLACE
- INTO {} ({})
- VALUES ({})
- """.format(tablename,
- columns_str,
- questionsmarks),
- tuple(params_list)
- )
- self.db.commit()
-
- def normalise_image(self, image, dtype=np.uint8):
- if not isinstance(image, np.ndarray):
- raise TypeError('image must be np.array')
- if np.any(np.isnan(image)):
- raise ValueError('image must not contain nan values')
- if image.shape[0] <= 0 or image.shape[1] <= 0:
- raise Exception('image dimensions incorrect')
- if image.shape[2] != len(self.channels):
- raise Exception('image channels number differs from\
- given channel number')
- if not tools.is_numeric_array(image):
- raise TypeError('scene is of non numeric type')
- normed_im = np.zeros(image.shape, dtype=dtype)
- maxval_nim = np.iinfo(normed_im.dtype).max
- #
- columns = list()
- for chan_n in self.channels:
- columns.append(str(chan_n) + '_max')
- columns.append(str(chan_n) + '_min')
- columns.append(str(chan_n) + '_range')
-
- cmaxminrange = pd.Series(index=columns)
- for chan_i, chan_n in enumerate(self.channels):
- cimage = image[:, :, chan_i].astype(float)
- cmax = cimage.max()
- cmin = cimage.min()
- crange = cmax - cmin
- cimage -= cmin
- if np.isclose(crange, 0):
- # cimage should be equal to 0
- # so crange is irelevant we can assign it to 1
- crange = 1
- cimage /= crange
- cimage *= maxval_nim
- cimage = cimage.astype(normed_im.dtype)
- normed_im[:, :, chan_i] = cimage
- cmaxminrange.loc[str(chan_n) + '_max'] = cmax
- cmaxminrange.loc[str(chan_n) + '_min'] = cmin
- cmaxminrange.loc[str(chan_n) + '_range'] = crange
- return normed_im, cmaxminrange
diff --git a/navipy/database/__pycache__/__init__.cpython-35.pyc b/navipy/database/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 3bfd065f5b9480e6ed59d81e03ef5c21a0c2e838..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 18847
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
I^Mil;-_!^*KL7v#
diff --git a/navipy/database/__pycache__/database.cpython-35.pyc b/navipy/database/__pycache__/database.cpython-35.pyc
deleted file mode 100644
index 39556f7eb80af088dfe0d6a01b7bb98eeda27f1e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 13869
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
diff --git a/navipy/moving/__pycache__/__init__.cpython-35.pyc b/navipy/moving/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index 9fba1b965c52102713da30cfa1546b76f4973c0c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 163
zcmWgR<>lJ!WEsT(1dl-k3@`#24nSPY0whux7=kq!{Z=v*frJsnuK@kr)RfFb{hZRw
zsziO4#FErJ{h-u>{9^r*+=9HsvdpCX3jLD&{2U;y3*x6ImSpDV>4TUBmHN5)Wtn;D
g`tk9Zd6^~g@p=W7w>WHa^HWN5Qtd!C6$3E?07>2}3IG5A
diff --git a/navipy/moving/__pycache__/agent.cpython-35.pyc b/navipy/moving/__pycache__/agent.cpython-35.pyc
deleted file mode 100644
index 3501c939970e1f0f1e0577baf5253c7be2df08b7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 11057
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
diff --git a/navipy/moving/__pycache__/maths.cpython-35.pyc b/navipy/moving/__pycache__/maths.cpython-35.pyc
deleted file mode 100644
index 54a569a60906dc1a11576ddf359469ec20246340..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3306
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
diff --git a/navipy/moving/__pycache__/test_agent.cpython-35.pyc b/navipy/moving/__pycache__/test_agent.cpython-35.pyc
deleted file mode 100644
index aa4058d63e97924dd19098b73d86c8fe532523f7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6987
zcmd5>TXP&o74Dh6uXeS%*|Bjh1G%wOB3X6<6>uCoQ5*uvma#-kZ4rji&S*8t?994n
z){>?qUYtBr@W6kdpo$;B1OI?GUb>1Wp8N`LdEz^#XLeU>S=b3wA$wXqeK~Xb^mo2<
zx^=$UtpD@No83QrQ;2_vsh=Y1H}J&2L*WY1MQI4v6oDbSW?nCdZZWTyM7NyRD`KxI
z_G+SA&s*liUPE-7`Rlys&gb=(=(fZMZb7(3@i{(I6kbd0Er<t@z9_sU;g-Z_rjWno
z_GR%v2m^|2w##X&zU9S<74299C)thb5238+^r*~#OjK^*iH}ftSO`{uGG78d*u|Ig
zkJEBW!Yz{`T~sQ<t#Tbps|mNxbu`Wix54$QaIvU)u46z;xC>mz!WV_R#B~f_hPo^2
z9BJEe?)$^TkE8p3*uUBL!lY+FGy0+51w8NJiC0l1LhM0Zw)+E9U<I}*l7iSPQhm=9
z4-9UEq5>Z%bW}NH>FGJ?#nDLiym-xZ5@*|qy;XO+T~^KEXMKCzsTT99z2gU7=nOp7
z92~malUJ7LZmY%y<h%<xA4QI<iZrNgsAB8|JHHol4%&WsXKmoQzOxpL{M1>)crRSL
z;|-&DEg1|+vF+$!Es3H4zh9^KzLWS-xTbYp8?Z^%64=Og$S|wJLsg2s<fp?0vPc<)
zFv>>DNH3jg$W<OYHYe?T5f7U)Kt-EVTP`!IVH~pw_X;9`Q4O(I5=mL?RRrt}RG>6w
zrxjuL$uvEOAPOjyc>-QG+m-Y(Rvt+o3$gsz3Sc(RwR}L;8$|NZ-k~lxIHb;7P7r&R
zYRz=rO5YyKh^=@x8U?Pk?OBdBbXRFVZb|HzwZH3yBz0Qi4oTeVq*qQA(22s+rzLXa
zwX3Q|Tf%#wnm4!OL^{2Mu_|d3RNaYVPbOO!tm=O3hjHSBJ=7;3Q|8cBwXu$EQ`Tu_
ziG?y;bkU&J1>W<i6`VtByn;fQEu)4#UotA#cd9jv^p(?he^$sC2n2#<JPd?Cp)$Lp
z<Vcep1rXp@zg`kXwzq(RA&k3jQT*i2&oXofacqi%UuJBfc|tRU<_66Qnh*L7vGM5}
z;<&(G3#3&~e&C25IsX870}V$7aqV6#=%btMrSz(k?E;*{%aO2kIP~6^GLnR<FiNbU
z6S_`pZF+!KY{_{n^;WmliIUsgq1!vkI8er+GE!A>g5j=XU(PG*dF6^S-2*&_cv4k$
z^Kp4?ecX2CA-P$*CR_L=$xk&z8X6*Z96$DARU50S8q+J0w8yHf6;st8dxyN9c9GE{
z&r@%63@ZD+7pOun3TE+hfwz8Iu<eJ#Q4)U(0;X`ZV62!8<DBuVftr!7o`IuNgpKi3
zf>c^5<LS?+JPuEqs&#PDVdZR~VC#XE2f_rlh^9(n4{-+pkb<5;_yPAL`k;{mQ@<cC
z0xL63*9f*%0uf+)tV2aj92Lc0J!^DVG*6uaw$7(-POmk`R^T~qY$cHu6T=K6A1t=-
zC%aZS3IYooq0yy^E@((n<WeO+biD(40d;wiif>SHiHc{bc#ewasd#}3iwdM2LeehD
z7g4B^jP`x^A&E<0X2P)u@UG<q3D~c{OJ9z9e!{Fts&v|OGtgs9$#0X)8p)iOSc*Lc
zkt#rde3iNvsk`jm8-Xj^r3vKZcc`O)Dcy4D?c?_>;H*ahN6HXDwR)E!Atp;Ofia2I
zKwnD$-z#`qGScrpDfmtb9)pnFZcJ)l-~|yai)8?$!3^^}f*0VSd56Or@+OXI2G~Y0
zooS45+S5m(!O$WE>ah4UqBsYsf?jTFY)DFBG#p+>O&LzRB44JqSEwMufa@a*3OweF
z$;M^TqPysae&RcU-HSpOwJ4n32pu_SSmyB?kg7c%v0?$yqHN5Ym$KTKkz-282_uuY
zv#0+Em1$2W?|LM8fWx94Atb4=3v(I_$3r9jV~>#48f+=ElfLvJ6sPR9FP-78wc{WM
zb62fS<a*Y?k7FdYz1<Aps`T+FNPNw%bDCY>C+Mm&vW&!YRf(mjQi$oXDh58{HhF*~
znDAy~c4c0jwPcMUO-9(l@VJUXFkUYh=?iCIm1gwFVd;mm1NtP}>tComYA<ji@e|mn
zL>2+lq2&R>X+a#U5kFC8Cd3z}xVZ7@bIe~Ly)y9^b)tDkhs%4{#a$Q~Oh>az;s{6v
z&FM~h0o&=wjTd~<h5#*zeSnA)pUR~@p(K#<oJhdYND$_cAmoxWZ{m$Db|kq!lcIbH
zwRTfe)c2{COeEi-;%zFfqfljMI7BX}%<w=}HvA6=4Qk$TU7Pn3sbVzH@1EQDVt!{&
zQuR-qV5F0Pc6q{JYL2m>r{^y`7bqc_`s0+fYaDPIw#X3BGm%Osp2Vq7#6;Nyg(VQ!
zGsY!E&?f%X;8nV|V5F~}0g!2VW1vtnNS0urtQEd8P|U{y1)=e400ju0V_X4v*z<-+
zn&OCEo8XBA5nfC%p3hp3F%GY-{8c-DLmX9jCWDgb6`04&QxIQ%l7&=^yP1!GrXRob
z@?`068BgsaXDl5_$CEETS)kR!Q7EQVMIY`qyZYNA;bfPhk~ToHB=(jwN6(swGhsgy
zIrIzS=cYKWievb>c4eeFHIeW0OXl5!vB<H7CL+g8PcCxb{Qt8bthL#$rT6Pr_Oou0
z`yodPa0)=^K-RY7%QzVixS|KFuX8`Abv)oTYyAxxy?!Ox9S^>0ZS6-mu13SyauPoJ
zMKT_DGq-h^+|uW_q6jxH;h}{y2oCnvj<-KGCw-CnxBY(JjT5X)tR6+R0Ue7Sq-GD9
zgoq{|(s`x5ayD1Wn;0bDrGmIaZcy<)if(HM`KLY6SpER5$o9Oj`^-$2o!yP7`LQlG
z=_0T3l++)BiifHwqabM4C$uU*ps)RqiVvwE2JhCVKG~s$QcSzhEqP3|GaS3j9DDM!
z1I&tlfkIT4%o&yi$6mzAw}r&9Qegg_=HPMf1@2uo+UVsnXX&XCY5NS8KB>`|rzs66
z;$faHA?JLmfIf-02(%}o_axpTEF&41L~eaf$s#u=trWSLm9mfxPC>lyBkIGW^P4+_
z;tlG^nRiUsRM9-7>1U!8atV?+q06tV6eMY-G7UlXq#N_)=Ymp`|D+qT7z!!l1f}+0
z(+$g;=$46vzTjh05%-jQ>-q#LA|OIV+<R`eo9VBt_o7jlAbYn$&+qSsxap!g<(}3K
z=-{dq`^kte_$K7BzG{6G^_&2tao`V}F{xZxwKkFN1ldV*GU4iY0`knM2|Br=G^>~A
zo^&8WA|W>M#B_52fFO2%+TbkR5Wg|Sy|UPx<h^ZEnX8xO_b_zQC@B;AvVM)S=Uy}z
zUjGY;BiS{P-Z;a7*b3Wh1)X-SUc*rkC(G-o<igSmw`H^)cmr)T439HYaH9Bi)*@-$
zr!7WOKL6LLRh*(j%*KC6=KJ62@b|NI81N2v+VfvE04zST1snpH)Z5ilS)2*Hmd}g3
z4ewy+^>CQ7!|mN}Bic?JKh$qC5K-ru$n&YdzTWje(jqAgh_dGLCeEK(#tddI<Dq-Z
zO5tRC^D*r!S$q20(?GA&Zm6nl({;XWtGaCuB6k!}y<yvQX4E~h2{q+2RJ=yTn^e3-
z#SJRxyesce@d*`^K*lxl6G?tSQ9E8j(J&jOMzb;BSZORY%8lj5JKRs23}8mv#$P}x
zw(UkeC{hYXgW;jPjd`l9?=AWK->rsTvLDIM4miknm-Qb9R`nkTR{8q4Th?#-9Lx6z
zt!x<GM$sQT=zdbyWCfp)6vI??gtIDbo2rsE-@`c8P~N59A}M*=DpmEGw%>K~558QW
SYiRnngw4dV3m5;^F#Zi$z5)mU
diff --git a/navipy/moving/__pycache__/test_maths.cpython-35.pyc b/navipy/moving/__pycache__/test_maths.cpython-35.pyc
deleted file mode 100644
index c9562c6a7391a164142221e8d1638f6fb06a0aaa..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3655
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
diff --git a/navipy/moving/agent.py~ b/navipy/moving/agent.py~
deleted file mode 100644
index c6b4210..0000000
--- a/navipy/moving/agent.py~
+++ /dev/null
@@ -1,361 +0,0 @@
-"""
-
-"""
-import numpy as np
-import pandas as pd
-import networkx as nx
-import multiprocessing
-from multiprocessing import Queue, JoinableQueue, Process
-import inspect
-try:
- from pandas.api.types import is_numeric_dtype
-except ImportError:
- from pandas.core.common import is_numeric_dtype
-from navipy.database import DataBaseLoad
-import navipy.moving.maths as navimomath
-
-
-def defaultcallback(database, posorients):
- raise NameError('No Callback')
-
-
-class AbstractAgent():
- """
- An abtract class for agent
- """
-
- def __init__(self,
- database_filename,
- memory_friendly=False):
-
- self.db = DataBaseLoad(database_filename)
- self.dbname = database_filename
- if memory_friendly:
- self.__posorients = None
- else:
- self.__posorients = self.db.posorients
- # set mode of motion
- mode_move = {'mode': 'on_cubic_grid',
- 'param': {'grid_spacing':
- pd.Series(data=1,
- index=['dx', 'dy', 'dz'])}}
- self.mode_of_motion = mode_move
-
- @property
- def posorients(self):
- toreturn = self.__posorients
- if toreturn is not None:
- toreturn = toreturn.copy()
- return toreturn
-
- @property
- def mode_of_motion(self):
- """
- """
- toreturn = self.__mode_move
- toreturn['describe'] = \
- navimomath.mode_moves_supported()[
- self.__mode_move['mode']]['describe']
- return toreturn
-
- @mode_of_motion.setter
- def mode_of_motion(self, mode):
- """
-
- """
- if not isinstance(mode, dict):
- raise TypeError('Mode is not a dictionary')
- if 'mode' not in mode:
- raise KeyError("'mode' is not a key of mode")
- if 'param' not in mode:
- raise KeyError("'param' is not a key of mode")
- if mode['mode'] in navimomath.mode_moves_supported().keys():
- for param in navimomath.mode_moves_supported()[
- mode['mode']]['param']:
- if param not in mode['param']:
- raise KeyError(
- "'{}' is not in mode['param']".format(param))
- self.__mode_move = mode
- else:
- raise ValueError('mode is not supported')
-
- def abstractmove(self, posorients_vel):
- if isinstance(posorients_vel, pd.Series) is False:
- raise TypeError('posorients_vel should be a pandas Series')
- for col in ['x', 'y', 'z', 'alpha_0', 'alpha_1', 'alpha_2',
- 'dx', 'dy', 'dz', 'dalpha_0', 'dalpha_1', 'dalpha_2']:
- if col not in posorients_vel.index:
- raise KeyError(
- 'posorients_vel should have {} as index'.format(col))
- # Compute the next position
- posorients_vel = navimomath.next_pos(
- posorients_vel,
- move_mode=self.__mode_move['mode'],
- move_param=self.__mode_move['param'])
-
- # Compute the closest possible position
- if posorients_vel is None:
- tmp = navimomath.closest_pos_memory_friendly(
- posorients_vel,
- self.db)
- posorients_vel[['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2']] = tmp
- posorients_vel.name = tmp.name
- else:
- tmp = navimomath.closest_pos(
- posorients_vel,
- self.__posorients)
- posorients_vel[['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2']] = tmp
- posorients_vel.name = tmp.name
- return posorients_vel
-
-
-class Single(AbstractAgent, Process):
-
- def __init__(self,
- database_filename,
- initial_condition,
- memory_friendly=False,
- posorients_queue=None,
- results_queue=None):
- if (posorients_queue is not None) and (results_queue is not None):
- multiprocessing.Process.__init__(self)
- AbstractAgent.__init__(self, database_filename,
- memory_friendly)
-
- self.__posorientvel = pd.Series(
- data=0,
- index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2',
- 'dx', 'dy', 'dz',
- 'dalpha_0', 'dalpha_1', 'dalpha_2'],
- dtype=np.float)
-
- if isinstance(initial_condition, pd.Series):
- if is_numeric_dtype(initial_condition):
- common_id = list(set(initial_condition.index).intersection(
- self.__posorientvel.index))
- self.__posorientvel.loc[common_id] = \
- initial_condition.loc[common_id]
- else:
- raise TypeError('vel should be numeric')
-
- else:
- raise TypeError('vel should be a pandas Series')
-
- self.__posorients_queue = posorients_queue
- self.__results_queue = results_queue
- self.__callback_function = defaultcallback
-
- def move(self):
- # Compute the next position
- tmp = self.__callback_function(database=self.db,
- posorient=self.__posorientvel)
- common_id = list(set(tmp.index).intersection(
- self.__posorientvel.index))
- self.__posorientvel.loc[common_id] = tmp.loc[common_id]
- self.__posorientvel = self.abstractmove(self.__posorientvel)
-
- def fly(self, nsteps):
- """move until either speed is null, or nsteps has been reached"""
- prev_move = self.__posorientvel
- for stepi in range(nsteps):
- self.move()
- if prev_move.equals(self.__posorientvel):
- break
- prev_move = self.__posorientvel
-
- def run(self):
- """ Only supported when multiprocess"""
- if self.__posorients_queue is None or self.__results_queue is None:
- raise NameError('Single agent class has not be inititialised '
- + 'with multiprocessing suppport')
- proc_name = self.name
- print('Process {} started'.format(proc_name))
- while True:
- start_posorient = self.__posorients_queue.get(timeout=1)
- if start_posorient is None:
- # Poison pill means shutdown)
- break
- common_id = list(set(start_posorient.index).intersection(
- self.__posorientvel.index))
- self.__posorientvel.loc[common_id] = start_posorient.loc[common_id]
- self.move()
- next_posorient = self.__posorientvel
-
- self.__posorients_queue.task_done()
- self.__results_queue.put((start_posorient, next_posorient))
- self.__posorients_queue.task_done()
- print('Process {} done'.format(proc_name))
-
- @property
- def callback_function(self):
- return inspect.getsourcelines(self.__callback_function)
-
- @callback_function.setter
- def callback_function(self, callback_function):
- self.__callback_function = callback_function
-
- @property
- def position(self):
- return self.__posorientvel.loc[['x', 'y', 'z']]
-
- @property
- def velocity(self):
- return self.__posorientvel.loc[['dx', 'dy', 'dz']]
-
- @property
- def orientation(self):
- return self.__posorientvel.loc[['alpha_0', 'alpha_1', 'alpha_2']]
-
- @property
- def angular_velocity(self):
- return self.__posorientvel.loc[['dalpha_0', 'dalpha_1', 'dalpha_2']]
-
-
-class Multi(AbstractAgent):
-
- def __init__(self, database_filename):
- super().__init__(database_filename, False)
- # Init the graph
- self.__graph = nx.DiGraph()
- for row_id, posor in self.db.posorients.iterrows():
- posor.name = row_id
- self.__graph.add_node(row_id,
- posorient=posor)
-
- @property
- def graph(self):
- return self.__graph
-
- @graph.setter
- def graph(self, graph):
- if isinstance(graph, nx.DiGraph) is False:
- raise TypeError('graph is not a nx.DiGraph')
- self.__graph = graph.copy()
- self.check_graph()
-
- def build_graph(self, callback_function,
- ncpu=5,
- timeout=1):
- # Build a list of nodes
- results_edges = []
- posorients_queue = JoinableQueue()
- results_queue = Queue()
- for node in self.__graph.nodes:
- posorients_queue.put(self.__graph.nodes[node]['posorient'])
- initpos = 0 * self.__graph.nodes[node]['posorient']
-
- # Start ndatabase loader
- num_agents = ncpu
- agents = [Single(self.dbname,
- initial_condition=initpos,
- memory_friendly=False,
- posorients_queue=posorients_queue,
- results_queue=results_queue)
- for _ in range(num_agents)]
- for w in agents:
- w.callback_function = callback_function
- w.start()
-
- # Add a poison pill for each agent
- for _ in range(num_agents):
- posorients_queue.put(None)
-
- # Wait for all of the tasks to finish
- # posorients_queue.join()
-
- for _ in range(nx.number_of_nodes(self.__graph)):
- result = results_queue.get(timeout=timeout)
- results_edges.append((result[0].name,
- result[1].name))
- # print(results_edges[-1])
- self.__graph.add_edges_from(results_edges)
- self.check_graph()
-
- def check_graph(self):
- self.check_single_target()
-
- def check_single_target(self):
- for node in self.__graph.nodes:
- # not connected -> loop not ran
- for count, _ in enumerate(self.__graph.neighbors(node)):
- # count == 0 -> connected to one node
- # count == 1 -> connected to two nodes
- if count > 0:
- raise ValueError(
- 'Node {} leads to several locations'.format(node))
-
- def find_attractors(self):
- """Return a list of node going to each attractor in a graph
- """
- attractors = list()
- for attractor in nx.attracting_components(self.__graph):
- att = dict()
- att['attractor'] = attractor
- attractors.append(att)
- return attractors
-
- def find_attractors_sources(self, attractors=None):
- """Find all sources going to each attractors
- """
- if attractors is None:
- attractors = self.find_attractors()
-
- if isinstance(attractors, list) is False:
- raise TypeError('Attractors should be a list of dict')
- elif len(attractors) == 0:
- raise ValueError('No attractors found')
-
- # Check attractor
- for att in attractors:
- keyatt = att.keys()
- if 'attractor' not in keyatt:
- raise ValueError(
- 'Each attractors should contain the key attractor')
-
- # Calculate connection
- for att_i, att in enumerate(attractors):
-
- # [0] because one node of the attractor is enough
- # all other node of the attractor are connected to this one
- target = list(att['attractor'])[0]
- attractors[att_i]['paths'] = \
- nx.shortest_path(self.graph, target=target)
- attractors[att_i]['sources'] = \
- list(attractors[att_i]['paths'].keys())
- return attractors
-
- def catchment_area(self, attractors=None):
- """Return the catchment area for attractors
- """
- if attractors is None:
- attractors = self.find_attractors_sources()
-
- if isinstance(attractors, list) is False:
- raise TypeError('Attractors should be a list of dict')
- elif len(attractors) == 0:
- raise ValueError('No attractors found')
-
- # Check attractor
- for att in attractors:
- keyatt = att.keys()
- if 'sources' not in keyatt:
- raise ValueError(
- 'Each attractors should contains a list of sources')
-
- return [len(att['sources']) for att in attractors]
-
- def reach_goals(self, goals):
- """ Return all paths to the goals """
- return nx.shortest_path(self.__graph, target=goals)
-
- def neighboring_nodes(self, target):
- """ Return the nodes going to the target """
- # Reverse graph because nx.neighbors give the end node
- # and we want to find the start node going to target
- # not where target goes.
- tmpgraph = self.__graph.reverse(copy=True)
- neighbors = tmpgraph.neighbors(target)
- return neighbors
diff --git a/navipy/moving/maths.py~ b/navipy/moving/maths.py~
deleted file mode 100644
index 4fd7a5b..0000000
--- a/navipy/moving/maths.py~
+++ /dev/null
@@ -1,30 +0,0 @@
-"""
-Mathematical computation are done in this module. Those involve mostly
-geometry, and predefined grids shapes
-"""
-import numpy as np
-import pandas as pd
-
-
-def next_pos(motion_vec, grid_spacing=1, grid_mode='cubic'):
- """
-
- """
- supported_grid_mode = ['cubic',
- None]
- assert isinstance(motion_vec, pd.Series),\
- 'motion vector must be a pandas Series'
- assert grid_mode in supported_grid_mode,
- 'grid mode must is not supported {}'.format(grid_mode)
-
- speed = motion_vec.loc[['dx', 'dy', 'dz']]
- position = motion_vec.loc[['x', 'y', 'z']]
- if grid_mode == 'cubic':
- speed /= np.linalg.norm(speed)
- scaling = grid_spacing / (2 * np.sin(np.pi / 8))
- elif grid_mode == None:
- scaling = 1
- else:
- raise ValueError('grid_mode is not supported')
-
- return position + speed.rename({'dx': 'x', 'dy': 'y', 'dz': 'z'}) * scaling
diff --git a/navipy/processing/__pycache__/Scene_processing.cpython-35.pyc b/navipy/processing/__pycache__/Scene_processing.cpython-35.pyc
deleted file mode 100644
index bf537c91768bc07de71d68e914b807e94f2d4152..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 9276
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
DuP#Us
diff --git a/navipy/processing/__pycache__/__init__.cpython-35.pyc b/navipy/processing/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index dcc89be0a4833923e1595f5f3f18d97c1f3e153e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1820
zcmb7FL2uJc5KTD%vc#4192=C{Kzjip1O*N~KtBNz5(q^T?<85|-8H**TJw)MfB%N-
z_b<K^Z`V$7p+FlcPSzg3eQ)N??Co2(vVRXBym!|plm8~8&kp`S!8c^MsLA9#t~--A
z(`&2{n!Q~Mg;K0g?OiD$XuG1CeM4?Z4IVbmRSS1YN|xG6AS2D%DG6EQsPSyW(s@H{
zNgG}XX^Z<zb;YGni9p;*I6-WX44{V`8nJjo(Mzr>*U;|$yZ7!+^K3*$2NI3#eU{w;
z+<_w7nz|$Qp1T>fK@^>=0TU?>I|l^H=T>_u8@8*qVjo3)!csdsBb`egsj+pQjV}B5
z^0dMJA2--&If;2u2^(NkLa+t(g^=O87F7&8ffpV#dFcuC+;$~j<;X+;7m`k**mub7
zx(!2OlaQrDKGIG|DnL?U9%fk&vf!w?FV^nS;hSkj^pwhqQM8h)K@Pp(a!s{972F9F
zspBmafq&4)i@Q?EhErnri#Bbup7udo;)bmipCj}rW|<pk4w3TKF983!FbMu|hP$V&
zlGE9MKCH@hgsq0vy^qMlu>lRGTSMmr9`^#VIa2LRAH?IBSt9dGZ9qb~R2(Z%4m+Yq
zgDUu~qfo<}>Tk-<J0dDOBQdb23&b3DB&V=<h$b1@V6Sh3t)mCK_F_@yE$lV{d1?dL
zeIa<bMAgiIhehnO#a`;JGgz)pxC?YJOFfl>GIuU$h}cKA$5tA_z)$}?i-wAp8a1yH
zuQ$lz(mO-&Tz*M=UCCfqwAd9*RytEVE4Jy&c9G@Ai8#JQBH+#6oA2`W`?Ky}4ET2o
zULZAlx@gl(PqSRS(biRN)kSBG{R#67qa}_ubj<i+vZNObB@EjI`W~~};djj&p@X#C
z|KZaax-Hak>Taa!^6b@g=i80>T)A>S|2py4a1N!*|8EN;N^?=Q`U@A&8GTc{mfD4)
zF}3B5#<^1r=g(eTuhPIO;@`T96L&bUiuqhy-OT5C-F>_H$T-zj@;HyD9=?<Ba-U!#
diff --git a/navipy/processing/__pycache__/constants.cpython-35.pyc b/navipy/processing/__pycache__/constants.cpython-35.pyc
deleted file mode 100644
index 8de0152796b7d7ec0ddbe8ced40f12d156c84a0e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 592
zcmY+Av2MaJ5QZ;66QEEkp)xacVQBpVRn>v69a?qCVwv~~mJ&OP4FVpeW4As|mkwS#
z<rO;h5<~$@{(b)Z`_AW4zu*1(evCgF06%av+7v&~wC^MmASMk!Hb6E(wm_bN3_&#^
zCK%PcUGvVKlk?c$t++e~*#p&rn3DACTf`|F@m)5Gk8k~RD!20!X@P1$OxZ5rWir@~
zx>I~p8pqaTI8KbVPH5Nl9ZYd0oHDwk7QjbhtFonAltHx%3nA6gmee=+VC{pA54Ju^
z7D8)GeJ3$lZZv9FHpvlpOqNkDsl?MH@)76KB%J#z&TYQHLM0;QN=r=8?r<UshgJ!F
zgfBT)vphK^=9COL#|<7V@sRVXHdQ{rPbh};s#<<uS%!4V(xuu8HWdyvd&b;Y=CWLi
zm719~bH=2!-c<W}{VA*p^9{=jLyxvf&)NR(>}|gB?Yqp#Ws3Jz|Mr?BY=l7=^l0vN
HzaH2h31^_8
diff --git a/navipy/processing/__pycache__/pcode.cpython-35.pyc b/navipy/processing/__pycache__/pcode.cpython-35.pyc
deleted file mode 100644
index b72a525ba7f6eba6b6841a27d11412b61ff87267..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 6530
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
C_N(gv
diff --git a/navipy/processing/__pycache__/processing.cpython-35.pyc b/navipy/processing/__pycache__/processing.cpython-35.pyc
deleted file mode 100644
index 060aeb1c51a4334d3fc721c83b0fde930c0c4c57..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 7709
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
diff --git a/navipy/processing/__pycache__/scene.cpython-35.pyc b/navipy/processing/__pycache__/scene.cpython-35.pyc
deleted file mode 100644
index eb3ef2c60648b7f1112519518355f4eef2d8e8c5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1233
zcmaJ=O>Z1U5UtrS$Ae=|2yrWkgT1iqV8m&K5J}*MoCqT%*0NUZ>E7LTX1a&&p0(F9
z7e4+3_Z;$ra+zyR`2~?U@n(iGs~l)em8!dHs`|aE{_x?$SpW3m=eK>L*R-<+u)l%$
zFQFvS96BP|qb#C%ue19!AJm8S*C#okKYBDD*4wl3@b<4q>{DeFr^4{1VyA@UrL#E;
zmLiBt;T0<#*2=NePNgB+^5vFSdZW#%^N6^xUI%T>XVz(Df~aji)+UrV-l#EK$4J6j
zvRxuKGG~f2jmp|Io~~Mayc9l+<M<6w(P;|Q&8pE3Ax|Lw7pOa6jp+G4xlbrG+Yr%J
zkAClw#|f~)j_9|D?uf3yLBIKBKzBH&-mlmqrb+T=%T`3YMi|o7h?WETs0{^O;#EY%
zKd4YT0}w59BEanM1LuGEff+n0!_Ho78P`a~zb75qX&f`wtPoD*_l(aF_bu3e4EDdb
z=t!Cg?{_0nudOuWy1Fn@cs^4o?)e(+LM^FoX7Tya&C%p&3%P}etXPZ1=bdrV8DAV-
z@Uc`&QD%Wptx*%!Q#EB{1D9UO@own`OnpNb=qI|ZmpW}bj)tohMr8@;_v2E}6ow^!
zr_ujkaoU!24cERd*Rp-CGPP-nO<3IOybS9Jr)y!1$|ihrfd<6qHqQ|vwU~6ClZ!54
z*cNKWrkH{<=ft*c!0GMB_mr|<+cJ~&b9jf^YX3f{8a6zP_o`TXZF~?WRaLK$^HJM|
z>hO{G%GD3yJLjyM$2AWNor@LXOi}F_buDhR9}ngax^Zwl47Te-Rl^4FOL8%GfB%@Q
zZLX3_o8b{|5_@f)WVV#a(+m$$xy9q;4E{y1HuK4|ZCG2A7_o5*W8f0+(xh-URUTJe
zB~9jOv32`MU8nblP;__@eGu(O??XO~8sB(S?JXA4ri(>2G-Zxo_7FH9wFBqs_t*qB
cm)ueB!BIW<Dz~!C)Yo;GA3=?xgXp0D4?MJE2mk;8
diff --git a/navipy/processing/__pycache__/test.cpython-35.pyc b/navipy/processing/__pycache__/test.cpython-35.pyc
deleted file mode 100644
index 5215b9e25c7fc208e484f01cff0f3a4f069ef965..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 10450
zcmd^FOLJRi8UBuLmSoA2<=BaxOAVbu723E>J3t`~X%qJ{EpBV4O%W~PMCZhjBTLFT
z$BiwLRbT;|Y#3H7*fPVC9{@Y98-^K%vxEiXVZ(|AbO_J$e&?bi$w@rzu))^(^xd!T
z^S;mb9xas1#XtXPwef=&l=`b0`pY1G0gw9=1QtGq>L}HS;)ZG%VSY+A(qTNK8rd+O
zQ(IH2F%>5BYOA2OimFkRoRsQJtL>6%l#~$+P*#nydeuT_8TDNZl~J}*TQllzS~X^r
zT~St6-AF0t$C6)FcNLl%YNMXp$1K%a-SDezx7pp<ww-pXX*!O%*J4TdmqO$M9`}a`
z(6?SgBgN%eDUQjNgyT0d9MH;1J|b92Ug9}r6_iz!I5MY|Rg!pKS!HF-NE{U~->Ss1
z;8|tWB#z2+$~q$PlCtKNwIFdcJc^YZ^YfQ&*Sl!CcFVvd`N!`xo{M<gGYCBF3MMRb
zzME3Fm1?GxmsVRD#<x=Ht|6In5*zjOnxE^MAGP~?gL%hxdpl0cc2_LZGp}NpGuG95
z&M)_GY&N4pe>RLZueCdN*W9-K^7fu}HBRQk_I~LSdU_c>z1cG@Kf`J`h>UA@uKiRw
zCCv9<Z?A0IR@+?Z?6e2w3hLY4m36z{b633WKBsoIx4Yu?dL4W}&Ge?}wR_zaJ?oXe
z)5DD2c6W2d!{(gn@A+BR_TKHYb2o=T89Ae33}(W;J0r!>4o;!Q=kUl5{sMcccQD$l
zJJ>HnZKWwucd(%;ZYA~?`)DwcWdQ_a@lINKBGy_+w0LO2fJkiSP|vu7Q-BB+)#B}p
zYUU*|trG=FlyssfiLy>iOJYVRN|LDPL|M*sMs0~Wp-T>tRbEwX&8pitVu)55Gi4?h
zRAZ)09EmyQ9btNFo>^D{;1iZDDDUV{StVJf8=>b#2zSsbUb?^{UN`s0xRX<u9WZ`7
zr<w>6#}W}oh&Wb=I6}m+K*SLuj`bm~S9wf%i=5xRCG0z<AFWz%Y*t-?rg&%l{dgiF
zMB};Ws(`4Hj<Nq3<P%P6>C>7NPwn{scwTMDv_2Z_1@<MQ&P7`S0hWXu6f~VA<fO2n
zl8~c<-jjr!6$Jep4+n>J;?vrfpua~td>rgXy|y-ZetBc{&DD#SmrpOhvi{cBm!VGD
z)Edp6)3&>wXprSAudS}HE<fq?Zndo!pRF%DRHlBm-L>pp-@s?jHwONc+38<5o6m%i
zXT!+Z{VeM5Q^oAF<vw(W+NT-W&miy%7*r4EXUyHUTR-Vfxi>p)&wkFIYW2EZyX865
zK7OvX<DjZPW$)Up9nbdj*KDtK-RyMyRNwM*8!%b6>r_$KnPpI8Fvs8sgLwu;1b)%6
zO{>}7HaBfQ)$RM!_HN(oT1~6H?fMndb#2Fc-CgT>YrU@RPwR|V%#LgOX?JHEs`I+p
zxBa3nxa{m8A3EMI>5O%=?b@ziSlw;eeeS1Ue9!Fc*sG3%>8HD9*DqY&>+5uV%9-Yz
zGF+=~wEPTq+I3DaFDp}Q6r(LVE5<+vW!5-CZQgWScGqr3wYYe97lATrM#(4})l?0!
z^3eahF^|-V)CprLU6EQP)Z~BFIFV-ULXaNL3+se=xuG60if);z8iSLO6`3@@R%n)a
ztV?(<;&K0pTnaHhk!6NT)OH0rSL{k)qESI826eU(+HG)<C{r7AsB>fjY*5>PCUCon
z8VAHt1lt6=qdz*y@qm1oHG`#0g02)Lsi{I<c?H36O&MNMl(aSwfuiM-P^UCfM|w1p
zb!dasy|^D3Dp=2;&h8&+U^fkQ>BC<uS}#487%D0!3^POJL?Z_?3*~bou)Zj%h9x<a
z<U?bm+i*>@vNG5`sD5e1fmvKt-dvm;WCf#S&{x77Mx#vW@%8+5H_4gllABM+;x_8j
zYkpSri*pQ;;GATz$Y6m1B}9~ta~!dHW>Qg@%Nn{BWvqTg@a{Z;I04q*bI4(w&og+I
znOR}Des*9xJ=Y;Kbe@s?eyeBM&_p-(I_<9QoMp)hgF1sRFn9`qpEkRoQf(KYcBs@s
zIA;Zueons52H(#G-_QGo>%7Q5NWX^QT+?vTgKAiRfEq66qyX6x9s>6?s2cv$RpSU?
zClBHkV+sF{rRL;&aC`)W!@agb2vQq=29H26hZXFe7g{{6Hd7F_XA}VlK>*<s!MJx!
z3kE11paifWR~ey@-YlytL2WtW(b_=ZQ0)iSR0q~Po}7UPZYGQ+oWujW6`mE=+?_M1
z7N8L1VnY6z#iBnB7oA)rXf4N@5~YF*$rP|+kn3W5zzbqpSRgn_dZ&pdkl-Q8SW+G+
zKvb5%BHE$<83`*vhZ>FoJn#r<hk+L{?L?<R34x#JGHPR>1QUrN8I@2aL?t&<0VGRn
z8gc@@FGE0l<MJlH@K?K_VJZlX0Y}vC|L6Yw`}JxJq!@o1LIOV`Ph;>&#spEP8H-@$
zJk8{J246!^Pm7IoI1lHG3`TG>CAeu@-$9v6Tq<J@R__$Ru@pQf`3-vq0Ht90@c)>=
zWXTv*lR#-(5jx0FIFv@mK?cebIRO%Y2THgYrQKKM>I>YU6dXIJHZvMfT4JEVMcEP}
z-jqlXIuPMP2cd-Cyr2Pv+S<yD)W&HK)yCiy(y`uX*C3=t<;f*!NT!g5=|LzFLN3KB
zp}2x4xIQ2cCWUvqio#8qj)skTVNIV!QeFGT=H~Bz$G_zZjjGjlJ+s@go1kc5ah-jL
z24#Z`Of>R{F4jULiuN3;_)8!}o@0XE+_Kx7*FD>6c5Tz?;u<SDTJ*2z+*nXTuC{t}
z$LxqW!7z|sITzTaVKru=&O|eh3evm?(&*HGgvRbE1k}Ov5TYtHaZSRRbS_mg3edUB
z#^6*^kVd<S#ENA2C>{~3zaL7hJY2;<YeW|Zx(CKT);&|o6J3P+8qQFAd&0xi=Z}-t
zWeF96cEf@o9im;_lo|#enK7fUH62REv{F=(g@%FKDb_tv3H4Q60vUs+3Oo-)3!_2m
zfTw`HK|x3CZBm?c4TLQG=p=gqDUpFu$|SD(n!SZreefGB^4<}kP;aeZ09!l6&1&=k
zBx~tDA684Vv#6F}XL=%bVuGXj4w+9#YD5PM)M&NC+*tEU?)*ex5lPM)3?5O{I&foZ
zZsdH0v9B_Sc#%+`dTt0(`4FYfORV`a1B&%1u#O6_q;h~~O>cgNy5f=3(5moOGNhZA
z(!9R}bO(T22%f=m5^Ccex40|(OX%?5AeX8TAF<4^{q(!w4guK^Hj~iduLtf+92_e^
z0;$8#iiZnbL^>SKmWf(7kRfXE-B;-QB-a2|%Hthr_5QGqzK@PF2K}WlDc~R_-O)cD
zqW8687mYs6y9kxK+%_<oAszwhA)pJ&io<1SCuq_j(j5X4_(-?7J4l~_f}o|~K1bPf
z-vQt7(IPfhT8K&!8!LsD2-+gX(wlz}bZ*pVCSoZtLZ7|hypHp4ltU41y6u6zpGV##
zwC#UP`!qKZM#5MG1(AKys3I|cWN5vK$_aav;e?#G*aumL4&+|HG!B<=6~97Fmvl)G
z1FTfxxm_|A!FTYTUW92XL?}9HoWlR$@duzK>^A}otrK~gSf`7)5`Z2?w*bNh1V>
zxrT-fq&lKLn%>~-K}Mj+g`LBAP-0S|qfrE!6I%nhLDQcmiaBYrw6sQL36q6(7`-eZ
zuD;UYkVI-fDKJ8ll}U=S9&OxYMQz4RR#ZYF9hodn0Qc=-i-H^Ttk{a9&<WAvVF+aL
zfkFt{$^9U3Iv=K;I1>)v?i%h?I7)5#4l|yp3i=$dTyc)$4UIT3#XW#N?>%U-V)ZI(
z`qCg2KEB{nNz1iftls|5k=(zIOfY`2dSc`lL&m$T`yK<@LI5ewi0U4Y8}ueO77jV=
z7>H@8U;C(S-@-c*I07BG9pSli9a_*vy5IWfkzpR2OmP^9?x3Cs?IyRt&u{N(1Lzmy
z!TcO@F_d2>{G<F)<&YQUfO>yHPcF^00`%z_AS)d;pcN>HML7A!L%Qq+vq{x}UMDMp
zjZdx!fEyYKTzjCy1A955804h~1WJsD=Bog|T$Dzyyu3$8W$<>z99Um!V9W%aV~PRh
zPuh(uhNvVDkSDr~N`l*RJXll`+^}^Chpy7r#ejp4trjT;eMQ6KCnyHA8wU7c+J!)+
z={-cdgkm^EJE#G@J}wu2LcG(eXvKg|G-IY>IB2n=7^;&M!#5z*qgI-Df3SA=kgbNb
zgJg_phmqVd?J${3UqR=7w(qoYEfr6NsD_L=K{q_bc_e)pLrnT$wcxzZhO+hsW8Y*j
zLJbOnevVp#DswrB0RFg$R*l+-cZ2@@ap>zDQ2@210$|6H21sz{Ut%~47Cw){oxyh@
z58By2%6D-WldBQmQtCI6U=*Ooa*;Ja8$#mzBKR&yI4Cm=xhCQH5$=q>V(u(&mJjHQ
z-1*<~TLW-s+#v(*{5RpwlNxfdxT?y9a1wV;u#pk&oX{Q*;m#m0!`yjDlSL&U%}Iq6
zl~5sJA~BtcN_e@BN*+R)op&f{G>zICZy=VW(ebs^Sw~^LHjyaDH$}>&U)yfCuG<|K
zuM|U?DSmhD41B~Z=`dw>II)S0S;K;a`US#*eXA60B8agN<bWuHAj_+-p-bjq1On_N
zf&i}z^dJcv{_UY4;K9uNU-@c^`c2y;{|psDn12XgO=v)O-y%j}w_#(@{L+W#<&8W5
z3g3+O;4G*+aAN5#7s3$xaA1p|LT<wj;YS?2KYlOva+8f|YI+bWmG?=5W4FvMe2~j_
z_)>Sd*TM^F+k$usuM{go+aoXvbA`atnWJ+TCZdK|alXyq5g~D~mqu*Mx6qYeh-O;P
z#||5fotHRP?5nxN`l;6TsHr(2rY6F02w_cJ*9kMZhZ1J6GNZ(E*mJW0V!B`qo=Do7
z1A1Po&-nRflfRj2HvM9=x!tpNI*gZ^O?q~9i8I4he2Kv-gVz|WF?gH7Wd<KGXfiMv
zz=RCjQ?abPZ#!uOM7hhO!t3p9>5bB3rQ@ZA(uvYi>2&Go(xTMiytd7Dx7n=E`uUx1
z+v65F^bPx2{Aw<E!|3PudjivS9%n&C{|M_$_<JvhI;C+m$c=xRbw<B*EXFx<`|u~!
y<S)Hk?fmA?D`akt&A~F9-q1ltYxMKy^gf=)!9@$jm7#<ehvLjmFWy&n$@nj)?`NU_
diff --git a/navipy/processing/__pycache__/tools.cpython-35.pyc b/navipy/processing/__pycache__/tools.cpython-35.pyc
deleted file mode 100644
index 4b13d82876b9b00e7c5067fa526792351985f8b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 5262
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
diff --git a/navipy/processing/constants.py~ b/navipy/processing/constants.py~
deleted file mode 100644
index 1839e29..0000000
--- a/navipy/processing/constants.py~
+++ /dev/null
@@ -1,22 +0,0 @@
-"""
-Define some constant
-"""
-
-__spherical_indeces__ = {'elevation': 0,
- 'azimuth': 1,
- 'radius': 2}
-__cartesian_indeces__ = {'x': 0,
- 'y': 1,
- 'z': 2}
-__ibpc_indeces__ = {'elevation': 0,
- 'azimuth': 1,
- 'channel': 2,
- 'component': 3}
-__obpc_indeces__ = {'ommatidia': 0,
- 'channel': 1,
- 'component': 2}
-__eye_indeces__ = {'elevation': 0,
- 'azimuth': 1,
- 'component': 2}
-__ommadia_indeces__ = {'ommatidia': 0,
- 'component': 1}
diff --git a/navipy/processing/test.py~ b/navipy/processing/test.py~
deleted file mode 100644
index daa12ed..0000000
--- a/navipy/processing/test.py~
+++ /dev/null
@@ -1,368 +0,0 @@
-import unittest
-import sqlite3
-import numpy as np
-import pandas as pd
-import navipy.database as database
-import navipy.processing.pcode as pcode
-from navipy.processing.tools import is_numeric_array
-import pkg_resources
-
-
-class TestCase(unittest.TestCase):
- def setUp(self):
- self.mydb_filename = pkg_resources.resource_filename(
- 'navipy', 'resources/database.db')
- self.mydb = database.DataBaseLoad(self.mydb_filename)
-
- def test_scene_posorient(self):
- conn = sqlite3.connect(self.mydb_filename)
- c = conn.cursor()
- c.execute(""" SELECT * FROM position_orientation WHERE (rowid=1) """)
- rows = c.fetchall()[0]
- # working case
- posorient = pd.Series(index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
- posorient.x = rows[5]
- posorient.y = rows[6]
- posorient.z = rows[1]
- posorient.alpha_0 = rows[3]
- posorient.alpha_1 = rows[2]
- posorient.alpha_2 = rows[4]
- image = self.mydb.read_image(posorient=posorient)
- image = np.expand_dims(image, axis=3)
- self.assertIsNotNone(image)
- self.assertFalse(sum(image.shape) == 0)
- # print("shape",image.shape)
- self.assertTrue(len(image.shape) == 4)
- self.assertTrue(image.shape[3] == 1)
-
- # incorrect case missing column
- posorient2 = pd.Series(index=['y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
- posorient2.y = posorient.y
- posorient2.z = posorient.z
- posorient2.alpha_0 = posorient.alpha_0
- posorient2.alpha_1 = posorient.alpha_1
- posorient2.alpha_2 = posorient.alpha_2
- with self.assertRaises(Exception):
- image = self.mydb.read_image(posorient=posorient2)
-
- # incorrect case None
- posorient2 = pd.Series(index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
- posorient2.x = None
- posorient2.y = posorient.y
- posorient2.z = posorient.z
- posorient2.alpha_0 = posorient.alpha_0
- posorient2.alpha_1 = posorient.alpha_1
- posorient2.alpha_2 = posorient.alpha_2
- with self.assertRaises(ValueError):
- image = self.mydb.read_image(posorient=posorient2)
-
- # incorrect case nan
- posorient2 = pd.Series(index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
- posorient2.x = np.nan
- posorient2.y = posorient.y
- posorient2.z = posorient.z
- posorient2.alpha_0 = posorient.alpha_0
- posorient2.alpha_1 = posorient.alpha_1
- posorient2.alpha_2 = posorient.alpha_2
- with self.assertRaises(ValueError):
- image = self.mydb.read_image(posorient=posorient2)
-
- # incorrect case no pandas series but dict
- posorient2 = {}
- posorient2['x'] = posorient.x
- posorient2['y'] = posorient.y
- posorient2['z'] = posorient.z
- posorient2['alpha_0'] = posorient.alpha_0
- posorient2['alpha_1'] = posorient.alpha_1
- posorient2['alpha_2'] = posorient.alpha_2
- with self.assertRaises(TypeError):
- image = self.mydb.read_image(posorient=posorient2)
-
- # not working case empty
- posorient2 = pd.Series(index=['x', 'y', 'z',
- 'alpha_0', 'alpha_1', 'alpha_2'])
-
- with self.assertRaises(Exception):
- image = self.mydb.read_image(posorient=posorient2)
-
- def test_skyline_scene(self):
- scene = self.mydb.read_image(rowid=1)
- scene2 = scene.copy()
- scene = np.expand_dims(scene, axis=3)
- scene2 = np.expand_dims(scene2, axis=3)
- scene2[3, 5, 2, 0] = np.nan
- scene3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- scene3 = [scene3, scene3, scene3]
- scene3 = np.array(scene3)
- scene4 = np.zeros((3, 4, 5, 0))
-
- # put useless stuff here
- with self.assertRaises(ValueError):
- pcode.skyline(scene2)
- with self.assertRaises(TypeError):
- pcode.skyline(scene3)
- with self.assertRaises(Exception):
- pcode.skyline(scene4)
-
- # should be working -> check if result(skyline) is correct
- for s in [scene]:
- skyline = pcode.skyline(s)
- self.assertFalse(skyline.shape[1] <= 0)
- self.assertTrue(skyline.shape[2] == 4)
- self.assertFalse(np.any(np.isnan(skyline)))
- # self.assertFalse(np.any(np.isNone(skyline)))
- self.assertTrue(is_numeric_array(skyline))
- self.assertTrue(skyline.shape[3] == 1)
- self.assertTrue(skyline.shape[0] > 0)
- self.assertTrue(skyline.shape[1] > 0)
-
- def test_id(self):
- for rowid in [0, -2]:
- with self.assertRaises(ValueError):
- # print("rowid",rowid)
- self.mydb.read_image(rowid=rowid)
- with self.assertRaises(TypeError):
- self.mydb.read_image(rowid='T')
- with self.assertRaises(TypeError):
- self.mydb.read_image(rowid=None)
- with self.assertRaises(TypeError):
- self.mydb.read_image(rowid=np.nan)
- with self.assertRaises(TypeError):
- self.mydb.read_image(rowid=4.5)
-
- for rowid in [1, 2, 3, 4, 5]:
- image = self.mydb.read_image(rowid=rowid)
- image = np.expand_dims(image, axis=3)
- # image=np.array(image)
- self.assertIsNotNone(image)
- self.assertFalse(sum(image.shape) == 0)
- self.assertTrue(len(image.shape) == 4)
- self.assertFalse(np.any(np.isnan(image)))
- self.assertTrue(image.shape[3] == 1)
- self.assertTrue(image.shape[2] == 4)
- self.assertTrue(image.shape[0] > 0)
- self.assertTrue(image.shape[1] > 0)
-
- def test_distance_channel(self):
- scene = self.mydb.read_image(rowid=1)
- scene = np.expand_dims(scene, axis=3)
- # should not be working
- for d in ['g', None, np.nan, 8.4]:
- with self.assertRaises(TypeError):
- pcode.contrast_weighted_nearness(scene,
- distance_channel=d)
- with self.assertRaises(ValueError):
- pcode.contrast_weighted_nearness(scene,
- distance_channel=-1)
-
- # should work
- d = 3
- weighted_scene = \
- pcode.contrast_weighted_nearness(scene,
- distance_channel=d)
- # print("last channel",d)
- self.assertTrue(is_numeric_array(weighted_scene))
- self.assertTrue(~np.any(np.isnan(weighted_scene)))
- self.assertEqual(weighted_scene.shape, scene.shape)
-
- def test_contr_weight_scene(self):
- scene = self.mydb.read_image(rowid=1)
- scene = np.expand_dims(scene, axis=3)
- # working cases
- contrast = pcode.contrast_weighted_nearness(scene)
- self.assertIsNotNone(contrast)
- self.assertFalse(sum(contrast.shape) == 0)
- self.assertTrue(len(contrast.shape) == 4)
- self.assertFalse(np.any(np.isnan(contrast)))
- self.assertTrue(contrast.shape[3] == 1)
- self.assertTrue(contrast.shape[2] == 4)
- self.assertTrue(contrast.shape[0] > 0)
- self.assertTrue(contrast.shape[1] > 0)
-
- # not working case
- scene2 = scene.copy()
- scene2[3, 2, 1, 0] = np.nan
- scene3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- scene3 = [scene3, scene3, scene3]
- scene3 = np.array(scene3)
- scene4 = np.zeros((3, 4, 5, 0))
- with self.assertRaises(ValueError):
- contrast = pcode.contrast_weighted_nearness(scene2)
- with self.assertRaises(Exception):
- contrast = pcode.contrast_weighted_nearness(scene3)
- with self.assertRaises(Exception):
- contrast = pcode.contrast_weighted_nearness(scene4)
-
- def test_contr_weight_contrast(self):
- scene = self.mydb.read_image(rowid=1)
- scene = np.expand_dims(scene, axis=3)
- for size in [9.4, 'g', None, np.nan]:
- with self.assertRaises(TypeError):
- contrast = pcode.contrast_weighted_nearness(
- scene, contrast_size=size)
- for size in [8, 1, 0, -4]:
- with self.assertRaises(ValueError):
- contrast = \
- pcode.contrast_weighted_nearness(
- scene, contrast_size=size)
-
- # working cases
- for size in [2, 3, 4, 5]:
- contrast = pcode.contrast_weighted_nearness(scene,
- contrast_size=size)
- self.assertIsNotNone(contrast)
- self.assertFalse(sum(contrast.shape) == 0)
- self.assertTrue(len(contrast.shape) == 4)
- self.assertFalse(np.any(np.isnan(contrast)))
- self.assertEqual(contrast.shape[3], 1)
- self.assertEqual(contrast.shape[2], scene.shape[2])
- self.assertEqual(contrast.shape[0], scene.shape[0])
- self.assertEqual(contrast.shape[1], scene.shape[1])
-
- def test_pcv(self):
- # working case
- rowid = 1
- my_scene = self.mydb.read_image(rowid=rowid)
- my_scene = np.expand_dims(my_scene, axis=3)
- directions = self.mydb.viewing_directions
- my_pcv = pcode.pcv(my_scene, directions)
- self.assertIsNotNone(my_pcv)
- self.assertFalse(sum(my_pcv.shape) == 0)
- self.assertTrue(len(my_pcv.shape) == 4)
- self.assertFalse(np.any(np.isnan(my_pcv)))
- self.assertTrue(my_pcv.shape[3] == 3)
- self.assertTrue(my_pcv.shape[2] == 4)
- self.assertTrue(my_pcv.shape[0] > 0)
- self.assertTrue(my_pcv.shape[1] > 0)
-
- # not working cases doesnt match with shape of place code
- testdirection = np.zeros((2, 4, 2))
- with self.assertRaises(Exception):
- my_pcv = pcode.pcv(my_scene, testdirection)
-
- # not working cases wrong last dimension
- testdirection = np.zeros((180, 360, 1))
- with self.assertRaises(Exception):
- my_pcv = pcode.pcv(my_scene, testdirection)
-
- # not working cases too many dimensions
- testdirection = np.zeros((180, 360, 2, 4))
- with self.assertRaises(Exception):
- my_pcv = pcode.pcv(my_scene, testdirection)
-
- # not working cases empty
- testdirection = np.zeros(())
- with self.assertRaises(Exception):
- my_pcv = pcode.pcv(my_scene, testdirection)
-
- # not working cases nans
- testdirection = np.zeros((180, 360, 2, 4))
- testdirection[2, 3, 0] = np.nan
- with self.assertRaises(ValueError):
- my_pcv = pcode.pcv(my_scene, testdirection)
-
- def test_apcv(self):
- # working case
- rowid = 1
- my_scene = self.mydb.read_image(rowid=rowid)
- my_scene = np.expand_dims(my_scene, axis=3)
- # print("scene shape",my_scene.shape)
- directions = self.mydb.viewing_directions
- print("directions", directions.shape)
- my_pcv = pcode.apcv(my_scene, directions)
-
- self.assertIsNotNone(my_pcv)
- self.assertFalse(sum(my_pcv.shape) == 0)
- self.assertTrue(len(my_pcv.shape) == 4)
- self.assertFalse(np.any(np.isnan(my_pcv)))
- self.assertTrue(my_pcv.shape[3] == 3)
- self.assertTrue(my_pcv.shape[2] == 4)
- self.assertTrue(my_pcv.shape[0] == 1)
- self.assertTrue(my_pcv.shape[1] == 1)
-
- # not working cases doesnt match with shape of place code
- testdirection = np.zeros((2, 4, 2))
- with self.assertRaises(Exception):
- my_pcv = pcode.apcv(my_scene, testdirection)
-
- # not working cases wrong last dimension
- testdirection = np.zeros((180, 360, 1))
- with self.assertRaises(Exception):
- my_pcv = pcode.apcv(my_scene, testdirection)
-
- # not working cases too many dimensions
- testdirection = np.zeros((180, 360, 2, 4))
- with self.assertRaises(Exception):
- my_pcv = pcode.apcv(my_scene, testdirection)
-
- # not working cases empty
- testdirection = np.zeros(())
- with self.assertRaises(Exception):
- my_pcv = pcode.apcv(my_scene, testdirection)
-
- # not working cases nans
- testdirection = np.zeros((180, 360, 2, 4))
- testdirection[2, 3, 0] = np.nan
- with self.assertRaises(ValueError):
- my_pcv = pcode.apcv(my_scene, testdirection)
-
- def test_size(self):
- # not working cases:
- scene = self.mydb.read_image(rowid=1)
- scene = np.expand_dims(scene, axis=3)
- for size in [8, 1, 0, -4]:
- with self.assertRaises(ValueError):
- contrast = pcode.michelson_contrast(
- scene, size=size)
- for size in [9.4, 'g', None, np.nan]:
- with self.assertRaises(TypeError):
- contrast = pcode.michelson_contrast(
- scene, size=size)
-
- # working cases
- for size in [2, 3, 4, 5]:
- contrast = pcode.michelson_contrast(scene, size=size)
- self.assertIsNotNone(contrast)
- self.assertFalse(sum(contrast.shape) == 0)
- self.assertTrue(len(contrast.shape) == 4)
- self.assertFalse(np.any(np.isnan(contrast)))
- self.assertTrue(contrast.shape[3] == 1)
- self.assertTrue(contrast.shape[2] == 4)
- self.assertTrue(contrast.shape[0] > 0)
- self.assertTrue(contrast.shape[1] > 0)
-
- def test_michelsoncontrast_scene(self):
-
- scene = self.mydb.read_image(rowid=1)
- scene = np.expand_dims(scene, axis=3)
-
- # working cases
- contrast = pcode.michelson_contrast(scene)
- self.assertIsNotNone(contrast)
- self.assertFalse(sum(contrast.shape) == 0)
- self.assertTrue(len(contrast.shape) == 4)
- self.assertFalse(np.any(np.isnan(contrast)))
- self.assertTrue(contrast.shape[3] == 1)
- self.assertTrue(contrast.shape[2] == 4)
- self.assertTrue(contrast.shape[0] > 0)
- self.assertTrue(contrast.shape[1] > 0)
-
- # not working case
- scene2 = scene.copy()
- scene2[3, 2, 1, 0] = np.nan
- scene3 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
- scene3 = [scene3, scene3, scene3]
- scene3 = np.array(scene3)
- scene4 = np.zeros((3, 4, 5, 0))
- for s in [scene2, scene3, scene4]:
- with self.assertRaises(Exception) as cm:
- contrast = pcode.michelson_contrast(s,)
- print("wanted exception occured", cm.exception)
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/navipy/processing/tools.py~ b/navipy/processing/tools.py~
deleted file mode 100644
index a1c3e0f..0000000
--- a/navipy/processing/tools.py~
+++ /dev/null
@@ -1,165 +0,0 @@
-from .constants import __ibpc_indeces__
-from .constants import __spherical_indeces__
-from .constants import __cartesian_indeces__
-from .constants import __obpc_indeces__
-from .constants import __eye_indeces__
-import numpy as np
-
-
-def check_scene(scene):
- if is_ibpc(scene):
- # print("normal")
- if not is_numeric_array(scene):
- raise TypeError('scene is of non numeric type')
- if not ~np.any(np.isnan(scene)):
- raise ValueError('scene contains nans')
- if not len(scene.shape) == 4:
- raise Exception('scene has wrong shape, must have 4 dimensions')
- if not (scene.shape[1] > 0):
- raise Exception('scenes first dimension is empty')
- if not (scene.shape[0] > 0):
- raise Exception('scenes second dimension is empty')
- if not (scene.shape[2] == 4):
- raise Exception('3rd dimension of scene must be four')
- if not (scene.shape[3] == 1):
- raise Exception('4rd dimension of scene must be one')
- # assert ~(np.any(np.isNone(scene)))
- return True
-
- elif is_obpc(scene):
- if not is_numeric_array(scene):
- raise TypeError('scene is of non numeric type')
- if not ~np.any(np.isnan(scene)):
- raise ValueError('scene contains nans')
- if not len(scene.shape) == 3:
- raise Exception('scene has wrong shape, must have 4 dimensions')
- if not ~(scene.shape[1] <= 0):
- raise Exception('scenes first dimension is empty')
- if not ~(scene.shape[0] <= 0):
- raise Exception('scenes second dimension is empty')
- if not (scene.shape[2] == 4):
- raise Exception('3rd dimension of scene must be four')
- # assert ~(np.any(np.isNone(scene)))
- return True
-
-
-def check_viewing_direction(viewing_direction):
- if not is_numeric_array(viewing_direction):
- raise TypeError('viewing direction is of non numeric type')
- if not ~np.any(np.isnan(viewing_direction)):
- raise ValueError('viewing direction contains nans')
- if len(viewing_direction.shape) < 3:
- raise Exception('viewing direction must have at least 3 dimensions')
- if not (viewing_direction.shape[1] > 0):
- raise Exception('viewing direction has empty second dimension')
- if not (viewing_direction.shape[0] > 0):
- raise Exception('viewing direction has empty first dimension')
- if not (viewing_direction.shape[-1] == 2):
- raise Exception(' last dimension of viewing direction must equal 2')
- return True
-
-
-def is_numeric_array(array):
- """Checks if the dtype of the array is numeric.
-
- Booleans, unsigned integer, signed integer, floats and complex are
- considered numeric.
-
- :param array : `numpy.ndarray`-like The array to check.
- :returns: True if it is a recognized numerical and False \
- if object or string.
- :rtype:bool
- """
- numerical_dtype_kinds = {'b', # boolean
- 'u', # unsigned integer
- 'i', # signed integer
- 'f', # floats
- 'c'} # complex
- try:
- return array.dtype.kind in numerical_dtype_kinds
- except AttributeError:
- # in case it's not a numpy array it will probably have no dtype.
- return np.asarray(array).dtype.kind in numerical_dtype_kinds
-
-
-def is_ibpc(place_code):
- """Test if a place code is image based
-
- :param place_code: a place-code
- :returns: True if image based place-code
- :rtype: bool
-
- """
- toreturn = isinstance(place_code, np.ndarray)
- toreturn = toreturn and (len(place_code.shape) ==
- len(__ibpc_indeces__))
- return toreturn
-
-
-def is_obpc(place_code):
- """Test if a place code is ommatidia based
-
- :param place_code: a place-code
- :returns: True if ommatidia based place-code
- :rtype: bool
-
- """
- toreturn = isinstance(place_code, np.ndarray)
- toreturn = toreturn and (len(place_code.shape) ==
- len(__obpc_indeces__))
- return toreturn
-
-
-def ibs_to_obs(scene, eye_map):
- """Convert an image based scene to an ommatidium based scene.
-
- :param scene: The scene to be converted
- :param eye_map: The eye_map to use
- :returns: (obs_scene,ommatidia_map)
- :rtype: (np.ndarray,np.ndarray)
- """
- assert is_ibpc(scene),\
- 'scene should be an ibs scene'
- assert isinstance(eye_map, np.ndarray), 'eye_map should be a numpy array'
- assert len(eye_map.shape) == len(__eye_indeces__),\
- 'eye_map should have {} dimensions to be an ibs scene'.format(
- len(__eye_indeces__))
- for index_name in ['elevation', 'azimuth']:
- index = __ibpc_indeces__[index_name]
- assert eye_map.shape[index] == scene.shape[index],\
- 'eye_map and scene should have the same number of {}'.format(
- index_name)
- obs_size = (scene.shape[__ibpc_indeces__['elevation']] *
- scene.shape[__ibpc_indeces__['azimuth']],
- scene.shape[__ibpc_indeces__['channel']],
- scene.shape[__ibpc_indeces__['component']])
- obs_scene = scene.reshape(obs_size)
- omm_size = (eye_map.shape[__ibpc_indeces__['elevation']] *
- eye_map.shape[__ibpc_indeces__['azimuth']],
- eye_map.shape[__ibpc_indeces__['component']])
- ommatidia_map = eye_map.reshape(omm_size)
- return (obs_scene, ommatidia_map)
-
-
-def cartesian_to_spherical(x, y, z):
- radius = np.sqrt(x**2 + y**2 + z**2)
- elevation = np.arctan2(z, np.sqrt(x**2 + y**2))
- azimuth = np.arctan2(y, x)
- spherical = np.zeros_like(x)
- spherical = np.tile(spherical[..., np.newaxis], (3,))
- spherical[..., __spherical_indeces__['elevation']] = elevation
- spherical[..., __spherical_indeces__['azimuth']] = azimuth
- spherical[..., __spherical_indeces__['radius']] = radius
- return spherical
-
-
-def spherical_to_cartesian(elevation, azimuth, radius=1):
- cartesian = np.zeros_like(elevation)
- cartesian = np.tile(cartesian[..., np.newaxis], (3,))
- cartesian[..., __cartesian_indeces__['x']] = np.cos(
- elevation) * np.cos(azimuth)
- cartesian[..., __cartesian_indeces__['y']] = np.cos(
- elevation) * np.sin(azimuth)
- cartesian[..., __cartesian_indeces__['z']] = np.sin(elevation)
- cartesian = radius * cartesian
- return cartesian
diff --git a/navipy/rendering/__pycache__/DataBase.cpython-35.pyc b/navipy/rendering/__pycache__/DataBase.cpython-35.pyc
deleted file mode 100644
index ef0c231ef7a111188cecc98060abab9e4b806656..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 10254
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
diff --git a/navipy/rendering/__pycache__/__init__.cpython-35.pyc b/navipy/rendering/__pycache__/__init__.cpython-35.pyc
deleted file mode 100644
index a2503f97bf18d28410e60c9e97814282d10886d8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 166
zcmWgR<>lJ!WEsT(1dl-k3@`#24nSPY0whux7=kq!{Z=v*frJsnuVDS$)RfFb{hZRw
zsziO4#FErJ{h-u>{9^r*+=9HsvdpCX3jLD&{2U;y3*x6ImSpDV>4TUBmHI`gc`2zy
jnR)5@@$s2?nI-Y@dIgoYIBatBQ%ZAE?Ld|l12F>t*kdd^
diff --git a/navipy/rendering/bee_sampling.py~ b/navipy/rendering/bee_sampling.py~
deleted file mode 100644
index c1f388a..0000000
--- a/navipy/rendering/bee_sampling.py~
+++ /dev/null
@@ -1,164 +0,0 @@
-"""
-The beesampling class
-
-.. tothinkof: conditional bpy import to build doc from comments
-"""
-import bpy
-import os
-import numpy as np
-import pandas as pd
-import warnings
-from navipy.rendering.cyber_bee import Cyberbee
-from navipy.database import DataBaseSave
-
-
-class BeeSampling(Cyberbee):
- """
- BeeSampling is a class deriving from Cyberbee.
- The BeeSampling can be used to generate a database of
-images taken on a rectangular regular grid. For the database,
-the BeeSampling rely on DataBase
- It worth noting that the generated database can take a large
-harddrive space, as each image is composed of 4 channels of 180x360 pixels.
- """
-
- def __init__(self):
- """Initialise the BeeSampling"""
- Cyberbee.__init__(self)
- self.blenddirname = os.path.dirname(bpy.data.filepath)
- self.blendfilename = os.path.basename(bpy.data.filepath)
- self.__grid_posorients = None
- self.__grid_size = None
- self.world_dim = np.inf
-
- def create_sampling_grid(self, x, y, z, alpha1, alpha2, alpha3):
- """Create a cubic grid from all the sampling points
-
- :param x: the positions along the x-axis
- :param y: the positions along the y-axis
- :param z: the positions along the z-axis
- :param alpha1: the first euler angles
- :param alpha2: the 2nd euler angles
- :param alpha3: the 3rd euler angles
- """
- if not (isinstance(x, int) or isinstance(x, float)):
- raise TypeError('x must be integer')
- if not (isinstance(y, int) or isinstance(y, float)):
- raise TypeError('y must be integer')
- if not (isinstance(z, int) or isinstance(z, float)):
- raise TypeError('z must be integer')
- if not (isinstance(alpha1, float) or isinstance(alpha1, int)):
- raise TypeError('alpha1 must be float')
- if not (isinstance(alpha2, float) or isinstance(alpha2, int)):
- raise TypeError('alpha2 must be float')
- if not (isinstance(alpha3, float) or isinstance(alpha3, int)):
- raise TypeError('alpha3 must be float')
- [mx, my, mz, ma1, ma2, ma3] = np.meshgrid(x,
- y,
- z,
- alpha1,
- alpha2,
- alpha3)
- self.grid_size = mx.shape
- mx = mx.flatten()
- my = my.flatten()
- mz = mz.flatten()
- ma1 = ma1.flatten()
- ma2 = ma2.flatten()
- ma3 = ma3.flatten()
- self.__grid_posorients = pd.DataFrame(index=range(mx.shape[0]),
- columns=['x', 'y', 'z',
- 'alpha_0',
- 'alpha_1',
- 'alpha_2'])
- self.__grid_posorients.loc[:, 'x'] = mx
- self.__grid_posorients.loc[:, 'y'] = my
- self.__grid_posorients.loc[:, 'z'] = mz
- self.__grid_posorients.loc[:, 'alpha_0'] = ma1
- self.__grid_posorients.loc[:, 'alpha_1'] = ma2
- self.__grid_posorients.loc[:, 'alpha_2'] = ma3
- self.__grid_posorients.index.name = 'grid_index'
- self.__grid_posorients.name = 'grid_position_orientation'
-
- @property
- def grid_posorients(self):
- """return a copy of the posorientation matrix
-
- :returns: position-orientations of the grid
- :rtype: pandas array
-
- .. todo: use @property
- def grid_posorients(self)
-
- .. todo: create @property.setter
- def grid_posorients(self,posorients)
- (need a type check, and col check, and copy of df)
- """
- return self.__grid_posorients.copy()
-
- def set_gridindeces2nan(self, indeces):
- """Set certain grid point to nan, so they will be ignore in the rendering
-
- :param indeces: a list of indeces to be set to nan
-
- .. todo: use @property.setter
- def blacklist_indeces(self,indeces)
- """
- if not isinstance(indeces, list):
- raise TypeError('indeces must be a list')
- if any(np.isnan(indeces)):
- raise ValueError('indeces must not contain nans')
- self.__grid_posorients.loc[indeces, :] = np.nan
-
- def render(self, database_filename):
- if not isinstance(database_filename, str):
- raise TypeError('filename must be a string')
- database_folder = os.path.dirname(database_filename)
- if not os.path.exists(database_folder):
- os.makedirs(database_folder)
- dataloger = DataBaseSave(database_filename,
- channels=['R', 'G', 'B', 'D'],
- arr_dtype=np.uint8)
- for frame_i, posorient in self.__grid_posorients.iloc[::-1].iterrows():
- print(frame_i)
- if np.any(np.isnan(posorient)):
- # warnings.warn('frame_i: {} posorient nans'.format(frame_i))
- continue
- rowid = dataloger.posid(posorient)
- if dataloger.check_data_validity(rowid):
- warnings.warn(
- 'frame_i: {} data is valid rowid {}'.format(frame_i,
- rowid))
- continue
- # The position-orientatios is valid (none nan)
- # and the cmaxminrange has not already been assigned
- # so the image need to be rendered
- self.update(posorient)
- distance = self.distance
- distance[distance > self.world_dim] = self.world_dim
- image = self.image
- image[:, :, 3] = distance
- dataloger.write_image(posorient, image)
- print('rendering completed')
-
-
-if __name__ == "__main__":
- import tempfile
- bee_samp = BeeSampling()
- # Create mesh
- world_dim = 15.0
- x = np.linspace(-7.5, 7.5, 5)
- y = np.linspace(-7.5, 7.5, 5)
- z = np.arange(1, 8, 2)
- alpha_1 = np.array([0]) + np.pi / 2
- alpha_2 = np.array([0])
- alpha_3 = np.array([0])
- bee_samp.create_sampling_grid(
- x, y, z, alpha1=alpha_1, alpha2=alpha_2, alpha3=alpha_3)
- bee_samp.world_dim = world_dim
- grid_pos = bee_samp.grid_posorients
- condition = (grid_pos.x**2 + grid_pos.y**2) < ((bee_samp.world_dim / 2)**2)
- bee_samp.set_gridindeces2nan(condition[condition == 0].index)
- bee_samp.cycle_samples(samples=5)
- with tempfile.TemporaryDirectory() as folder:
- bee_samp.render(folder + '/database.db')
diff --git a/navipy/rendering/cyber_bee.py~ b/navipy/rendering/cyber_bee.py~
deleted file mode 100644
index 6d80fbf..0000000
--- a/navipy/rendering/cyber_bee.py~
+++ /dev/null
@@ -1,379 +0,0 @@
-"""
- How to test the script:
- -----------------------
- >>> blender test.blend --background --python Cyberbee.py
-
- :Author: Olivier Bertrand (olivier.bertrand@uni-bielefeld.de)
- :Parent module: Scene_rendering
-
- ..tothinkof for the doc bpy will raise an issue.
- conditional import of bpy
-"""
-import bpy
-import numpy as np
-import tempfile
-import os
-
-
-class Cyberbee():
- """
- Cyberbee is a small class binding python with blender.
- With Cyberbee one can move the bee to a position, and render what
- the bee see at this position.
-
- The Bee eye is a panoramic camera with equirectangular projection
- The light rays attaining the eyes are filtered with a gaussian.
- """
-
- def __init__(self):
- """Initialise the Cyberbee
- ..todo check that TemporaryDirectory is writtable and readable
- """
- # Rendering engine needs to be Cycles to support panoramic
- # equirectangular camera
- bpy.context.scene.render.engine = 'CYCLES'
- bpy.context.scene.render.layers["RenderLayer"].use_pass_z = True
- # Look for object camera
- camera_found = False
- for obj in bpy.context.scene.objects:
- if obj.type == 'CAMERA':
- self.camera = obj
- camera_found = True
- break
- assert camera_found, 'The blender file does not contain a camera'
- # The bee eye is panoramic, and with equirectangular projection
- self.camera.data.type = 'PANO'
- self.camera.data.cycles.panorama_type = 'EQUIRECTANGULAR'
- # Filtering props
- bpy.context.scene.cycles.filter_type = 'GAUSSIAN'
- # Call all set function with default values
- self.camera_rotation_mode = 'XYZ'
- self.camera_fov = [[-90, 90], [-180, 180]]
- self.camera_gaussian_width = 1.5
- self.camera_resolution = [360, 180]
- self.cycle_samples = 30
- # switch on nodes
- # Create render link to OutputFile with Image and Z buffer
- bpy.context.scene.use_nodes = True
- scene = bpy.context.scene
- nodes = scene.node_tree.nodes
-
- render_layers = nodes['Render Layers']
- output_file = nodes.new("CompositorNodeOutputFile")
- output_file.format.file_format = "OPEN_EXR"
- output_file.file_slots.remove(output_file.inputs[0])
- tmp_fileoutput = dict()
- tmp_fileoutput['Image'] = 'Image'
- tmp_fileoutput['Depth'] = 'Depth'
- tmp_fileoutput['Folder'] = tempfile.TemporaryDirectory().name
- tmp_fileoutput['ext'] = '.exr'
- output_file.file_slots.new(tmp_fileoutput['Image'])
- output_file.file_slots.new(tmp_fileoutput['Depth'])
- output_file.base_path = tmp_fileoutput['Folder']
- scene.node_tree.links.new(
- render_layers.outputs['Image'],
- output_file.inputs['Image']
- )
- scene.node_tree.links.new(
- render_layers.outputs['Z'],
- output_file.inputs['Depth']
- )
- self.tmp_fileoutput = tmp_fileoutput
-
- @property
- def camera_rotation_mode(self):
- """get the current camera rotation mode
-
- :returns: the mode of rotation used by the camera
- :rtype: string
-
- ..todo: Use @property
- def camera_rotation_mode(self)
- """
- return bpy.data.scenes["Scene"].camera.rotation_mode
-
- @camera_rotation_mode.setter
- def camera_rotation_mode(self, mode='XYZ'):
- """change the camera rotation mode
-
-
-
- :param mode: the mode of rotation for the camera see blender doc
-
- (default: 'XYZ').
-
- :type mode: a string
-
- .. seealso: blender bpy.data.scenes["Scene"].camera.rotation_mode
-
-
-
- ..todo: Use @property.setter
-
- def camera_rotation_mode(self, mode='XYZ')
-
- """
- if not isinstance(mode, str):
-
- raise TypeError('mode must be a string')
- bpy.data.scenes["Scene"].camera.rotation_mode = mode
-
- @property
- def cycle_samples(self):
- """get the samples for rendering with cycle
-
- :returns: the number of samples used for the rendering
- :rtype: int
-
- ..todo use @property
- def cycle_samples(self)
- """
- return bpy.context.scene.cycles.samples
-
- @cycle_samples.setter
- def cycle_samples(self, samples=30):
- """change the samples for rendering with cycle
-
-
- :param samples: the number of samples to use when rendering images
-
- :type samples: int
-
-
- ..todo: Use @property.setter
-
- def cycle_samples(self, samples=30)
- """
- if not isinstance(samples, int):
- raise TypeError('samples must be an integer')
- bpy.context.scene.cycles.samples = samples
-
- @property
- def camera_fov(self):
- """get fov of camera
-
-
-
- :returns: the field of view of the camera as min/max,longitude/latitude
-
- in degrees
-
- :rtype: dict
-
-
-
- ..todo use @property
-
- def camera_fov()
-
-
-
- ..todo Change assert to if -> raise TypeError/KeyError
-
- """
- assert self.camera.data.type == 'PANO', 'Camera is not panoramic'
- assert self.camera.cycles.panorama_type == 'EQUIRECTANGULAR',\
- 'Camera is not equirectangular'
- fov = dict()
- fov['latitude_min'] = np.rad2ged(self.camera.data.cycles.latitude_min)
- fov['latitude_max'] = np.rad2ged(self.camera.data.cycles.latitude_max)
- fov['longitude_min'] = np.rad2ged(
- self.camera.data.cycles.longitude_min)
- fov['longitude_max'] = np.rad2ged(
- self.camera.data.cycles.longitude_max)
- return fov
-
- @camera_fov.setter
- def camera_fov(self, resolution=[[-90, 90], [-180, 180]]):
- """change the field of view of the panoramic camera
-
- :param resolution: [[minimum latitude, maximum latitude],
- [minimum longitude, maximum longitude]]
- (in deg)
- :type latmin: 2x2 float array or list
-
- ..todo use @property.setter
- def camera_fov(self, latlongrange)
- here latlongrange is a a 2x2 list or array:
- [[latmin,latmax],[longmin,longmax]]
-
- ..todo Change assert to if -> raise TypeError()/KeyError()
- """
- if not (isinstance(resolution, list) or
- isinstance(resolution, np.ndarray)):
- raise TypeError('resolution must be list or array')
- if not self.camera.data.type == 'PANO':
- raise Exception('Camera is not panoramic')
- if not self.camera.data.cycles.panorama_type == 'EQUIRECTANGULAR':
- raise Exception('Camera is not equirectangular')
- self.camera.data.cycles.latitude_min = np.deg2rad(resolution[0, 0])
- self.camera.data.cycles.latitude_max = np.deg2rad(resolution[0, 1])
- self.camera.data.cycles.longitude_min = np.deg2rad(resolution[1, 0])
- self.camera.data.cycles.longitude_max = np.deg2rad(resolution[1, 1])
-
- @property
- def camera_gaussian_width(self, gauss_w=1.5):
- """get width of the gaussian spatial filter
-
- :returns: the width of the gaussian filter
- :rtype: float
-
- ..todo use @property
- def camera_gaussian_width(self)
- """
- if not (isinstance(gauss_w, int) or isinstance(gauss_w, float)):
- raise TypeError('gauss window must be integer or float')
- return bpy.context.scene.cycles.filter_width
-
- @camera_gaussian_width.setter
- def camera_gaussian_width(self, gauss_w=1.5):
- """change width of the gaussian spatial filter
-
- :param gauss_w: width of the gaussian filter
-
- :type gauss_w: float
-
- ..todo use @property.setter
- def camera_gaussian_width(self)
-
-
- ..todo check that input argument is of correct type,
- if not raise TypeError()
-
- """
- if not (isinstance(gauss_w, int) or isinstance(gauss_w, float)):
- raise TypeError('gauss window must be integer or float')
- bpy.context.scene.cycles.filter_width = gauss_w
-
- @property
- def camera_resolution(self):
- """return camera resolution (x,y)
-
- :returns: the resolution of the camera along (x-axis,y-axis)
- :rtype: (int,int)
-
- ..todo use @property
- def camera_resolution(self)
- """
- resolution_x = bpy.context.scene.render.resolution_x
- resolution_y = bpy.context.scene.render.resolution_y
- return resolution_x, resolution_y
-
- @camera_resolution.setter
- def set_camera_resolution(self, resolution=[360, 180]):
- """change the camera resolution (nb of pixels)
-
-
- :param resolution_x: number of pixels along the x-axis of the camera
- :type resolution_x: int
-
- :param resolution_y: number of pixels along the y-axis of the camera
-
- :type resolution_y: int
-
-
- ..todo use @property.setter
-
- def camera_resolution(self,resolution)
-
- here resolution is [res_x,res_y]
-
-
-
- ..todo check type and raise TypeError
-
- """
- if not (isinstance(resolution, list) or isinstance(resolution, np.ndarray)):
- raise TypeError('resolution list or array')
- bpy.context.scene.render.resolution_x = resolution[0]
- bpy.context.scene.render.resolution_y = resolution[1]
- bpy.context.scene.render.resolution_percentage = 100
-
- def update(self, posorient):
- """assign the position and the orientation of the camera.
-
- :param posorient: is a 1x6 vector containing:
- x,y,z, angle_1, angle_2, angle_3,
- here the angles are euler rotation around the axis
- specified by scene.camera.rotation_mode
- :type posorient: 1x6 double array
- """
- if len(posorient) != 6:
- raise Exception('posorient should be a 1x6 double array')
- if not (isinstance(posorient, np.ndarray) or
- isinstance(posorient, list)):
- raise TypeError('posorient must be of type array or list')
- self.camera.location = posorient[:3]
- self.camera.rotation_euler = posorient[3:]
- # Render
- bpy.ops.render.render()
-
- @property
- def image(self):
- """return the last rendered image as a numpy array
-
- :returns: the image (height,width,4)
- :rtype: a double numpy array
-
- .. note: A temporary file will be written on the harddrive,
- due to API blender limitation
-
- .. todo: use @property
- def image(self)
- """
- # save image as a temporary file, and then loaded
- # sadly the rendered image pixels can not directly be access
- filename = os.path.join(self.tmp_fileoutput['Folder'],
- self.tmp_fileoutput['Image'] + '0001' +
- self.tmp_fileoutput['ext'])
- im_width, im_height = self.camera_resolution
- im = bpy.data.images.load(filename)
- pixels = np.array(im.pixels)
- # im=PIL.Image.open(filename)
- # pixels=np.asarray(im)
- pixels = pixels.reshape([im_height, im_width, 4])
- return pixels
-
- @property
- def distance(self):
- """return the last rendered distance map as a numpy array
-
- :returns: the distance map (height, width)
- :rtype: a double numpy array
-
- .. note: A temporary file will be written on the harddrive,
- due to API blender limitation
-
- .. todo: use @property
- def distance(self)
- """
- # save image as a temporary file, and then loaded
- # sadly the rendered image pixels can not directly be access
- filename = os.path.join(self.tmp_fileoutput['Folder'],
- self.tmp_fileoutput['Depth'] + '0001' +
- self.tmp_fileoutput['ext'])
- im_width, im_height = self.camera_resolution
- im = bpy.data.images.load(filename)
- distance = np.array(im.pixels)
- # im=PIL.Image.open(filename)
- # distance=np.asarray(im)
- distance = distance.reshape([im_height, im_width, 4])
- distance = distance[:, :, 0]
- return distance
-
-
-if __name__ == "__main__":
- # Initiate the Cyberbee
- mybee = Cyberbee()
- frames_per_revolution = 5.0
- step_size = 2 * np.pi / frames_per_revolution
- posorients = np.zeros((frames_per_revolution, 6))
- posorients[:, 0] = np.sin(np.arange(frames_per_revolution) * step_size) * 5
- posorients[:, 1] = np.cos(np.arange(frames_per_revolution) * step_size) * 5
- for frame_i, posorient in enumerate(posorients):
- mybee.update(posorient)
- # Test image
- image = mybee.image
- # Test distance
- distance = mybee.distance
- print('Cyberbee OK')
--
GitLab