def test_dendrogramComputation(self):
d = Dendrogram(self.data, minimum_npix=8, minimum_delta=0.3, minimum_flux=1.4, verbose=False)
num_leaves = len(d.get_leaves())
self.assertEqual(num_leaves,55) # This data with these parameters should produce 55 leaves
# Now check every pixel in the data cube (this takes a while).
# The following loop construct may look crazy, but it is a more
# efficient way of iterating through the array than using a regular
# nditer with multi_index.
for coord in np.array(np.unravel_index( np.arange(self.data.size), self.data.shape)).transpose():
coord = tuple(coord)
f = self.data[coord]
if (f < 1.4):
self.assertEqual(d.item_at(coord), None)
else:
item = d.item_at(coord)
if item:
# The current pixel is associated with part of the dendrogram.
self.assertIn(coord, item.coords, "Pixel at {0} is claimed to be part of {1}, but that item does not contain the coordinate {0}!".format(coord, item))
fmax_item, _, fmax = item.get_peak_recursive()
if fmax_item is item:
# The current pixel is the peak pixel in this item
pass
else:
self.assertTrue(fmax >= f)
def test_4dim(self):
" Test 4-dimensional data "
data = np.zeros((5,5,5,5)) # Create a 5x5x5x5 array initialized to zero
# N-dimensional data is hard to conceptualize so I've kept this simple.
# Create a local maximum (value 5) at the centre
data[2,2,2,2] = 5
# add some points around it of intensity 3. Note that '1:4:2' is equivalent to saying indices '1' and '3'
data[2,1:4:2,2,2] = data[2,2,1:4:2,2] = data[2,2,2,1:4:2] = 3
# Add a trail of points of value 2 connecting one of those 3s to a 4
data[0:3,0,2,2] = 2 # Sets [0,0,2,2], [1,0,2,2], and [2,0,2,2] all equal to 2 -> will connect to the '3' at [2,1,2,2]
data[0,0,2,1] = 4
# Now dendrogram it:
d = Dendrogram(data, minimum_flux=1, verbose=False)
# We expect two leaves:
leaves = d.get_leaves()
self.assertEqual(len(leaves), 2)
# We expect one branch:
branches = [i for i in d.all_items if type(i) is Branch]
self.assertEqual(len(branches), 1)
self.assertEqual(len(d.trunk), 1)
self.assertEqual(d.trunk[0], branches[0])
# The maxima of each leaf should be at [2,2,2,2] and [0,3,2,1]
for leaf in leaves:
self.assertIn(leaf.peak, ( ((2,2,2,2), 5.), ((0,0,2,1),4.) ) )
self.assertNotEqual(leaves[0].peak, leaves[1].peak)
# Check out a few more properties of the leaf around the global maximum:
leaf = d.item_at((2,2,2,2))
self.assertEqual(leaf.fmax, 5)
self.assertEqual(leaf.fmin, 2)
self.assertEqual(leaf.npix, 1+6+2) # Contains 1x '5', 6x '3', and 2x '2'. The other '2' should be in the branch
# Check that the only pixel in the branch is a '2' at [0,0,2,2]
self.assertEqual((branches[0].coords, branches[0].f), ( [(0,0,2,2),],[2.,] ))
def test_computing_level(self):
d = Dendrogram(self.data, verbose=False)
# Now pick an item near the middle of the dendrogram:
mid_item = d.item_at((0, self.size//2))
# Compute its level:
sys.setrecursionlimit(100000)
_ = mid_item.level
# Now check the .level property of all items, in random order:
import random
items = random.sample(list(d.all_items), len(d.items_dict))
for item in items:
obj = item
level = item.level
while level > 0:
obj = obj.parent
level -= 1
self.assertEqual(obj.parent, None)
self.assertEqual(obj.level, 0)