def test_patch_distance(self):
""" Test the squared euclidean distance between patches.
"""
for patch1, patch2, metric in zip(self.patches1, self.patches2,
self.metrics):
dist = patch_distance(patch1, patch2)
self.assertEqual(dist, metric)
def _get_denoised_patch(self, index):
""" Method that compute the denoised patch at a specific location.
Parameters
----------
index: array
the patch central location.
Returns
-------
patch: aray
the denoised patch.
weight: float
the patch power (ie., the sum of all the weights associated to
the neighbor patches).
"""
# Get patch around the current location.
central_patch = get_patch(
index, self.to_denoise_array, self.full_patch_size)
if not self.use_cython:
# Intern parameters
# > maximum weight of patches
wmax = 0
# > sum of weights: used for normalization
wsum = 0
# Allocate the patch result
patch = numpy.zeros(self.full_patch_size, dtype=numpy.single)
# Compute the search region
search_elements = self._get_search_elements(index)
# Go through all the search indices
for neighbor_index in search_elements:
# Optimize the speed of the patch search
if self.use_optimized_strategy:
is_valid_neighbor = self._check_speed(
tuple(index), tuple(neighbor_index))
else:
is_valid_neighbor = True
# If we are dealing with a valid neighbor
if is_valid_neighbor:
# Create the neighbor patch
neighbor_patch = get_patch(
neighbor_index, self.to_denoise_array, self.full_patch_size)
# Compute the weight associated to the distance between the
# central and neighbor patches
weight = numpy.exp(
- patch_distance(central_patch, neighbor_patch) /
self.range_bandwidth)
# Keep trace of the maximum weight
if weight > wmax:
wmax = weight
# Update the weight sum
wsum += weight
# Update the result denoised patch
patch += neighbor_patch * weight
else:
# Use compiled code to do the same steps as the upper python version
patch, wsum, wmax = get_average_patch(
self.to_denoise_array, index, self.half_spatial_bandwidth,
self.half_patch_size, self.full_patch_size, self.range_bandwidth,
self.mean_array, self.variance_array, self.use_optimized_strategy,
self.lower_mean_threshold, self.lower_variance_threshold,
self.nb_of_threads)
# Deal with the central patch based on the user parameters
# > add the central patch
if self.central_point_strategy == "add":
patch += central_patch
wsum += 1.
# > remove the central patch
elif self.central_point_strategy == "remove":
pass
# > use a weighted central patch
elif self.central_point_strategy == "weight":
patch += (1. - wmax) * central_patch
wsum += (1. - wmax)
# > raise value error
else:
raise ValueError("Unexpected central point strategy '{0}'.".format(
self.central_point_strategy))
# Normalize the denoised patch if the total weight is big enough
if wsum > 0.0001:
patch /= wsum
# Otherwise can't denoise properly, copy the central patch to the
# denoise patch
else:
patch = central_patch
return patch, wsum
def test_patch_distance(self):
""" Test the squared euclidean distance between patches.
"""
for patch1, patch2, metric in zip(self.patches1, self.patches2, self.metrics):
dist = patch_distance(patch1, patch2)
self.assertEqual(dist, metric)
