def compute_cov_eq_linear_transform_matrix(
input_scene, # type: ndarray
scene_to_match, # type: ndarray
input_scene_mask=None, # type: ndarray
scene_to_match_mask=None # type: ndarray
): # type: (...) -> ndarray
flattened_1 = spectral_tools.flatten_image_cube(input_scene)
flattened_2 = spectral_tools.flatten_image_cube(scene_to_match)
flattened_mask_1 = image_utils.flatten_image_band(input_scene_mask)
flattened_mask_2 = image_utils.flatten_image_band(scene_to_match_mask)
big_l = spectral_image_processing_1d.compute_cov_eq_linear_transform_matrix(
flattened_1, flattened_2, flattened_mask_1, flattened_mask_2)
return big_l
def test_masked_mean_1d(self):
print("")
print("MASKED MEAN TEST 1D")
image_cube = image_utils.create_uniform_image_data(nx,
ny,
nbands,
values=0,
dtype=np.float32)
image_cube[y_loc, x_loc, :] = np.arange(0, nbands)
flattened_image = spectral_utils.flatten_image_cube(image_cube)
image_mask = np.zeros((ny, nx))
image_mask[y_loc, x_loc] = 1
flattened_mask = image_utils.flatten_image_band(image_mask)
raw_mean = sp1d.compute_image_cube_spectral_mean(flattened_image)
masked_mean = sp1d.compute_image_cube_spectral_mean(
flattened_image, flattened_mask)
assert len(masked_mean) == nbands
assert len(raw_mean) == nbands
logging.debug("length of means equals number of spectral bands")
assert masked_mean.max() == 0
assert raw_mean.max() != 0
logging.debug(
"1d image cube raw and masked means have different results")
logging.debug("masked_mean_1d test passed")
print("MASKED MEAN TEST 1D - TEST PASSED")
def test_sam_ace_compare(self):
print("")
print("SAM / ACE EQUALITY TEST WHEN INVERSE COVARIANCE IS IDENTITY")
random_cube = np.random.random((ny, nx, nbands))
signal_x_axis = np.arange(0, nbands) / nbands * 2 * np.pi
signal_to_embed = np.sin(signal_x_axis) * 100
background_to_embed = np.cos(signal_x_axis) * 100
image_cube = random_cube + background_to_embed
image_cube[y_loc,
x_loc, :] = image_cube[y_loc, x_loc, :] + signal_to_embed
flattened_image = spectral_utils.flatten_image_cube(image_cube)
ace_inv_cov = np.eye(nbands)
ace_mean = np.zeros(nbands)
ace_detection_result = sp1d.ace(flattened_image, signal_to_embed,
ace_mean, ace_inv_cov)
sam_detection_result = sp1d.sam(flattened_image, signal_to_embed)
# TODO: use higher precision if we need better accuracy
np.testing.assert_allclose(ace_detection_result,
np.square(sam_detection_result),
rtol=1.e-6)
logging.debug("SAM squared is equivalent to ACE if the inverse "
"covariance is the identify matrix")
print("ACE / SAM comparison test passed.")
def test_sam_1d(self):
print("")
print("SAM TEST 1D")
random_cube = np.random.random((ny, nx, nbands))
signal_x_axis = np.arange(0, nbands) / nbands * 2 * np.pi
signal_to_embed = np.sin(signal_x_axis) * 100
background_to_embed = np.cos(signal_x_axis) * 100
image_cube = random_cube + background_to_embed
image_cube[y_loc,
x_loc, :] = image_cube[y_loc, x_loc, :] + signal_to_embed
flattened_image = spectral_utils.flatten_image_cube(image_cube)
detection_result = sp1d.sam(flattened_image, signal_to_embed)
detection_result_2d = image_utils.unflatten_image_band(
detection_result, nx, ny)
detection_max_locs_y_x = np.where(
detection_result_2d == detection_result_2d.max())
detection_max_y = detection_max_locs_y_x[0][0]
detection_max_x = detection_max_locs_y_x[1][0]
assert detection_max_y == y_loc
assert detection_max_x == x_loc
logging.debug("location of highest detection return matches x/y "
"location of embedded signal")
print("1-D SAM TEST PASSED")
def test_masked_covar_1d(self):
print("")
print("MASKED COVARIANCE TEST 1D")
image_cube = image_utils.create_uniform_image_data(nx,
ny,
nbands,
values=0,
dtype=np.float32)
image_cube[y_loc, x_loc, :] = np.arange(0, nbands)
flattened_image = spectral_utils.flatten_image_cube(image_cube)
image_mask = np.zeros((ny, nx))
image_mask[y_loc, x_loc] = 1
flattened_mask = image_utils.flatten_image_band(image_mask)
raw_covar = sp1d.compute_image_cube_spectral_covariance(
flattened_image)
masked_covar = sp1d.compute_image_cube_spectral_covariance(
flattened_image, flattened_mask)
assert masked_covar.shape == (nbands, nbands)
assert raw_covar.shape == (nbands, nbands)
logging.debug("covariance shape is (nbands x nbands)")
assert masked_covar.max() == 0
assert raw_covar.max() != 0
logging.debug(
"1d image cube raw and masked covariances have different results")
print("MASKED_COVAR_1D TEST PASSED")
def compute_image_cube_spectral_covariance(
spectral_image, # type: ndarray
image_mask=None # type: ndarray
): # type: (...) -> ndarray
spectral_image = spectral_tools.flatten_image_cube(spectral_image)
if image_mask is not None:
image_mask = image_utils.flatten_image_band(image_mask)
masked_covariance = spectral_image_processing_1d.compute_image_cube_spectral_covariance(
spectral_image, image_mask)
return masked_covariance
def sam(
spectral_image, # type: ndarray
target_spectra # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(spectral_image)
spectral_image = spectral_tools.flatten_image_cube(spectral_image)
sam_result = spectral_image_processing_1d.sam(spectral_image,
target_spectra)
sam_result = image_utils.unflatten_image_band(sam_result, nx, ny)
return sam_result
def rx_anomaly_detector(
spectral_image, # type: ndarray
spectral_mean=None, # type: ndarray
inverse_covariance=None # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(spectral_image)
spectral_image = spectral_tools.flatten_image_cube(spectral_image)
rx_result = spectral_image_processing_1d.rx_anomaly_detector(
spectral_image, spectral_mean, inverse_covariance)
rx_result = image_utils.unflatten_image_band(rx_result, nx, ny)
return rx_result
def covariance_equalization_mean_centered(
input_scene_demeaned, # type: ndarray
scene_to_match_demeaned, # type: ndarray
input_scene_mask=None, # type: ndarray
scene_to_match_mask=None # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(
input_scene_demeaned)
flattened_1 = spectral_tools.flatten_image_cube(input_scene_demeaned)
flattened_2 = spectral_tools.flatten_image_cube(scene_to_match_demeaned)
if input_scene_mask is not None:
input_scene_mask = image_utils.flatten_image_band(input_scene_mask)
if scene_to_match_mask is not None:
scene_to_match_mask = image_utils.flatten_image_band(
scene_to_match_mask)
scene_1_cov_equalized = spectral_image_processing_1d.covariance_equalization_mean_centered(
flattened_1, flattened_2, input_scene_mask, scene_to_match_mask)
scene_1_cov_equalized = spectral_tools.unflatten_image_cube(
scene_1_cov_equalized, nx, ny)
return scene_1_cov_equalized
def ace_demeaned(
demeaned_image, # type: ndarray
demeaned_target_spectrum, # type: ndarray
inverse_covariance, # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(demeaned_image)
spectral_image = spectral_tools.flatten_image_cube(demeaned_image)
ace_result = spectral_image_processing_1d.ace_demeaned(
spectral_image, demeaned_target_spectrum, inverse_covariance)
ace_result = image_utils.unflatten_image_band(ace_result, nx, ny)
return ace_result
def demean_image_data(
spectral_image, # type: ndarray
image_mask=None # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(spectral_image)
spectral_image = spectral_tools.flatten_image_cube(spectral_image)
if image_mask is not None:
image_mask = image_utils.flatten_image_band(image_mask)
demeaned_image_data = spectral_image_processing_1d.demean_image_data(
spectral_image, image_mask)
demeaned_image_data = spectral_tools.unflatten_image_cube(
demeaned_image_data, nx, ny)
return demeaned_image_data
def test_flatten_image_cube(self):
print("")
print("FLATTEN IMAGE CUBE TEST")
image_cube = image_utils.create_uniform_image_data(nx,
ny,
nbands,
values=0,
dtype=np.float32)
image_cube[y_loc, x_loc, :] = np.arange(0, nbands)
flattened_image = spectral_utils.flatten_image_cube(image_cube)
unflattend_image_cube = spectral_utils.unflatten_image_cube(
flattened_image, nx, ny)
assert (unflattend_image_cube == image_cube).all()
print("flattening and unflattening image cube matches with original")
def test_covariance_equalization(self):
print("")
print("COVARIANCE EQUALIZATION TEST")
scene_1 = np.random.random((ny, nx, nbands))
scene_1 = spectral_utils.flatten_image_cube(scene_1)
scene_1 = scene_1 + (
np.sin(np.arange(0, nbands) / nbands * (2 * np.pi)) / 4 + 0.75)
scene_2 = scene_1 * 2.0
scene_1_equalized = sp1d.covariance_equalization_mean_centered(
scene_1, scene_2)
scene_2_cov = sp1d.compute_image_cube_spectral_covariance(scene_2)
scene_1_equalized_cov = sp1d.compute_image_cube_spectral_covariance(
scene_1_equalized)
np.testing.assert_almost_equal(scene_2_cov, scene_1_equalized_cov)
logging.debug(
"equalized covariance from scene_1 matches covariance of scene_2")
print("COVARIANCE EQUALIZATION TEST PASSED")
def ace(
spectral_image, # type: ndarray
target_spectra, # type: ndarray
spectral_mean=None, # type: ndarray
inverse_covariance=None, # type: ndarray
image_mask=None, # type: ndarray
): # type: (...) -> ndarray
nx, ny, nbands = spectral_tools.get_2d_cube_nx_ny_nbands(spectral_image)
spectral_image = spectral_tools.flatten_image_cube(spectral_image)
if image_mask is not None:
image_mask = image_utils.flatten_image_band(image_mask)
ace_result = spectral_image_processing_1d.ace(spectral_image,
target_spectra,
spectral_mean,
inverse_covariance,
image_mask)
ace_result = image_utils.unflatten_image_band(ace_result, nx, ny)
return ace_result
def test_rx_1d(self):
print("")
print("RX ANAMOLY TEST 1D")
image_cube = np.random.random((ny, nx, nbands))
signal_x_axis = np.arange(0, nbands) / nbands * 2 * np.pi
signal_to_embed = np.sin(signal_x_axis) * 100
image_cube[y_loc, x_loc, :] = signal_to_embed
flattened_image = spectral_utils.flatten_image_cube(image_cube)
image_mask = np.zeros((ny, nx))
image_mask[y_loc, x_loc] = 1
flattened_mask = image_utils.flatten_image_band(image_mask)
masked_mean = sp1d.compute_image_cube_spectral_mean(
flattened_image, flattened_mask)
masked_covar = sp1d.compute_image_cube_spectral_covariance(
flattened_image, flattened_mask)
masked_inv_cov = np.linalg.inv(masked_covar)
detection_result = sp1d.rx_anomaly_detector(flattened_image,
masked_mean,
masked_inv_cov)
detection_result_2d = image_utils.unflatten_image_band(
detection_result, nx, ny)
detection_max_locs_y_x = np.where(
detection_result_2d == detection_result_2d.max())
detection_max_y = detection_max_locs_y_x[0][0]
detection_max_x = detection_max_locs_y_x[1][0]
assert detection_max_y == y_loc
assert detection_max_x == x_loc
assert len(detection_result.shape) == 1
assert detection_result.shape[0] == nx * ny
logging.debug("location of highest detection return matches x/y "
"location of embedded signal")
print("1d rx passed ")
print("")
def test_sam_ace_sanity_check(self):
print("")
print("SAM / ACE COMPARISON AND SANITY CHECK TEST")
random_cube = np.random.random((ny, nx, nbands))
signal_x_axis = np.arange(0, nbands) / nbands * 2 * np.pi
signal_to_embed = np.sin(signal_x_axis) * 100
background_to_embed = np.cos(signal_x_axis) * 100
image_cube = random_cube + background_to_embed
image_cube[y_loc,
x_loc, :] = image_cube[y_loc, x_loc, :] + signal_to_embed
flattened_image = spectral_utils.flatten_image_cube(image_cube)
demeaned_target_sig_array = signal_to_embed
inverse_covariance = np.eye(nbands)
signal_x_axis = np.arange(0, nbands) / nbands * 2 * np.pi
signal_to_embed = np.sin(signal_x_axis) * 100
target_spectra = signal_to_embed
# checking ace / sam numerator right hand side
# Python 3.5+
# ace_numerator = inverse_covariance @ flattened_image.transpose()
# Python 2.7 - 3.4
ace_numerator = np.dot(inverse_covariance, flattened_image.transpose())
ace_numerator = np.multiply(target_spectra, ace_numerator.transpose())
ace_numerator = np.square(np.sum(ace_numerator, axis=1))
# Python 3.5+
# ace_den_left = (
# inverse_covariance @ demeaned_target_sig_array.transpose())
# Python 2.7 - 3.4
ace_den_left = np.dot(inverse_covariance,
demeaned_target_sig_array.transpose())
ace_den_left = np.multiply(demeaned_target_sig_array,
ace_den_left.transpose())
ace_den_left = np.sum(ace_den_left)
# Python 3.5+
# ace_den_right = inverse_covariance @ flattened_image.transpose()
# Python 2.7 - 3.4
ace_den_right = np.dot(inverse_covariance, flattened_image.transpose())
ace_den_right = np.multiply(flattened_image, ace_den_right.transpose())
ace_den_right = np.sum(ace_den_right, axis=1)
# Python 3.5+
# sam_numerator = target_spectra @ flattened_image.transpose()
# Python 2.7 - 3.4
sam_numerator = np.dot(target_spectra, flattened_image.transpose())
# Python 3.5+
# sam_den_left = np.sqrt(target_spectra @ target_spectra)
# Python 2.7 - 3.4
sam_den_left = np.sqrt(np.dot(target_spectra, target_spectra))
sam_den_right = np.sqrt(
np.sum(np.multiply(flattened_image, flattened_image), axis=1))
np.testing.assert_allclose(ace_numerator,
np.square(sam_numerator),
rtol=1.e-6)
np.testing.assert_allclose(ace_den_left,
np.square(sam_den_left),
rtol=1.e-6)
np.testing.assert_allclose(ace_den_right,
np.square(sam_den_right),
rtol=1.e-6)
logging.debug(
"sam and ace portions of numerators and denominators are "
"close when the covariance is an identify matrix.")
print("SAM / ACE SANITY CHECK TEST PASSED")
