Skip to content
Snippets Groups Projects
Commit a6adb80a authored by Luise Odenthal's avatar Luise Odenthal
Browse files

added tests for processing

parent f3ad7cf3
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/processing/test.py 0 → 100644
+ 467
− 0
View file @ a6adb80a
import unittest
import sqlite3
import numpy as np
import pandas as pd
import os.path as path
from ..database import database
import __init__ as processing
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.
Parameters
----------
array : `numpy.ndarray`-like
The array to check.
Returns
-------
is_numeric : `bool`
True if it is a recognized numerical and False if object or
string.
"""
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 build_test_db():
db_filename = 'test_db_1'
conn = sqlite3.connect(db_filename)
c = conn.cursor()
conn.close()
db_filename = 'test_db_2'
conn = sqlite3.connect(db_filename)
c = conn.cursor()
c.execute('''CREATE TABLE normalisation
(R_max, R_min, R_range,
G_max, G_min, G_range,
B_max, B_min, B_range,
D_max, D_min, D_range)''')
c.execute('''CREATE TABLE position_orientation
(x,y,z,alpha_0,alpha_1,alpha_2)''')
c.execute('''CREATE TABLE image
(data)''')
conn.close()
class TestCase(unittest.TestCase):
def setUp(self):
one_up = path.abspath(path.join(__file__, "../"))
self.mydb_filename = one_up+'/database.db'
self.mydb = database.DataBaseLoad(self.mydb_filename)
# def test_scene_rowID(self):
# for rowid in [-1,-6,9.4,3.0,5.4,'e',np.nan,None]:
# with self.assertRaises(TypeError):
# image = self.mydb.read_image(rowid=rowid)
# self.assertIsNotNone(image)
# self.assertFalse(sum(image.shape)==0)
def test_scene_posorient(self):
# get existing position for which also an image is contained in the db
# db_filename='/media/luiza/Daten/Repos/proj-ASV3Dnavi/data/raw/ASV_data_0_db.npy'
conn = sqlite3.connect(self.mydb_filename)
c = conn.cursor()
c.execute(""" SELECT * FROM position_orientation WHERE (rowid=1) """)
rows = c.fetchall()[0]
# print(rows)
# convert to pd.series
# 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]
# conn.close()
# print("posorient",posorient)
# print(posorientall.head())
image = processing.scene(self.mydb, posorient=posorient)
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) as cm:
image = processing.scene(self.mydb, posorient=posorient2)
# print("missing column")
print(cm.exception)
# 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(Exception) as cm:
image = processing.scene(self.mydb, posorient=posorient2)
print(cm.exception)
# 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(Exception) as cm:
image = processing.scene(self.mydb, posorient=posorient2)
print(cm.exception)
# 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(Exception) as cm:
image = processing.scene(self.mydb, posorient=posorient2)
print(cm.exception)
# not working case empty
posorient2 = pd.Series(index=['x', 'y', 'z',
'alpha_0', 'alpha_1', 'alpha_2'])
with self.assertRaises(Exception) as cm:
image = processing.scene(self.mydb, posorient=posorient2)
print(cm.exception)
"""
def test_db(self):
#build_test_db()
#empty database -> should not work
db_filename='test_db_1'
#loading should not work cuz not
#all required tables are in this database
with self.assertRaises(Exception) as cm:
db=database.DataBaseLoad(db_filename)
print("a wanted error occured", cm.exception)
#reading should not anyway
with self.assertRaises(Exception) as cm:
image = db.read_image(rowid=1)
#empty database -> should work??
db_filename='test_db_2'
#loading should work
db=database.DataBaseLoad(db_filename)
#reading should not
with self.assertRaises(Exception) as cm:
image = db.read_image(rowid=1)
"""
def test_skyline_scene(self):
# image = processing.scene(self.mydb,posorient=posorient)
# print("image size skyline test",image.shape)
scene = processing.scene(self.mydb, rowid=1)
# print("scene size skypline test",scene.shape)
scene2 = scene.copy()
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))
for s in [scene2, scene3, scene4]: # put useless stuff here
with self.assertRaises(Exception) as cm:
processing.skyline(s)
print("wanted exception occured", cm.exception)
# should be working -> check if result(skyline) is correct
for s in [scene]:
skyline = processing.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):
# print("test_id")
# check for wrong cases
# my_scene = processing.scene(self.mydb, rowid=-2)
for rowid in [0, 't', -2, 4.5, np.nan, None]:
with self.assertRaises(Exception) as cm:
# print("rowid",rowid)
processing.scene(self.mydb, rowid=rowid)
the_exception = cm.exception
print("error occured", the_exception)
for rowid in [1, 2, 3, 4, 5]:
image = processing.scene(self.mydb, rowid=rowid)
# 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 = processing.scene(self.mydb, rowid=1)
# print("scene sizejhghghhg",scene.shape)
# should not be working
for d in [-1, 'g', None, np.nan, 8.4]:
with self.assertRaises(Exception) as cm:
processing.contrast_weighted_nearness(scene,
distance_channel=d)
print("wanted error occured", cm.exception)
# should work
for d in [0, 1, 2, 3]:
weighted_scene = \
processing.contrast_weighted_nearness(scene,
distance_channel=d)
# print("last channel",d)
assert is_numeric_array(weighted_scene)
assert ~np.any(np.isnan(weighted_scene))
assert len(weighted_scene.shape) == 4
assert ~(weighted_scene.shape[1] <= 0)
assert ~(weighted_scene.shape[0] <= 0)
assert (weighted_scene.shape[2] == 4)
assert ~(np.any(np.isNone(weighted_scene)))
def test_contr_weight_scene(self):
scene = processing.scene(self.mydb, rowid=1)
# working cases
contrast = processing.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))
for s in [scene2, scene3, scene4]:
with self.assertRaises(Exception) as cm:
contrast = processing.contrast_weighted_nearness(scene)
print("wanted excption occured", cm.exception)
def test_contr_weight_contrast(self):
scene = processing.scene(self.mydb, rowid=1)
for size in [8, 1, 0, -4, 9.4, 'g', None, np.nan]:
with self.assertRaises(Exception) as cm:
contrast = \
processing.contrast_weighted_nearness(scene,
contrast_size=size)
print("wanted error occured", cm.exception)
# working cases
for size in [2, 3, 4, 5]:
contrast = \
processing.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.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_pcv(self):
# working case
rowid = 1
my_scene = processing.scene(self.mydb, rowid=rowid)
# print("scene shape",my_scene.shape)
directions = self.mydb.viewing_directions
# print("directions",directions.shape)
my_pcv = processing.pcv(my_scene, directions)
# print("place code shape",my_pcv.shape)
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) as cm:
my_pcv = processing.pcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases wrong last dimension
testdirection = np.zeros((180, 360, 1))
with self.assertRaises(Exception) as cm:
my_pcv = processing.pcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases too many dimensions
testdirection = np.zeros((180, 360, 2, 4))
with self.assertRaises(Exception) as cm:
my_pcv = processing.pcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases empty
testdirection = np.zeros(())
with self.assertRaises(Exception) as cm:
my_pcv = processing.pcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases nans
testdirection = np.zeros((180, 360, 2, 4))
testdirection[2, 3, 0] = np.nan
with self.assertRaises(Exception) as cm:
my_pcv = processing.pcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
def test_apcv(self):
# working case
rowid = 1
my_scene = processing.scene(self.mydb, rowid=rowid)
# print("scene shape",my_scene.shape)
directions = self.mydb.viewing_directions
# print("directions",directions.shape)
my_pcv = processing.apcv(my_scene, directions)
print("place code shape", my_pcv.shape)
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) as cm:
my_pcv = processing.apcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases wrong last dimension
testdirection = np.zeros((180, 360, 1))
with self.assertRaises(Exception) as cm:
my_pcv = processing.apcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases too many dimensions
testdirection = np.zeros((180, 360, 2, 4))
with self.assertRaises(Exception) as cm:
my_pcv = processing.apcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases empty
testdirection = np.zeros(())
with self.assertRaises(Exception) as cm:
my_pcv = processing.apcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
# not working cases nans
testdirection = np.zeros((180, 360, 2, 4))
testdirection[2, 3, 0] = np.nan
with self.assertRaises(Exception) as cm:
my_pcv = processing.apcv(my_scene, testdirection)
print("wanted exception occured", cm.exception)
def test_size(self):
# not working cases:
scene = processing.scene(self.mydb, rowid=1)
for size in [8, 1, 0, -4, 9.4, 'g', None, np.nan]:
with self.assertRaises(Exception) as cm:
contrast = processing.michelson_contrast(scene, size=size)
print("wanted error occured", cm.exception)
# working cases
for size in [2, 3, 4, 5]:
contrast = processing.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 = processing.scene(self.mydb, rowid=1)
# working cases
contrast = processing.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 = processing.michelson_contrast(s,)
print("wanted exception occured", cm.exception)
if __name__ == '__main__':
unittest.main()
src/processing/tools.py
+ 23
− 19
View file @ a6adb80a
import processing.constants as prc 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 import numpy as np
...@@ -12,7 +16,7 @@ def is_ibpc(place_code): ...@@ -12,7 +16,7 @@ def is_ibpc(place_code):
""" """
toreturn = isinstance(place_code, np.ndarray) toreturn = isinstance(place_code, np.ndarray)
toreturn = toreturn and (len(place_code.shape) == toreturn = toreturn and (len(place_code.shape) ==
len(prc.__ibpc_indeces__)) len(__ibpc_indeces__))
return toreturn return toreturn
...@@ -26,7 +30,7 @@ def is_obpc(place_code): ...@@ -26,7 +30,7 @@ def is_obpc(place_code):
""" """
toreturn = isinstance(place_code, np.ndarray) toreturn = isinstance(place_code, np.ndarray)
toreturn = toreturn and (len(place_code.shape) == toreturn = toreturn and (len(place_code.shape) ==
len(prc.__obpc_indeces__)) len(__obpc_indeces__))
return toreturn return toreturn
...@@ -41,22 +45,22 @@ def ibs_to_obs(scene, eye_map): ...@@ -41,22 +45,22 @@ def ibs_to_obs(scene, eye_map):
assert is_ibpc(scene),\ assert is_ibpc(scene),\
'scene should be an ibs scene' 'scene should be an ibs scene'
assert isinstance(eye_map, np.ndarray), 'eye_map should be a numpy array' assert isinstance(eye_map, np.ndarray), 'eye_map should be a numpy array'
assert len(eye_map.shape) == len(prc.__eye_indeces__),\ assert len(eye_map.shape) == len(__eye_indeces__),\
'eye_map should have {} dimensions to be an ibs scene'.format( 'eye_map should have {} dimensions to be an ibs scene'.format(
len(prc.__eye_indeces__)) len(__eye_indeces__))
for index_name in ['elevation', 'azimuth']: for index_name in ['elevation', 'azimuth']:
index = prc.__ibpc_indeces__[index_name] index = __ibpc_indeces__[index_name]
assert eye_map.shape[index] == scene.shape[index],\ assert eye_map.shape[index] == scene.shape[index],\
'eye_map and scene should have the same number of {}'.format( 'eye_map and scene should have the same number of {}'.format(
index_name) index_name)
obs_size = (scene.shape[prc.__ibpc_indeces__['elevation']] * obs_size = (scene.shape[__ibpc_indeces__['elevation']] *
scene.shape[prc.__ibpc_indeces__['azimuth']], scene.shape[__ibpc_indeces__['azimuth']],
scene.shape[prc.__ibpc_indeces__['channel']], scene.shape[__ibpc_indeces__['channel']],
scene.shape[prc.__ibpc_indeces__['component']]) scene.shape[__ibpc_indeces__['component']])
obs_scene = scene.reshape(obs_size) obs_scene = scene.reshape(obs_size)
omm_size = (eye_map.shape[prc.__ibpc_indeces__['elevation']] * omm_size = (eye_map.shape[__ibpc_indeces__['elevation']] *
eye_map.shape[prc.__ibpc_indeces__['azimuth']], eye_map.shape[__ibpc_indeces__['azimuth']],
eye_map.shape[prc.__ibpc_indeces__['component']]) eye_map.shape[__ibpc_indeces__['component']])
ommatidia_map = eye_map.reshape(omm_size) ommatidia_map = eye_map.reshape(omm_size)
return (obs_scene, ommatidia_map) return (obs_scene, ommatidia_map)
...@@ -67,19 +71,19 @@ def cartesian_to_spherical(x, y, z): ...@@ -67,19 +71,19 @@ def cartesian_to_spherical(x, y, z):
azimuth = np.arctan2(y, x) azimuth = np.arctan2(y, x)
spherical = np.zeros_like(x) spherical = np.zeros_like(x)
spherical = np.tile(spherical[..., np.newaxis], (3,)) spherical = np.tile(spherical[..., np.newaxis], (3,))
spherical[..., prc.__spherical_indeces__['elevation']] = elevation spherical[..., __spherical_indeces__['elevation']] = elevation
spherical[..., prc.__spherical_indeces__['azimuth']] = azimuth spherical[..., __spherical_indeces__['azimuth']] = azimuth
spherical[..., prc.__spherical_indeces__['radius']] = radius spherical[..., __spherical_indeces__['radius']] = radius
return spherical return spherical
def spherical_to_cartesian(elevation, azimuth, radius=1): def spherical_to_cartesian(elevation, azimuth, radius=1):
cartesian = np.zeros_like(elevation) cartesian = np.zeros_like(elevation)
cartesian = np.tile(cartesian[..., np.newaxis], (3,)) cartesian = np.tile(cartesian[..., np.newaxis], (3,))
cartesian[..., prc.__cartesian_indeces__['x']] = np.cos( cartesian[..., __cartesian_indeces__['x']] = np.cos(
elevation) * np.cos(azimuth) elevation) * np.cos(azimuth)
cartesian[..., prc.__cartesian_indeces__['y']] = np.cos( cartesian[..., __cartesian_indeces__['y']] = np.cos(
elevation) * np.sin(azimuth) elevation) * np.sin(azimuth)
cartesian[..., prc.__cartesian_indeces__['z']] = np.sin(elevation) cartesian[..., __cartesian_indeces__['z']] = np.sin(elevation)
cartesian = radius * cartesian cartesian = radius * cartesian
return cartesian return cartesian
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment