def makeBox(self):
self.box = BoundingBox(points=((self.left, self.bottom), (self.right,
self.top)))
self.ct = SheetCoordinateSystem(self.box, self.density, self.density)
# float bounds for matrix coordinates: these
# values are actually outside the matrix
self.rbound = self.density * (self.top - self.bottom)
self.cbound = self.density * (self.right - self.left)
#self.cbound = int(self.density*(self.right-self.left)) / float((self.right-self.left))
#self.rbound = int(self.density*(self.top-self.bottom)) / float((self.top-self.bottom))
# CEBALERT: this is supposed to be a small distance
D = 0.00001
# Sheet values around the edge of the BoundingBox
self.just_in_right_x = self.right - D
self.just_in_bottom_y = self.bottom + D
self.just_out_top_y = self.top + D
self.just_out_left_x = self.left - D
# Matrix values around the edge of the matrix
self.just_out_right_idx = self.rbound + D
self.just_out_bottom_idx = self.cbound + D
self.just_out_top_idx = 0.0 - D
self.just_out_left_idx = 0.0 - D
def test_composite_pattern_basic(self):
"""
Test that a composite pattern consisting of just one Gaussian
is the same as that actual Gaussian pattern, and that a
composite pattern of two rectangles is the same as adding the
two individual matrices.
"""
bbox = BoundingBox(radius=0.5)
g = Gaussian(size=0.2, aspect_ratio=0.5, orientation=0, x=0.2, y=-0.03)
c = Composite(generators=[g], bounds=bbox, xdensity=7, ydensity=7)
assert_array_equal(g(bounds=bbox, xdensity=7, ydensity=7), c())
r1 = Rectangle(size=0.2,
aspect_ratio=1,
x=0.3,
y=0.3,
orientation=0,
smoothing=0.0)
r2 = Rectangle(size=0.2,
aspect_ratio=1,
x=-0.3,
y=-0.3,
orientation=0,
bounds=BoundingBox(radius=0.8),
xdensity=2,
smoothing=0.0)
c_true = r1(bounds=bbox, xdensity=7, ydensity=7) + r2(
bounds=bbox, xdensity=7, ydensity=7)
c = Composite(generators=[r1, r2], bounds=bbox, xdensity=7, ydensity=7)
assert_array_equal(c(), c_true)
def setUp(self):
self.sim = Simulation()
self.sim['Dest'] = CFSheet(nominal_density=10,nominal_bounds=BoundingBox(radius=0.5))
self.sim['Src'] = CFSheet(nominal_density=10,nominal_bounds=BoundingBox(radius=0.5))
self.sim.connect('Src','Dest',
connection_type = ResizableCFProjection,
)
def test_coordinate_position(self):
"""
these tests duplicate some of the earlier ones,
except these use a matrix with non-integer
(right-left) and (top-bottom). This is an important
test case for the definition of density; without it,
the tests above could be passed by a variety of
sheet2matrix, bounds2shape functions, etc.
CEBALERT: transfer the box to TestBox3Coordinates and have
these tests run in the framework.
"""
l, b, r, t = (-0.8, -0.8, 0.8, 0.8)
# mimics that a sheet recalculates its density)
density = int(16 * (r - l)) / float(r - l)
bounds = BoundingBox(points=((l, b), (r, t)))
ct = SheetCoordinateSystem(bounds, density, density)
self.assertEqual(ct.sheet2matrixidx(0.8, 0.8), (0, 24 + 1))
self.assertEqual(ct.sheet2matrixidx(0.0, 0.0), (12, 12))
self.assertEqual(ct.sheet2matrixidx(-0.8, -0.8), (24 + 1, 0))
self.assertEqual(
ct.matrixidx2sheet(24, 0),
(((r - l) / int(density * (r - l)) / 2.0) + l, (t - b) / int(density * (t - b)) / 2.0 + b),
)
self.assertEqual(
ct.matrixidx2sheet(0, 0),
(
((r - l) / int(density * (r - l)) / 2.0) + l,
(t - b) / int(density * (t - b)) * (int(density * (t - b)) - 0.5) + b,
),
)
x, y = ct.matrixidx2sheet(0, 0)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((0, 0), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(25, 25)
self.assertFalse(bounds.contains(x, y))
self.assertNotEqual((24, 24), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(0, 24)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((0, 24), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(24, 0)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((24, 0), ct.sheet2matrixidx(x, y))
def __init__(self,cf,input_sheet,x=0.0,y=0.0,template=BoundingBox(radius=0.1),
mask=patterngenerator.Constant(),
min_matrix_radius=1):
"""
From an existing copy of ConnectionField (CF) that acts as a
template, create a new CF that shares weights with the
template CF. Copies all the properties of CF to stay
identical except the weights variable that actually contains
the data.
The only difference from a normal CF is that the weights of
the CF are implemented as a numpy view into the single master
copy of the weights stored in the CF template.
"""
# CEBALERT: There's no call to super's __init__; see JAHACKALERT
# below.
template = copy(template)
if not isinstance(template,Slice):
template = Slice(template,input_sheet,force_odd=True,
min_matrix_radius=min_matrix_radius)
# Note: if passed in, mask is shared between CFs (but not if created here)
if not hasattr(mask,'view'):
mask = _create_mask(patterngenerator.Constant(),
template.compute_bounds(input_sheet),
input_sheet,True,0.5)
self._has_norm_total=False
self.mask=mask
weights_slice = self._create_input_sheet_slice(input_sheet,x,y,template,min_matrix_radius=min_matrix_radius)
self.weights = weights_slice.submatrix(cf.weights)
def test_vertical_oddimage_evensheet__horizontal_evenimage_evensheet(self):
"""
Test vertical positioning for even sheet, odd image and horizontal
positioning for even image, even sheet.
"""
image_array = np.array(
[[ 96.59090909, 96.59090909, 96.59090909, 96.59090909, 96.59090909,
96.59090909, 96.59090909, 96.59090909,],
[ 0. , 34. , 68. , 102. , 136. ,
255. , 0. , 0. ,],
[ 0. , 34. , 68. , 102. , 136. ,
255. , 255. , 0. ,],
[ 0. , 34. , 68. , 102. , 136. ,
255. , 255. , 255. ,],
[ 255. , 0. , 255. , 0. , 255. ,
0. , 255. , 0. ,],
[ 0. , 255. , 0. , 255. , 0. ,
255. , 0. , 255. ,],
[ 96.59090909, 96.59090909, 96.59090909, 96.59090909, 96.59090909,
96.59090909, 96.59090909, 96.59090909,],
[ 96.59090909, 96.59090909, 96.59090909, 96.59090909, 96.59090909,
96.59090909, 96.59090909, 96.59090909,]],dtype=np.float)
image = FileImage(filename = resolve_path('topo/tests/unit/testimage.pgm'),
xdensity=8,
ydensity=8,
bounds=BoundingBox(radius=0.5),
output_fns=[])
ps = image.pattern_sampler
ps.size_normalization='original'
ps.whole_pattern_output_fns=[]
assert_array_almost_equal(image_array,image())
def __call__(self,x):
rows,cols = x.shape
radius = self.density*self.kernel_radius
crop_radius = int(max(1.25,radius*self.crop_radius_multiplier))
# find out the matrix coordinates of the winner
wr,wc = array_argmax(x)
# convert to sheet coordinates
wy = rows-wr-1
# Optimization: Calculate the bounding box around the winner
# in which weights will be changed
cmin = max(wc-crop_radius, 0)
cmax = min(wc+crop_radius+1,cols)
rmin = max(wr-crop_radius, 0)
rmax = min(wr+crop_radius+1,rows)
ymin = max(wy-crop_radius, 0)
ymax = min(wy+crop_radius+1,rows)
bb = BoundingBox(points=((cmin,ymin), (cmax,ymax)))
# generate the kernel matrix and insert it into the correct
# part of the output array
kernel = self.neighborhood_kernel_generator(bounds=bb,xdensity=1,ydensity=1,
size=2*radius,x=wc+0.5,y=wy+0.5)
x *= 0.0
x[rmin:rmax,cmin:cmax] = kernel
def makeBox(self):
self.box = BoundingBox(points=((self.left,self.bottom),
(self.right,self.top)))
self.ct = SheetCoordinateSystem(self.box,self.density,self.density)
# float bounds for matrix coordinates: these
# values are actually outside the matrix
self.rbound = self.density*(self.top-self.bottom)
self.cbound = self.density*(self.right-self.left)
#self.cbound = int(self.density*(self.right-self.left)) / float((self.right-self.left))
#self.rbound = int(self.density*(self.top-self.bottom)) / float((self.top-self.bottom))
# CEBALERT: this is supposed to be a small distance
D = 0.00001
# Sheet values around the edge of the BoundingBox
self.just_in_right_x = self.right - D
self.just_in_bottom_y = self.bottom + D
self.just_out_top_y = self.top + D
self.just_out_left_x = self.left - D
# Matrix values around the edge of the matrix
self.just_out_right_idx = self.rbound + D
self.just_out_bottom_idx = self.cbound + D
self.just_out_top_idx = 0.0 - D
self.just_out_left_idx = 0.0 - D
def test_bounds2slice(self):
# test that if you ask to slice the matrix with the sheet's BoundingBox, you
# get back the whole matrix
sheet_bb = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
ct = SheetCoordinateSystem(sheet_bb, 10)
slice_ = Slice(sheet_bb, ct)
true_slice = (0, 10, 0, 10
) # inclusive left boundary, exclusive right boundary
self.assertEqual(tuple(slice_.tolist()), true_slice)
# for the following tests, the values have been all computed by hand and then
# tested (by JC). The boundingbox and density tested have been chosen randomly,
# then drawn to get the slice from it.
# Test with 20 density.
ct = SheetCoordinateSystem(sheet_bb, 20, 20)
bb = BoundingBox(points=((-0.05, -0.20), (0.20, 0.05)))
slice_ = Slice(bb, ct)
true_slice = (9, 14, 9, 14)
self.assertEqual(tuple(slice_.tolist()), true_slice)
bb = BoundingBox(points=((-0.40, 0), (-0.30, 0.30)))
slice_ = Slice(bb, ct)
true_slice = (4, 10, 2, 4)
self.assertEqual(tuple(slice_.tolist()), true_slice)
bb = BoundingBox(points=((0.15, 0.10), (0.30, 0.30)))
slice_ = Slice(bb, ct)
true_slice = (4, 8, 13, 16)
self.assertEqual(tuple(slice_.tolist()), true_slice)
bb = BoundingBox(points=((-0.05, -0.45), (0.10, -0.25)))
slice_ = Slice(bb, ct)
true_slice = (15, 19, 9, 12)
self.assertEqual(tuple(slice_.tolist()), true_slice)
# test with 7 density sheet.
bb = BoundingBox(points=((-0.5 + 2.0 / 7.0, 0.5 - 2.0 / 7.0),
(-0.5 + 4.0 / 7.0, 0.5)))
ct = SheetCoordinateSystem(sheet_bb, 7)
slice_ = Slice(bb, ct)
true_slice = (0, 2, 2, 4)
self.assertEqual(tuple(slice_.tolist()), true_slice)
#(4x4 matrix)
ct = SheetCoordinateSystem(BoundingBox(radius=0.2),
xdensity=10,
ydensity=10)
test_bounds = BoundingBox(radius=0.1)
slice_ = Slice(test_bounds, ct)
r1, r2, c1, c2 = slice_
self.assertEqual((r1, r2, c1, c2), (1, 3, 1, 3))
def test_connection_field_like(self):
# test a ConnectionField-like example
sheet = Sheet(nominal_density=10,nominal_bounds=BoundingBox(radius=0.5))
cf_bounds = BoundingBox(points=((0.3,0.3),(0.6,0.6)))
slice_ = Slice(cf_bounds,sheet)
slice_.crop_to_sheet(sheet)
# check it's been cropped to fit onto sheet...
self.assertEqual(slice_.tolist(),[0,2,8,10])
# now check that it gives the correct bounds...
cropped_bounds = slice_.compute_bounds(sheet)
true_cropped_bounds = BoundingBox(points=((0.3,0.3),(0.5,0.5)))
for a,b in zip(cropped_bounds.lbrt(),true_cropped_bounds.lbrt()):
self.assertAlmostEqual(a,b)
def test_connection_field_like(self):
# test a ConnectionField-like example
sheet = Sheet(nominal_density=10,nominal_bounds=BoundingBox(radius=0.5))
cf_bounds = BoundingBox(points=((0.3,0.3),(0.6,0.6)))
slice_ = Slice(cf_bounds,sheet)
slice_.crop_to_sheet(sheet)
# check it's been cropped to fit onto sheet...
self.assertEqual(slice_.tolist(),[0,2,8,10])
# now check that it gives the correct bounds...
cropped_bounds = slice_.compute_bounds(sheet)
true_cropped_bounds = BoundingBox(points=((0.3,0.3),(0.5,0.5)))
for a,b in zip(cropped_bounds.lbrt(),true_cropped_bounds.lbrt()):
self.assertAlmostEqual(a,b)
def test_constant(self):
"""
Constant overrides PatternGenerator's usual matrix creation.
"""
pattern_bounds = BoundingBox(points=((0.3, 0.2), (0.5, 0.5)))
pattern_target = array([[1, 1], [1, 1], [1, 1]])
c = Constant(bounds=pattern_bounds, xdensity=10.0, ydensity=10)
assert_array_equal(c(), pattern_target)
def __call__(self,x):
###JABHACKALERT: Need to set it up to be independent of
#density; right now only things like random numbers work
#reasonably
rows,cols = x.shape
bb = BoundingBox(points=((0,0), (rows,cols)))
generated_pattern = self.generator(bounds=bb,xdensity=1,ydensity=1).transpose()
new_pattern = self.operator(x, generated_pattern)
x *= 0.0
x += new_pattern
def test_a_basic_patterngenerator(self):
pattern_bounds = BoundingBox(points=((0.3,0.2),(0.5,0.5)))
pattern_target = array([[1,1],
[1,1],
[1,1]])
r = Rectangle(bounds=pattern_bounds,xdensity=10,
ydensity=10,aspect_ratio=1,size=1,smoothing=0.0)
assert_array_equal(r(),pattern_target)
def test_composite_pattern_moves(self):
"""
Test that moving a composite pattern yields the correct pattern.
"""
bbox=BoundingBox(radius=0.5)
g = Gaussian(size=0.2,aspect_ratio=0.5,orientation=pi/3,x=0,y=0)
c = Composite(generators=[g],x=-0.3,y=0.4,xdensity=4,ydensity=4,bounds=bbox)
g_moved = g(x=-0.3,y=0.4,xdensity=4,ydensity=4,bounds=bbox)
assert_array_equal(c(),g_moved)
def _compute_depth_map(self, shape):
(d1, d2) = shape
(min_lim, max_lim) = self.limits
self.raw_depth_map = self.distribution(name='ScatterDepth',
xdensity=d1,
ydensity=d2,
bounds=BoundingBox(radius=0.5))
bin_edges = list(np.linspace(min_lim, max_lim, self.depth))
discretized = np.digitize(self.raw_depth_map.flatten(), bin_edges)
# Out of bounds bins (to +inf) need to be pulled back in.
discretized[discretized == len(bin_edges)] = len(bin_edges) - 1
return discretized.reshape(*shape)
def test_fit_shortest(self):
"""
Test that the shorter dimension is made to fit 1.0, while the other
is scaled by the same factor.
"""
### 15 units represent 1.0 in sheet coordinates.
image_array = np.array(
[[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
0., 0.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
0., 0.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
0., 0.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 34., 68., 68., 68., 102., 102., 102., 136., 136., 136., 255., 255., 255.,
255., 255.,],
[ 0., 255., 255., 255., 0., 0., 0., 255., 255., 255., 0., 0., 0.,
255., 255.,],
[ 0., 255., 255., 255., 0., 0., 0., 255., 255., 255., 0., 0., 0.,
255., 255.,],
[ 0., 255., 255., 255., 0., 0., 0., 255., 255., 255., 0., 0., 0.,
255., 255.,],
[ 255., 0., 0., 0., 255., 255., 255., 0., 0., 0., 255., 255., 255.,
0., 0.,],
[ 255., 0., 0., 0., 255., 255., 255., 0., 0., 0., 255., 255., 255.,
0., 0.,],
[ 255., 0., 0., 0., 255., 255., 255., 0., 0., 0., 255., 255., 255.,
0., 0.,]])
image = FileImage(filename = resolve_path('topo/tests/unit/testimage.pgm'),
xdensity=15,
ydensity=15,
output_fns=[],
bounds=BoundingBox(radius=0.5))
ps = image.pattern_sampler
ps.size_normalization='fit_shortest'
ps.whole_pattern_output_fns=[]
assert_array_almost_equal(image_array,image())
def test_orientation_and_rotation(self):
"""
Test that a pattern is drawn with the correct orientation,
and is rotated correctly.
"""
### Test initial orientation and 90-degree rotation
target = array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0]])
bounds = BoundingBox(radius=0.3)
xdensity = 10
ydensity = 10
width = 2.0/xdensity
height = 4.0/ydensity
rect = Rectangle(size=height,
aspect_ratio=width/height,smoothing=0.0,
xdensity=xdensity,ydensity=ydensity,bounds=bounds)
assert_array_equal(rect(),target)
assert_array_equal(rect(orientation=pi/2),rot90(target))
### 45-degree rotation about the origin
rot_45 = array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0]])
assert_array_equal(rect(orientation=pi/4),rot_45)
### 45-degree rotation that's not about the origin
rot_45_offset = array([[0, 1, 0, 0, 0, 0],
[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]])
assert_array_equal(rect(x=-1.0/xdensity,y=1.0/ydensity,orientation=pi/4),
rot_45_offset)
def new_simulation(name=None, register=True):
from topo.base.simulation import Simulation
from topo.base.cf import CFSheet, CFProjection
from topo.sheet import GeneratorSheet
from topo.base.boundingregion import BoundingBox
sim = Simulation(register=register, name=name)
b = BoundingBox(radius=0.5)
sim['GS'] = GeneratorSheet(nominal_density=2, nominal_bounds=b)
sim['GS2'] = GeneratorSheet(nominal_density=2, nominal_bounds=b)
sim['S'] = CFSheet(nominal_density=2, nominal_bounds=b)
sim['S2'] = CFSheet(nominal_density=2, nominal_bounds=b)
sim.connect('GS', 'S', connection_type=CFProjection, delay=0.05)
sim.connect('GS', 'S2', connection_type=CFProjection, delay=0.05)
sim.connect('GS2', 'S2', connection_type=CFProjection, delay=0.05)
return sim
def test_Sheet_creation(self):
# Example where the nominal x and y densities would not be equal.
# density along x =10
# density along y <10
# The density along y should become 10, by adjusting the height to be 2.0
# in this case.
# The y center of the bounds should remain -0.0025. Hence we should get
# a bottom bound of -1.0025 and a top one of 0.9975.
sheet = Sheet(nominal_density=10,
nominal_bounds=BoundingBox(points=((-0.5,-1.005),(0.5,1.0))))
self.assertEqual(sheet.xdensity,10)
self.assertEqual(sheet.xdensity,sheet.ydensity)
l,b,r,t = sheet.lbrt
self.assertEqual(l,-0.5)
self.assertEqual(r,0.5)
self.assertAlmostEqual(t,0.9975)
self.assertAlmostEqual(b,-1.0025)
def setUp(self):
# sheet to test. As it is, its activity matrix dimension is (3,2)
Sheet.nominal_density = 1
Sheet.nominal_bounds = BoundingBox(points=((-1, -2), (1, 1)))
test_sheet = Sheet()
# simple activity arrays use to update the feature maps
self.a1 = array([[1, 1], [1, 1], [1, 1]])
self.a2 = array([[3, 3], [3, 3], [3, 3]])
self.a3 = array([[0, 1], [0, 1], [0, 1]])
# object to test for non-cyclic distributions
self.fm1 = DistributionMatrix(test_sheet.shape,
axis_range=(0.0, 1.0),
cyclic=False)
self.fm1.update(self.a1, 0.5)
# object to for cyclic distributions
self.fm2 = DistributionMatrix(test_sheet.shape,
axis_range=(0.0, 1.0),
cyclic=True)
self.fm2.update(self.a1, 0.5)
def test_coordinate_position(self):
"""
these tests duplicate some of the earlier ones,
except these use a matrix with non-integer
(right-left) and (top-bottom). This is an important
test case for the definition of density; without it,
the tests above could be passed by a variety of
sheet2matrix, bounds2shape functions, etc.
CEBALERT: transfer the box to TestBox3Coordinates and have
these tests run in the framework.
"""
l, b, r, t = (-0.8, -0.8, 0.8, 0.8)
# mimics that a sheet recalculates its density)
density = int(16 * (r - l)) / float(r - l)
bounds = BoundingBox(points=((l, b), (r, t)))
ct = SheetCoordinateSystem(bounds, density, density)
self.assertEqual(ct.sheet2matrixidx(0.8, 0.8), (0, 24 + 1))
self.assertEqual(ct.sheet2matrixidx(0.0, 0.0), (12, 12))
self.assertEqual(ct.sheet2matrixidx(-0.8, -0.8), (24 + 1, 0))
self.assertEqual(ct.matrixidx2sheet(24, 0),
(((r - l) / int(density * (r - l)) / 2.0) + l,
(t - b) / int(density * (t - b)) / 2.0 + b))
self.assertEqual(ct.matrixidx2sheet(0, 0),
(((r - l) / int(density * (r - l)) / 2.0) + l,
(t - b) / int(density * (t - b)) *
(int(density * (t - b)) - 0.5) + b))
x, y = ct.matrixidx2sheet(0, 0)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((0, 0), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(25, 25)
self.assertFalse(bounds.contains(x, y))
self.assertNotEqual((24, 24), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(0, 24)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((0, 24), ct.sheet2matrixidx(x, y))
x, y = ct.matrixidx2sheet(24, 0)
self.assertTrue(bounds.contains(x, y))
self.assertEqual((24, 0), ct.sheet2matrixidx(x, y))
def test_stretch_to_fit(self):
"""
Test that both image dimensions are made to fit 1.0.
"""
### 8 units represent 1.0 in sheet coordinates.
image_array = array([[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
34.,
68.,
102.,
136.,
255.,
0.,
0.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
34.,
68.,
102.,
136.,
255.,
0.,
0.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
34.,
68.,
102.,
136.,
255.,
255.,
0.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
34.,
68.,
102.,
136.,
255.,
255.,
255.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
34.,
68.,
102.,
136.,
255.,
255.,
255.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
255.,
0.,
255.,
0.,
255.,
0.,
255.,
0.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
255.,
0.,
255.,
0.,
255.,
0.,
255.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
0.,
255.,
0.,
255.,
0.,
255.,
0.,
255.,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
]])
image = FileImage(filename=resolve_path('tests/testimage.pgm'),
xdensity=8,
ydensity=8,
output_fns=[],
bounds=BoundingBox(radius=1.0))
ps = image.pattern_sampler
ps.size_normalization = 'stretch_to_fit'
ps.whole_pattern_output_fns = []
assert_array_almost_equal(image_array, image())
class ShiftingGeneratorSheet(SequenceGeneratorSheet):
"""
A GeneratorSheet that takes an extra input on port 'Saccade'
that specifies a saccade command as a tuple (amplitude,direction),
indicating the relative size and direction of the saccade in
degrees. The parameter visual_angle_scale defines the
relationship between degrees and sheet coordinates. The parameter
saccade bounds limits the region within which the saccades may occur.
"""
visual_angle_scale = param.Number(default=90,
doc="""
The scale factor determining the visual angle subtended by this sheet, in
degrees per unit of sheet.""")
saccade_bounds = BoundingRegionParameter(default=BoundingBox(radius=1.0),
doc="""
The bounds for saccades. Saccades are constrained such that the centroid of the
sheet bounds remains within this region.""")
generate_on_shift = param.Boolean(default=True,
doc="""
Whether to generate a new pattern when a shift occurs.""")
fixation_jitter = param.Number(default=0,
doc="""
Standard deviation of Gaussian fixation jitter.""")
fixation_jitter_period = param.Number(default=10,
doc="""
Period, in time units, indicating how often the eye jitters.
""")
dest_ports = ["Trigger", "Saccade"]
src_ports = ['Activity', 'Position']
def __init__(self, **params):
super(ShiftingGeneratorSheet, self).__init__(**params)
self.fixation_point = self.bounds.centroid()
def start(self):
super(ShiftingGeneratorSheet, self).start()
if self.fixation_jitter_period > 0:
now = self.simulation.time()
refix_event = PeriodicEventSequence(
now + self.simulation.convert_to_time_type(
self.fixation_jitter_period),
self.simulation.convert_to_time_type(
self.fixation_jitter_period),
[FunctionEvent(0, self.refixate)])
self.simulation.enqueue_event(refix_event)
def input_event(self, conn, data):
if conn.dest_port == 'Saccade':
# the data should be (amplitude,direction)
amplitude, direction = data
self.shift(amplitude, direction)
def generate(self):
super(ShiftingGeneratorSheet, self).generate()
self.send_output(src_port='Position',
data=self.bounds.aarect().centroid())
def shift(self, amplitude, direction, generate=None):
"""
Shift the bounding box by the given amplitude and
direction.
Amplitude and direction are specified in degrees, and will be
converted using the sheet's visual_angle_scale
parameter. Negative directions are always downward, regardless
of whether the amplitude is positive (rightword) or negative
(leftward). I.e. straight-down = -90, straight up = +90.
The generate argument indicates whether or not to generate
output after shifting. If generate is None, then the value of
the sheet's generate_on_shift parameter will be used.
"""
# JPALERT: Right now this method assumes that we're doing
# colliculus-style saccades. i.e. amplitude and direction
# relative to the current position. Technically it would
# not be hard to also support absolute or relative x,y
# commands, and select what style to use with either with
# a parameter, or with a different input port (e.g. 'xy
# relative', 'xy absolute' etc.
# JPHACKALERT: Currently there is no support for modeling the
# fact that saccades actually take time, and larger amplitudes
# take more time than small amplitudes. No clue if we should
# do that, or how, or what gets sent out while the saccade
# "eye" is moving.
assert not self._out_of_bounds()
# convert the command to x/y translation
radius = amplitude / self.visual_angle_scale
# if the amplitude is negative, negate the direction (so up is still up)
if radius < 0.0:
direction *= -1
self._translate(radius, direction)
if self._out_of_bounds():
self._find_saccade_in_bounds(radius, direction)
self.fixation_point = self.bounds.centroid()
if generate is None:
generate = self.generate_on_shift
if generate:
self.generate()
def refixate(self):
"""
Move the bounds toward the fixation point.
Moves the bounds toward the fixation point specified in
self.fixation_point, potentially with noise as specified by
the parameter self.fixation_jitter.
"""
self.debug("Refixating.")
if self.fixation_jitter > 0:
jitter_vec = random.normal(0, self.fixation_jitter, (2, ))
else:
jitter_vec = zeros((2, ))
fix = asarray(self.fixation_point)
pos = asarray(self.bounds.centroid())
refix_vec = (fix - pos) + jitter_vec
self.bounds.translate(*refix_vec)
def _translate(self, radius, angle):
angle *= pi / 180
xoff = radius * cos(angle)
yoff = radius * sin(angle)
self.verbose("Applying translation vector (%.2f,%.2f)" % (xoff, yoff))
self.bounds.translate(xoff, yoff)
def _out_of_bounds(self):
"""
Return true if the centroid of the current bounds is outside the saccade bounds.
"""
return not self.saccade_bounds.contains(
*self.bounds.aarect().centroid())
def _find_saccade_in_bounds(self, radius, theta):
"""
Find a saccade in the given direction (theta) that lies within self.saccade_bounds.
Assumes that the given saccade was already performed and
landed out of bounds.
"""
# JPHACKALERT: This method iterates to search for a saccade
# that lies in bounds along the saccade vector. We should
# really compute this algebraically. Doing so involves computing
# the intersection of the saccade vector with the saccade
# bounds. Ideally, each type of BoundingRegion would know how
# to compute its own intersection with a given line (should be
# easy for boxes, circles, and ellipses, at least.)
# Assume we're starting out of bounds, so start by shifting
# back to the original position
self._translate(-radius, theta)
while not self._out_of_bounds():
radius *= 0.5
self._translate(radius, theta)
radius = -radius
while self._out_of_bounds():
radius *= 0.5
self._translate(radius, theta)
def test_position(self):
"""
Test that a pattern is drawn correctly at different
locations.
"""
initial = array([[0,0,0,0],
[0,1,1,0],
[0,1,1,0],
[0,0,0,0]])
r = Rectangle(bounds=BoundingBox(radius=2),xdensity=1,
ydensity=1,aspect_ratio=1,size=2,smoothing=0.0)
assert_array_equal(r(),initial)
### x offset
x_offset = array([[0,0,0,0],
[0,0,1,1],
[0,0,1,1],
[0,0,0,0]])
assert_array_equal(r(x=1),x_offset)
### y offset
y_offset = rot90(x_offset)
assert_array_equal(r(y=1),y_offset)
### x and y offset
target = array([[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[1,1,0,0,0,0,0,0,0,0],
[1,1,0,0,0,0,0,0,0,0],
[1,1,0,0,0,0,0,0,0,0],
[1,1,0,0,0,0,0,0,0,0]])
width = 0.2
height = 0.4
r = Rectangle(bounds=BoundingBox(radius=0.5),
xdensity=10,ydensity=10,smoothing=0.0,
aspect_ratio=width/height,size=height)
assert_array_equal(r(x=-0.4,y=-0.3),target)
### x and y offset with bounds offset by the same
target = array([[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,1,1,0,0,0,0],
[0,0,0,0,1,1,0,0,0,0],
[0,0,0,0,1,1,0,0,0,0],
[0,0,0,0,1,1,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0]])
width = 0.2
height = 0.4
bounds = BoundingBox(points=((-0.9,-0.8),(0.1,0.2)))
r = Rectangle(bounds=bounds,xdensity=10,ydensity=10,smoothing=0.0,
aspect_ratio=width/height,size=height)
assert_array_equal(r(x=-0.4,y=-0.3),target)
def setUp(self):
### Simple case: we only pass a dictionary to Plot()
### that does not belong to a Sheet:
views = {}
time = 0
metadata = AttrDict(timestamp=time)
### SheetView1:
### Find a way to assign randomly the matrix.
self.matrix1 = zeros((10, 10), Float) + RandomArray.random((10, 10))
self.bounds1 = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
sv = SheetView(self.matrix1, self.bounds1, metadata=metadata)
self.sheet_view1 = NdMapping((None, sv),
src_name='TestInputParam',
precedence=0.1,
row_precedence=0.1,
cyclic_range=None,
timestamp=time)
self.key1 = 'sv1'
views[self.key1] = self.sheet_view1
### SheetView2:
### Find a way to assign randomly the matrix.
self.matrix2 = zeros((10, 10), Float) + 0.3
self.bounds2 = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
sv = SheetView(self.matrix2, self.bounds2, metadata=metadata)
self.sheet_view2 = NdMapping((None, sv),
src_name='TestInputParam',
precedence=0.2,
row_precedence=0.2,
cyclic_range=None,
timestamp=time)
self.key2 = ('sv2', 0, 10)
views[self.key2] = self.sheet_view2
### SheetView3:
### Find a way to assign randomly the matrix.
self.matrix3 = zeros((10, 10), Float) + RandomArray.random((10, 10))
self.bounds3 = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
sv = SheetView(self.matrix3, self.bounds3, metadata=metadata)
self.sheet_view3 = NdMapping((None, sv),
src_name='TestInputParam',
precedence=0.3,
row_precedence=0.3,
cyclic_range=None,
timestamp=time)
self.key3 = ('sv3', 0, 'hello', (10, 0))
views[self.key3] = self.sheet_view3
### SheetView4: for testing clipping + different bounding box
### Find a way to assign randomly the matrix.
self.matrix4 = zeros((10, 10), Float) + 1.6
self.bounds4 = BoundingBox(points=((-0.7, -0.7), (0.7, 0.7)))
sv = SheetView(self.matrix4, self.bounds4, metadata=metadata)
self.sheet_view4 = NdMapping((None, sv),
src_name='TestInputParam',
precedence=0.4,
row_precedence=0.4,
cyclic_range=None,
timestamp=time)
self.key4 = 'sv4'
views[self.key4] = self.sheet_view4
self.view_dict = {'Strength': views, 'Hue': views, 'Confidence': views}
### JCALERT! for the moment we can only pass a triple when creating plot
### adding more sheetView to test when plot will be fixed for accepting
### as much as you want.
# plot0: empty plot + no sheetviewdict passed: error or empty plot?
### JCALERT! It has to be fixed what to do in this case in plot..
### disabled test for the moment.
#self.plot0 = Plot((None,None,None),None,name='plot0')
### CATCH EXCEPTION
plot_channels1 = {'Strength': None, 'Hue': None, 'Confidence': None}
# plot1: empty plot
self.plot1 = make_template_plot(plot_channels1,
self.view_dict,
density=10.0,
name='plot1')
plot_channels2 = {
'Strength': self.key1,
'Hue': None,
'Confidence': None
}
# plot2: sheetView 1, no normalize, no clipping
self.plot2 = make_template_plot(plot_channels2,
self.view_dict,
density=10.0,
name='plot2')
plot_channels3 = {
'Strength': self.key1,
'Hue': self.key2,
'Confidence': None
}
# plot3: sheetView 1+2, no normalize, no clipping
self.plot3 = make_template_plot(plot_channels3,
self.view_dict,
density=10.0,
name='plot3')
plot_channels4 = {
'Strength': self.key1,
'Hue': self.key2,
'Confidence': self.key3
}
# plot4: sheetView 1+2+3, no normalize , no clipping
self.plot4 = make_template_plot(plot_channels4,
self.view_dict,
density=10.0,
name='plot4')
plot_channels5 = {
'Strength': self.key1,
'Hue': None,
'Confidence': self.key3
}
# plot5: sheetView 1+3, no normalize, no clipping
self.plot5 = make_template_plot(plot_channels5,
self.view_dict,
density=10.0,
name='plot5')
plot_channels6 = {
'Strength': None,
'Hue': self.key2,
'Confidence': self.key3
}
# plot6: sheetView 2+3, no normalize , no clipping
self.plot6 = make_template_plot(plot_channels6,
self.view_dict,
density=10.0,
name='plot6')
plot_channels7 = {
'Strength': self.key4,
'Hue': self.key2,
'Confidence': self.key3
}
# plot7: sheetView 1+2+3, no normalize , clipping
self.plot7 = make_template_plot(plot_channels7,
self.view_dict,
density=10.0,
name='plot7')
plot_channels8 = {
'Strength': self.key1,
'Hue': self.key2,
'Confidence': self.key3
}
# plot8: sheetView 1+2+3, normalize , no clipping
self.plot8 = make_template_plot(plot_channels8,
self.view_dict,
density=10.0,
normalize=True,
name='plot8')
### JCALERT! FOR THE MOMENT I TAKE THE DEFAULT FOR NORMALIZE.
### WE WILL SEE IF IT REMAINS IN PLOT FIRST.
### also makes a sheet to test realease_sheetviews
self.sheet = Sheet()
self.sheet.views.maps[self.key1] = self.sheet_view1
self.sheet.views.maps[self.key2] = self.sheet_view2
self.sheet.views.maps[self.key3] = self.sheet_view3
self.sheet.views.maps[self.key4] = self.sheet_view4
plot_channels9 = {
'Strength': self.key1,
'Hue': self.key2,
'Confidence': self.key3
}
self.plot9 = make_template_plot(plot_channels9,
self.sheet.views.maps,
density=10.0,
name='plot9')
def test_slice2bounds(self):
# test that if you ask to slice the matrix with the sheet's BoundingBox, you
# get back the whole matrix
# (I chose to use a 7 density, I don't know why I like 7 so much, it is kind of mystical)
sheet_bb = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
ct = SheetCoordinateSystem(sheet_bb, 7)
slice_ = (0, 7, 0, 7)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.5, -0.5, 0.5, 0.5)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
# for the following tests, the values have been all computed
# by hand and then tested (by JC). The boundingbox and density
# tested have been chosen randomly, then drawn to get the slice
# from it.
# Test for 10 density
ct = SheetCoordinateSystem(sheet_bb, 10)
slice_ = (0, 9, 1, 5)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.4, -0.4, 0, 0.5)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
slice_ = (2, 3, 7, 10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (0.2, 0.2, 0.5, 0.3)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
# Test for 7 density
ct = SheetCoordinateSystem(sheet_bb, 7)
slice_ = (3, 7, 2, 5)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.5 + 2.0 / 7.0, -0.5, -0.5 + 5.0 / 7.0,
0.5 - 3.0 / 7.0)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
slice_ = (2, 6, 0, 1)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.5, 0.5 - 6.0 / 7.0, -0.5 + 1.0 / 7.0,
0.5 - 2.0 / 7.0)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
# Test for 25 density
ct = SheetCoordinateSystem(sheet_bb, 25)
slice_ = (0, 25, 4, 10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.5 + 4.0 / 25.0, -0.5, -0.5 + 10.0 / 25.0, 0.5)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
slice_ = (7, 18, 3, 11)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
true_bounds_lbrt = (-0.5 + 3.0 / 25.0, 0.5 - 18.0 / 25.0,
-0.5 + 11.0 / 25.0, 0.5 - 7.0 / 25.0)
for a, b in zip(bounds.lbrt(), true_bounds_lbrt):
self.assertAlmostEqual(a, b)
def test_slice2bounds_bounds2slice(self):
bb = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
ct = SheetCoordinateSystem(bb, 10)
slice_ = (0, 3, 7, 8)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (4, 7, 8, 10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (2, 3, 4, 8)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (0, 3, 9, 10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
bb = BoundingBox(points=((-0.75, -0.5), (0.75, 0.5)))
ct = SheetCoordinateSystem(bb, 20, 20)
slice_ = (9, 14, 27, 29)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (0, 6, 0, 7)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (6, 10, 11, 29)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
bb = BoundingBox(points=((-0.5, -0.5), (0.5, 0.5)))
ct = SheetCoordinateSystem(bb, 7)
slice_ = (4, 7, 2, 3)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
slice_ = (0, 7, 0, 7)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_, ct))
test_slice = Slice(bounds, ct)
for a, b in zip(slice_, test_slice):
self.assertEqual(a, b)
def __call__(self, iterator, input_activity, output_activity, learning_rate, **params):
cfs = iterator.proj.cfs.tolist() # CEBALERT: convert to use flatcfs
rows,cols = output_activity.shape
# This learning function does not need to scale the learning
# rate like some do, so it does not use constant_sum_connection_rate()
single_connection_learning_rate = learning_rate
### JABALERT: The learning_radius is normally set by
### the learn() function of CFSOM, so it doesn't matter
### much that the value accepted here is in matrix and
### not sheet coordinates. It's confusing that anything
### would accept matrix coordinates, but the learning_fn
### doesn't have access to the sheet, so it can't easily
### convert from sheet coords.
radius = self.learning_radius
crop_radius = max(1.25,radius*self.crop_radius_multiplier)
# find out the matrix coordinates of the winner
#
# NOTE: when there are multiple projections, it would be
# slightly more efficient to calculate the winner coordinates
# within the Sheet, e.g. by moving winner_coords() to CFSOM
# and passing in the results here. However, finding the
# coordinates does not take much time, and requiring the
# winner to be passed in would make it harder to mix and match
# Projections and learning rules with different Sheets.
wr,wc = array_argmax(output_activity)
# Optimization: Calculate the bounding box around the winner
# in which weights will be changed, to avoid considering those
# units below.
cmin = int(max(wc-crop_radius,0))
cmax = int(min(wc+crop_radius+1,cols)) # at least 1 between cmin and cmax
rmin = int(max(wr-crop_radius,0))
rmax = int(min(wr+crop_radius+1,rows))
# generate the neighborhood kernel matrix so that the values
# can be read off easily using matrix coordinates.
nk_generator = self.neighborhood_kernel_generator
radius_int = int(ceil(crop_radius))
rbound = radius_int + 0.5
bb = BoundingBox(points=((-rbound,-rbound), (rbound,rbound)))
# Print parameters designed to match fm2d's output
#print "%d rad= %d std= %f alpha= %f" % (topo.sim._time, radius_int, radius, single_connection_learning_rate)
neighborhood_matrix = nk_generator(bounds=bb,xdensity=1,ydensity=1,
size=2*radius)
for r in range(rmin,rmax):
for c in range(cmin,cmax):
cwc = c - wc
rwr = r - wr
lattice_dist = L2norm((cwc,rwr))
if lattice_dist <= crop_radius:
cf = cfs[r][c]
rate = single_connection_learning_rate * neighborhood_matrix[rwr+radius_int,cwc+radius_int]
X = cf.get_input_matrix(input_activity)
cf.weights += rate * (X - cf.weights)
# CEBHACKALERT: see ConnectionField.__init__()
cf.weights *= cf.mask
class TestCoordinateTransforms(unittest.TestCase):
"""
Tests for sheet.
Subclassed for use; the subclasses have a setUp method to create
the particular coordinates to use each time.
"""
def makeBox(self):
self.box = BoundingBox(points=((self.left, self.bottom), (self.right,
self.top)))
self.ct = SheetCoordinateSystem(self.box, self.density, self.density)
# float bounds for matrix coordinates: these
# values are actually outside the matrix
self.rbound = self.density * (self.top - self.bottom)
self.cbound = self.density * (self.right - self.left)
#self.cbound = int(self.density*(self.right-self.left)) / float((self.right-self.left))
#self.rbound = int(self.density*(self.top-self.bottom)) / float((self.top-self.bottom))
# CEBALERT: this is supposed to be a small distance
D = 0.00001
# Sheet values around the edge of the BoundingBox
self.just_in_right_x = self.right - D
self.just_in_bottom_y = self.bottom + D
self.just_out_top_y = self.top + D
self.just_out_left_x = self.left - D
# Matrix values around the edge of the matrix
self.just_out_right_idx = self.rbound + D
self.just_out_bottom_idx = self.cbound + D
self.just_out_top_idx = 0.0 - D
self.just_out_left_idx = 0.0 - D
### sheet2matrix() tests
#
def test_sheet2matrix_center(self):
"""
Check that the center of the Sheet corresponds to the center
of the matrix.
"""
x_center = self.left + (self.right - self.left) / 2.0
y_center = self.bottom + (self.top - self.bottom) / 2.0
row, col = self.ct.sheet2matrix(x_center, y_center)
self.assertEqual((row, col), (self.rbound / 2.0, self.cbound / 2.0))
def test_sheet2matrix_left_top(self):
"""
Check that the top-left of the Sheet is [0,0] in matrix
coordinates.
"""
row, col = self.ct.sheet2matrix(self.left, self.top)
self.assertEqual((row, col), (0, 0))
def test_sheet2matrix_right_bottom(self):
"""
Check that the bottom-right of the Sheet is [rbound,cbound] in matrix
coordinates.
"""
row, col = self.ct.sheet2matrix(self.right, self.bottom)
self.assertEqual((row, col), (self.rbound, self.cbound))
def test_sheet2matrix_matrix2sheet(self):
"""
Check that matrix2sheet() is the inverse of sheet2matrix().
"""
# top-right corner
row, col = self.ct.sheet2matrix(self.right, self.top)
x_right, y_top = self.ct.matrix2sheet(row, col)
self.assertEqual((x_right, y_top), (self.right, self.top))
# bottom-left corner
row, col = self.ct.sheet2matrix(self.left, self.bottom)
x_left, y_bottom = self.ct.matrix2sheet(row, col)
self.assertEqual((x_left, y_bottom), (self.left, self.bottom))
def test_matrix2sheet_sheet2matrix(self):
"""
Check that sheet2matrix() is the inverse of matrix2sheet().
"""
# top-right corner
x, y = self.ct.matrix2sheet(float(0), float(self.last_col))
top_row, right_col = self.ct.sheet2matrix(x, y)
self.assertEqual((top_row, right_col),
(float(0), float(self.last_col)))
# bottom-left corner
x, y = self.ct.matrix2sheet(float(self.last_row), float(0))
bottom_row, left_col = self.ct.sheet2matrix(x, y)
self.assertEqual((bottom_row, left_col),
(float(self.last_row), float(0)))
### sheet2matrixidx() tests
#
def test_sheet2matrixidx_left_top(self):
"""
Test a point just inside the top-left corner of the BoundingBox, and
one just outside.
"""
# inside
r, c = 0, 0
x, y = self.left, self.top
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
# outside
r, c = -1, -1
x, y = self.just_out_left_x, self.just_out_top_y
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
def test_sheet2matrixidx_left_bottom(self):
"""
Test a point just inside the left-bottom corner of the BoundingBox, and
one just outside.
"""
# inside
r, c = self.last_row, 0
x, y = self.left, self.just_in_bottom_y
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
# outside
r, c = self.last_row + 1, -1
x, y = self.just_out_left_x, self.bottom
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
def test_sheet2matrixidx_right_top(self):
"""
Test a point just inside the top-right corner of the BoundingBox, and
one just outside.
"""
# inside
r, c = 0, self.last_col
x, y = self.just_in_right_x, self.top
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
# outside
r, c = -1, self.last_col + 1
x, y = self.right, self.just_out_top_y
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
def test_sheet2matrixidx_right_bottom(self):
"""
Test a point just inside the bottom-right corner of the BoundingBox,
and the corner itself - which should not be inside.
"""
# inside
r, c = self.last_row, self.last_col
x, y = self.just_in_right_x, self.just_in_bottom_y
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
# not inside
r, c = self.last_row + 1, self.last_col + 1
x, y = self.right, self.bottom
self.assertEqual(self.ct.sheet2matrixidx(x, y), (r, c))
### matrix2sheet() tests
#
def test_matrix2sheet_left_top(self):
"""
Check that Sheet's (0,0) is the top-left of the matrix.
Check that just outside the top-left in matrix coordinates
comes back to Sheet coordinates that are outside the
BoundingBox.
"""
x, y = self.ct.matrix2sheet(0, 0)
self.assertEqual((x, y), (self.left, self.top))
x, y = self.ct.matrix2sheet(self.just_out_left_idx,
self.just_out_top_idx)
self.assertFalse(self.box.contains(x, y))
def test_matrix2sheet_right_bottom(self):
"""
Check that Sheet's (right,bottom) is the bottom-right in
matrix coordinates i.e. [rbound,cbound]
Check that just outside the bottom-right in matrix coordinates
comes back to Sheet coordinates that are outside the
BoundingBox.
"""
x, y = self.ct.matrix2sheet(self.rbound, self.cbound)
self.assertEqual((x, y), (self.right, self.bottom))
x, y = self.ct.matrix2sheet(self.just_out_right_idx,
self.just_out_bottom_idx)
self.assertFalse(self.box.contains(x, y))
def test_matrix2sheet_center(self):
"""
Check that the center in Sheet coordinates corresponds to
the center in continuous matrix coordinates.
"""
x_center = self.left + (self.right - self.left) / 2.0
y_center = self.bottom + (self.top - self.bottom) / 2.0
center_float_row = self.rbound / 2.0
center_float_col = self.cbound / 2.0
x, y = self.ct.matrix2sheet(center_float_row, center_float_col)
self.assertEqual((x, y), (x_center, y_center))
### matrixidx2sheet() tests
#
def test_matrixidx2sheet_left_top(self):
"""
The top-left matrix cell [0,0] should be given back in Sheet
coordinates at the center of that cell.
The cell [-1,-1] outside this corner should come back out of
the BoundingBox
"""
# inside
r, c = 0, 0
x, y = self.left + self.half_unit, self.top - self.half_unit
test_x, test_y = self.ct.matrixidx2sheet(r, c)
self.assertEqual((test_x, test_y), (x, y))
self.assertTrue(self.box.contains(test_x, test_y))
# outside
r, c = -1, -1
test_x, test_y = self.ct.matrixidx2sheet(r, c)
self.assertFalse(self.box.contains(test_x, test_y))
def test_matrixidx2sheet_left_bottom(self):
"""
The bottom-left matrix cell [0,rbound] should be given back
in Sheet coordinates at the center of that cell.
The cell [last_row+1,-1] outside this corner should come back out of
the BoundingBox.
"""
# inside
r, c = self.last_row, 0
x, y = self.left + self.half_unit, self.bottom + self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r, c), (x, y))
# outside
r, c = self.last_row + 1, -1
test_x, test_y = self.ct.matrixidx2sheet(r, c)
self.assertFalse(self.box.contains(test_x, test_y))
def test_matrixidx2sheet_right_top(self):
"""
The top-right matrix cell [cbound,0] should be given back
in Sheet coordinates at the center of that cell.
The cell [-1,last_col+1] outside this corner should come back out of
the BoundingBox.
"""
# inside
r, c = 0, self.last_col
x, y = self.right - self.half_unit, self.top - self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r, c), (x, y))
# outside
r, c = -1, self.last_col + 1
test_x, test_y = self.ct.matrixidx2sheet(r, c)
self.assertFalse(self.box.contains(test_x, test_y))
def test_matrixidx2sheet_right_bottom(self):
"""
The bottom-right matrix cell [cbound,rbound] should be given back
in Sheet coordinates at the center of that cell.
The cell [last_row+1,last_col+1] outside this corner should come back out of
the BoundingBox.
"""
r, c = self.last_row, self.last_col
x, y = self.right - self.half_unit, self.bottom + self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r, c), (x, y))
# outside
r, c = self.last_row + 1, self.last_col + 1
test_x, test_y = self.ct.matrixidx2sheet(r, c)
self.assertFalse(self.box.contains(test_x, test_y))
def test_matrixidx2sheet_center(self):
"""
The row and col *index* of the center unit in the matrix should come
back as the Sheet coordinates of the center of that center unit.
"""
r, c = self.center_unit_idx
x_center = self.left + (self.right - self.left) / 2.0
y_center = self.bottom + (self.top - self.bottom) / 2.0
x, y = x_center + self.half_unit, y_center - self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r, c), (x, y))
def test_matrixidx2sheet_sheet2matrixidx(self):
"""
Check that sheet2matrixidx() is the inverse of matrix2sheetidx().
"""
# top-right corner
x, y = self.ct.matrixidx2sheet(float(0), float(self.last_col))
top_row, right_col = self.ct.sheet2matrixidx(x, y)
self.assertEqual((top_row, right_col),
(float(0), float(self.last_col)))
# bottom-left corner
x, y = self.ct.matrixidx2sheet(float(self.last_row), float(0))
bottom_row, left_col = self.ct.sheet2matrixidx(x, y)
self.assertEqual((bottom_row, left_col),
(float(self.last_row), float(0)))
def test_slice2bounds(self):
# test that if you ask to slice the matrix with the sheet's BoundingBox, you
# get back the whole matrix
# (I chose to use a 7 density, I don't know why I like 7 so much, it is kind of mystical)
sheet_bb = BoundingBox(points=((-0.5,-0.5),(0.5,0.5)))
ct = SheetCoordinateSystem(sheet_bb,7)
slice_ = (0,7,0,7)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.5,-0.5,0.5,0.5)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
# for the following tests, the values have been all computed
# by hand and then tested (by JC). The boundingbox and density
# tested have been chosen randomly, then drawn to get the slice
# from it.
# Test for 10 density
ct = SheetCoordinateSystem(sheet_bb,10)
slice_ = (0,9,1,5)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.4,-0.4,0,0.5)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
slice_ = (2,3,7,10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (0.2,0.2,0.5,0.3)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
# Test for 7 density
ct = SheetCoordinateSystem(sheet_bb,7)
slice_ = (3,7,2,5)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.5+2.0/7.0,-0.5,-0.5+5.0/7.0,0.5-3.0/7.0)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
slice_ = (2,6,0,1)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.5,0.5-6.0/7.0,-0.5+1.0/7.0,0.5-2.0/7.0)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
# Test for 25 density
ct = SheetCoordinateSystem(sheet_bb,25)
slice_ = (0,25,4,10)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.5+4.0/25.0,-0.5,-0.5+10.0/25.0,0.5)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
slice_ = (7,18,3,11)
bounds = BoundingBox(points=Slice._slicespec2boundsspec(slice_,ct))
true_bounds_lbrt = (-0.5+3.0/25.0,0.5-18.0/25.0,-0.5+11.0/25.0,0.5-7.0/25.0)
for a,b in zip(bounds.lbrt(),true_bounds_lbrt):
self.assertAlmostEqual(a,b)
def test_fit_longest(self):
"""
Check that the longer image dimension is made to fit the default
dimension of 1.0, while the other is scaled the same.
"""
### Twice the default BoundingBox dimensions, image size of 2.0.
### In this case, 8 units represent 1.0 in sheet coordinates.
image_array = array([[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
0.,
0.,
0.,
0.,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
0.,
0.,
0.,
0.,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
255.,
255.,
0.,
0.,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
255.,
255.,
0.,
0.,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
255.,
255.,
255.,
255.,
],
[
0.,
0.,
34.,
34.,
68.,
68.,
102.,
102.,
136.,
136.,
255.,
255.,
255.,
255.,
255.,
255.,
],
[
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
],
[
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
],
[
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
],
[
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
0.,
0.,
255.,
255.,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
],
[
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
96.59090909,
]], Float)
image = FileImage(filename=resolve_path('tests/testimage.pgm'),
xdensity=8,
ydensity=8,
size=2.0,
output_fns=[],
bounds=BoundingBox(radius=1.0))
ps = image.pattern_sampler
ps.size_normalization = 'fit_longest'
ps.whole_pattern_output_fns = []
assert_array_almost_equal(image_array, image())
class TestCoordinateTransforms(unittest.TestCase):
"""
Tests for sheet.
Subclassed for use; the subclasses have a setUp method to create
the particular coordinates to use each time.
"""
def makeBox(self):
self.box = BoundingBox(points=((self.left,self.bottom),
(self.right,self.top)))
self.ct = SheetCoordinateSystem(self.box,self.density,self.density)
# float bounds for matrix coordinates: these
# values are actually outside the matrix
self.rbound = self.density*(self.top-self.bottom)
self.cbound = self.density*(self.right-self.left)
#self.cbound = int(self.density*(self.right-self.left)) / float((self.right-self.left))
#self.rbound = int(self.density*(self.top-self.bottom)) / float((self.top-self.bottom))
# CEBALERT: this is supposed to be a small distance
D = 0.00001
# Sheet values around the edge of the BoundingBox
self.just_in_right_x = self.right - D
self.just_in_bottom_y = self.bottom + D
self.just_out_top_y = self.top + D
self.just_out_left_x = self.left - D
# Matrix values around the edge of the matrix
self.just_out_right_idx = self.rbound + D
self.just_out_bottom_idx = self.cbound + D
self.just_out_top_idx = 0.0 - D
self.just_out_left_idx = 0.0 - D
### sheet2matrix() tests
#
def test_sheet2matrix_center(self):
"""
Check that the center of the Sheet corresponds to the center
of the matrix.
"""
x_center = self.left+(self.right-self.left)/2.0
y_center = self.bottom+(self.top-self.bottom)/2.0
row, col = self.ct.sheet2matrix(x_center,y_center)
self.assertEqual((row,col),(self.rbound/2.0,self.cbound/2.0))
def test_sheet2matrix_left_top(self):
"""
Check that the top-left of the Sheet is [0,0] in matrix
coordinates.
"""
row, col = self.ct.sheet2matrix(self.left,self.top)
self.assertEqual((row,col),(0,0))
def test_sheet2matrix_right_bottom(self):
"""
Check that the bottom-right of the Sheet is [rbound,cbound] in matrix
coordinates.
"""
row, col = self.ct.sheet2matrix(self.right,self.bottom)
self.assertEqual((row,col),(self.rbound,self.cbound))
def test_sheet2matrix_matrix2sheet(self):
"""
Check that matrix2sheet() is the inverse of sheet2matrix().
"""
# top-right corner
row, col = self.ct.sheet2matrix(self.right,self.top)
x_right, y_top = self.ct.matrix2sheet(row,col)
self.assertEqual((x_right,y_top),(self.right,self.top))
# bottom-left corner
row, col = self.ct.sheet2matrix(self.left,self.bottom)
x_left, y_bottom = self.ct.matrix2sheet(row,col)
self.assertEqual((x_left,y_bottom),(self.left,self.bottom))
def test_matrix2sheet_sheet2matrix(self):
"""
Check that sheet2matrix() is the inverse of matrix2sheet().
"""
# top-right corner
x,y = self.ct.matrix2sheet(float(0),float(self.last_col))
top_row,right_col = self.ct.sheet2matrix(x,y)
self.assertEqual((top_row,right_col),(float(0),float(self.last_col)))
# bottom-left corner
x,y = self.ct.matrix2sheet(float(self.last_row),float(0))
bottom_row,left_col = self.ct.sheet2matrix(x,y)
self.assertEqual((bottom_row,left_col),(float(self.last_row),float(0)))
### sheet2matrixidx() tests
#
def test_sheet2matrixidx_left_top(self):
"""
Test a point just inside the top-left corner of the BoundingBox, and
one just outside.
"""
# inside
r,c = 0,0
x,y = self.left,self.top
self.assertEqual(self.ct.sheet2matrixidx(x,y), (r,c))
# outside
r,c = -1,-1
x,y = self.just_out_left_x,self.just_out_top_y
self.assertEqual(self.ct.sheet2matrixidx(x,y), (r,c))
def test_sheet2matrixidx_left_bottom(self):
"""
Test a point just inside the left-bottom corner of the BoundingBox, and
one just outside.
"""
# inside
r,c = self.last_row, 0
x,y = self.left, self.just_in_bottom_y
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
# outside
r,c = self.last_row+1, -1
x,y = self.just_out_left_x, self.bottom
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
def test_sheet2matrixidx_right_top(self):
"""
Test a point just inside the top-right corner of the BoundingBox, and
one just outside.
"""
# inside
r,c = 0,self.last_col
x,y = self.just_in_right_x,self.top
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
# outside
r,c = -1,self.last_col+1
x,y = self.right,self.just_out_top_y
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
def test_sheet2matrixidx_right_bottom(self):
"""
Test a point just inside the bottom-right corner of the BoundingBox,
and the corner itself - which should not be inside.
"""
# inside
r,c = self.last_row,self.last_col
x,y = self.just_in_right_x,self.just_in_bottom_y
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
# not inside
r,c = self.last_row+1,self.last_col+1
x,y = self.right,self.bottom
self.assertEqual(self.ct.sheet2matrixidx(x,y),(r,c))
### matrix2sheet() tests
#
def test_matrix2sheet_left_top(self):
"""
Check that Sheet's (0,0) is the top-left of the matrix.
Check that just outside the top-left in matrix coordinates
comes back to Sheet coordinates that are outside the
BoundingBox.
"""
x,y = self.ct.matrix2sheet(0,0)
self.assertEqual((x,y), (self.left,self.top))
x,y = self.ct.matrix2sheet(self.just_out_left_idx,self.just_out_top_idx)
self.assertFalse(self.box.contains(x,y))
def test_matrix2sheet_right_bottom(self):
"""
Check that Sheet's (right,bottom) is the bottom-right in
matrix coordinates i.e. [rbound,cbound]
Check that just outside the bottom-right in matrix coordinates
comes back to Sheet coordinates that are outside the
BoundingBox.
"""
x,y = self.ct.matrix2sheet(self.rbound,self.cbound)
self.assertEqual((x,y), (self.right,self.bottom))
x,y = self.ct.matrix2sheet(self.just_out_right_idx,self.just_out_bottom_idx)
self.assertFalse(self.box.contains(x,y))
def test_matrix2sheet_center(self):
"""
Check that the center in Sheet coordinates corresponds to
the center in continuous matrix coordinates.
"""
x_center = self.left+(self.right-self.left)/2.0
y_center = self.bottom+(self.top-self.bottom)/2.0
center_float_row = self.rbound/2.0
center_float_col = self.cbound/2.0
x,y = self.ct.matrix2sheet(center_float_row,center_float_col)
self.assertEqual((x,y),(x_center,y_center))
### matrixidx2sheet() tests
#
def test_matrixidx2sheet_left_top(self):
"""
The top-left matrix cell [0,0] should be given back in Sheet
coordinates at the center of that cell.
The cell [-1,-1] outside this corner should come back out of
the BoundingBox
"""
# inside
r,c = 0,0
x,y = self.left+self.half_unit,self.top-self.half_unit
test_x, test_y = self.ct.matrixidx2sheet(r,c)
self.assertEqual((test_x,test_y), (x,y))
self.assertTrue(self.box.contains(test_x,test_y))
# outside
r,c = -1,-1
test_x, test_y = self.ct.matrixidx2sheet(r,c)
self.assertFalse(self.box.contains(test_x,test_y))
def test_matrixidx2sheet_left_bottom(self):
"""
The bottom-left matrix cell [0,rbound] should be given back
in Sheet coordinates at the center of that cell.
The cell [last_row+1,-1] outside this corner should come back out of
the BoundingBox.
"""
# inside
r,c = self.last_row,0
x,y = self.left+self.half_unit,self.bottom+self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r,c), (x,y))
# outside
r,c = self.last_row+1,-1
test_x, test_y = self.ct.matrixidx2sheet(r,c)
self.assertFalse(self.box.contains(test_x,test_y))
def test_matrixidx2sheet_right_top(self):
"""
The top-right matrix cell [cbound,0] should be given back
in Sheet coordinates at the center of that cell.
The cell [-1,last_col+1] outside this corner should come back out of
the BoundingBox.
"""
# inside
r,c = 0,self.last_col
x,y = self.right-self.half_unit,self.top-self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r,c), (x,y))
# outside
r,c = -1,self.last_col+1
test_x, test_y = self.ct.matrixidx2sheet(r,c)
self.assertFalse(self.box.contains(test_x,test_y))
def test_matrixidx2sheet_right_bottom(self):
"""
The bottom-right matrix cell [cbound,rbound] should be given back
in Sheet coordinates at the center of that cell.
The cell [last_row+1,last_col+1] outside this corner should come back out of
the BoundingBox.
"""
r,c = self.last_row,self.last_col
x,y = self.right-self.half_unit,self.bottom+self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r,c), (x,y))
# outside
r,c = self.last_row+1,self.last_col+1
test_x, test_y = self.ct.matrixidx2sheet(r,c)
self.assertFalse(self.box.contains(test_x,test_y))
def test_matrixidx2sheet_center(self):
"""
The row and col *index* of the center unit in the matrix should come
back as the Sheet coordinates of the center of that center unit.
"""
r,c = self.center_unit_idx
x_center = self.left+(self.right-self.left)/2.0
y_center = self.bottom+(self.top-self.bottom)/2.0
x,y = x_center+self.half_unit, y_center-self.half_unit
self.assertEqual(self.ct.matrixidx2sheet(r,c), (x,y))
def test_matrixidx2sheet_sheet2matrixidx(self):
"""
Check that sheet2matrixidx() is the inverse of matrix2sheetidx().
"""
# top-right corner
x,y = self.ct.matrixidx2sheet(float(0),float(self.last_col))
top_row,right_col = self.ct.sheet2matrixidx(x,y)
self.assertEqual((top_row,right_col),(float(0),float(self.last_col)))
# bottom-left corner
x,y = self.ct.matrixidx2sheet(float(self.last_row),float(0))
bottom_row,left_col = self.ct.sheet2matrixidx(x,y)
self.assertEqual((bottom_row,left_col),(float(self.last_row),float(0)))
