changed around demo names, added dim mismatch bug fix to sig detectors

Author: Yutai

README.md

@@ -1,2 +1,4 @@
 # hsi_toolkit_py
 GatorSense Hyperspectral Image Analysis Toolkit - Python Implementation
+
+Hyperspectral image format: height x width x bands

anomaly_detectors/anomaly_det_demo.py renamed to anomaly_detectors/demo_anomaly_detector.py

@@ -21,6 +21,9 @@ def abd_detector(hsi_img, tgt_sig, ems, mask = None):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	abd_out, kwargsout = img_det(abd_helper,hsi_img,tgt_sig,mask,ems = ems);
 
 	return abd_out

classifiers/classification_demo.py renamed to classifiers/demo_classification.py

@@ -4,44 +4,47 @@
 import numpy as np
 
 def ace_detector(hsi_img, tgt_sig, mask = None, mu = None, sig_inv = None):
-	"""
-	Squared Adaptive Cosine/Coherence Estimator
-
-	Inputs:
-		hsi_image - n_row x n_col x n_band hyperspectral image
-		tgt_sig - target signature (n_band x 1 - column vector)
-		mask - binary image limiting detector operation to pixels where mask is true
-		       if not present or empty, no mask restrictions are used
-		mu - background mean (n_band x 1 column vector)
-		sig_inv - background inverse covariance (n_band x n_band matrix)
-
-	Outputs:
-		ace_out - detector image
-		mu - mean of input data
-		sig_inv - inverse covariance of input data
-
-	 8/8/2012 - Taylor C. Glenn
-	 6/2/2018 - Edited by Alina Zare
-	 10/2018 - Python Implementation by Yutai Zhou
-	 """
-	ace_out, kwargsout = img_det(ace_det_helper, hsi_img, tgt_sig, mask, mu = mu, sig_inv = sig_inv)
-	return ace_out, kwargsout['mu'], kwargsout['sig_inv']
+    """
+    Squared Adaptive Cosine/Coherence Estimator
+
+    Inputs:
+        hsi_image - n_row x n_col x n_band hyperspectral image
+        tgt_sig - target signature (n_band x 1 - column vector)
+        mask - binary image limiting detector operation to pixels where mask is true
+               if not present or empty, no mask restrictions are used
+        mu - background mean (n_band x 1 column vector)
+        sig_inv - background inverse covariance (n_band x n_band matrix)
+
+    Outputs:
+        ace_out - detector image
+        mu - mean of input data
+        sig_inv - inverse covariance of input data
+
+     8/8/2012 - Taylor C. Glenn
+     6/2/2018 - Edited by Alina Zare
+     10/2018 - Python Implementation by Yutai Zhou
+     """
+    if tgt_sig.ndim == 1:
+        tgt_sig = tgt_sig[:, np.newaxis]
+
+    ace_out, kwargsout = img_det(ace_det_helper, hsi_img, tgt_sig, mask, mu = mu, sig_inv = sig_inv)
+    return ace_out, kwargsout['mu'], kwargsout['sig_inv']
 
 def ace_det_helper(hsi_data, tgt_sig, kwargs):
-	mu = np.mean(hsi_data, axis = 1) if kwargs['mu'] is None else kwargs['mu']
-	sig_inv = np.linalg.pinv(np.cov(hsi_data.T, rowvar = False)) if kwargs['sig_inv'] is None else kwargs['sig_inv']
+    mu = np.mean(hsi_data, axis = 1) if kwargs['mu'] is None else kwargs['mu']
+    sig_inv = np.linalg.pinv(np.cov(hsi_data.T, rowvar = False)) if kwargs['sig_inv'] is None else kwargs['sig_inv']
 
-	mu = np.reshape(mu, (len(mu), 1), order='F')
-	s = tgt_sig - mu
-	z = hsi_data - mu
+    mu = np.reshape(mu, (len(mu), 1), order='F')
+    s = tgt_sig - mu
+    z = hsi_data - mu
 
-	st_sig_inv = s.T @ sig_inv
-	st_sig_inv_s = s.T @ sig_inv @ s
+    st_sig_inv = s.T @ sig_inv
+    st_sig_inv_s = s.T @ sig_inv @ s
 
-	A = np.sum(st_sig_inv @ z, 0)
-	B = st_sig_inv_s
-	C = np.sum(z * (sig_inv @ z), 0)
+    A = np.sum(st_sig_inv @ z, 0)
+    B = st_sig_inv_s
+    C = np.sum(z * (sig_inv @ z), 0)
 
-	ace_data = A * A / (B * C)
+    ace_data = A * A / (B * C)
 
-	return ace_data.T.squeeze(), {'mu':mu, 'sig_inv': sig_inv}
+    return ace_data.T.squeeze(), {'mu':mu, 'sig_inv': sig_inv}

dim_reduction/dim_reduction_demo.py renamed to dim_reduction/demo_dim_reduction.py

@@ -27,6 +27,10 @@ def ace_local_detector(hsi_img, tgt_sig, mask = None, guard_win = 2, bg_win = 4,
 	mask = np.ones([n_row, n_col]) if mask is None else mask
 	reg = beta * np.eye(n_band)
 
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
+
 	out, kwargsout = rx_det(ace_local_helper, hsi_img, tgt_sig, mask = mask, guard_win = guard_win, bg_win = bg_win, reg = reg)
 	return out, kwargsout
 

signature_detectors/abd_detector.py

@@ -24,6 +24,9 @@ def ace_rt_detector(hsi_img, tgt_sig, mask = None, mu = None, sig_inv = None):
 	6/2/2018 - Edited by Alina Zare
 	11/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	ace_rt_out, kwargsout = img_det(ace_rt_helper, hsi_img, tgt_sig, mask, mu = mu, sig_inv = sig_inv)
 	return ace_rt_out, kwargsout['mu'], kwargsout['sig_inv']
 

signature_detectors/ace_detector.py

@@ -25,6 +25,9 @@ def ace_rt_max_detector(hsi_img, tgt_sig, mask = None, mu = None, sig_inv = None
 	6/2/2018 - Edited by Alina Zare
 	11/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	ace_rt_max_out, kwargsout = img_det(ace_rt_max_helper, hsi_img, tgt_sig, mask, mu = mu, sig_inv = sig_inv)
 	return ace_rt_max_out, kwargsout['mu'], kwargsout['sig_inv']
 

signature_detectors/ace_local_detector.py

@@ -20,6 +20,9 @@ def ace_ss_detector(hsi_img, tgt_sig, mask = None, mu = None, sig_inv = None):
 	6/2/2018 - Edited by Alina Zare
 	11/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	ace_ss_out, kwargsout = img_det(ace_ss_helper, hsi_img, tgt_sig, mask, mu = mu, sig_inv = sig_inv)
 	return ace_ss_out
 

signature_detectors/ace_rt_detector.py

@@ -28,6 +28,9 @@ def amsd_detector(hsi_img, tgt_sig, mask = None, n_dim_tgt = 1, n_dim_bg = 5):
 	6/02/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	amsd_out, kwargsout = img_det(amsd_helper, hsi_img, tgt_sig, mask, n_dim_tgt = n_dim_tgt, n_dim_bg = n_dim_bg)
 	return amsd_out
 

signature_detectors/ace_rt_max_detector.py

@@ -24,6 +24,9 @@ def ccmf_detector(hsi_img, tgt_sig, mask = None, n_comp = 5, gmm = None):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	ccmf_out, kwargsout = img_det(ccmf_helper, hsi_img, tgt_sig, mask, n_comp = n_comp, gmm = gmm)
 
 	return ccmf_out, kwargsout['gmm']

signature_detectors/ace_ss_detector.py

@@ -23,6 +23,8 @@ def cem_detector(hsi_img, tgt_sig, mask = None):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
 
 	cem_out, kwargsout = img_det(cem_helper, hsi_img, tgt_sig, mask)
 

signature_detectors/amsd_detector.py

@@ -19,6 +19,9 @@ def ctmf_detector(hsi_img, tgt_sig, n_cluster = 2):
 	6/02/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	n_row, n_col, n_band = hsi_img.shape
 	n_pixel = n_row * n_col
 

signature_detectors/ccmf_detector.py

@@ -0,0 +1,128 @@
+import sys
+from scipy.io import loadmat
+import matplotlib.pyplot as plt
+sys.path.append('../')
+sys.path.append('../util/')
+from signature_detectors import *
+from get_RGB import get_RGB
+from img_seg import img_seg
+from sklearn.cluster import KMeans
+"""
+Demo script that runs all signature detectors in hsi_toolkit_py
+
+Inputs:
+	hsi_sub - n_row x n_col x n_band hyperspectral image
+	tgt_spectra - n_band x 1 target signature vector
+	wavelengths - n_band x 1 vector listing wavelength values for hsi_sub in nm
+	gt_img_sub - n_row x n_col ground truths
+	mask - binary image limiting detector operation to pixels where mask is true
+	 	if not present or empty, no mask restrictions are used
+Outputs:
+	det_out - dictionary of RGB image, ground truth image, and detector outputs
+
+6/2/2018 - Alina Zare
+10/12/2018 - Python Implementation by Yutai Zhou
+"""
+# Load data
+an_hsi_img_for_tgt_det_demo = loadmat('an_hsi_img_for_tgt_det_demo.mat')
+hsi_sub = an_hsi_img_for_tgt_det_demo['hsi_sub']
+tgt_spectra = an_hsi_img_for_tgt_det_demo['tgt_spectra']
+tgt_spectra = tgt_spectra.squeeze()
+wavelengths = an_hsi_img_for_tgt_det_demo['wavelengths']
+gt_img_sub = an_hsi_img_for_tgt_det_demo['gtImg_sub']
+
+det_out = {}
+det_out['RGB'] = get_RGB(hsi_sub, wavelengths)
+det_out['Ground Truth'] = gt_img_sub
+
+# init detector args
+guard_win = 1; bg_win = 3; beta = 0.001; n_dim_ss = 10;
+ems = hsi_sub[:3,1,:].T # need to provide background endmembers (can get them using SPICE unmixing)
+
+# call detectors
+abd_out = abd_detector(hsi_sub, tgt_spectra, ems)
+det_out['ABD'] = abd_out
+ace_out, _, _ = ace_detector(hsi_sub, tgt_spectra)
+det_out['ACE Squared'] = ace_out
+ace_local_out, _ = ace_local_detector(hsi_sub, tgt_spectra, guard_win = guard_win, bg_win = bg_win, beta = beta)
+det_out['ACE Local Squared'] = ace_local_out
+ace_ss_out = ace_ss_detector(hsi_sub, tgt_spectra)
+det_out['ACE SS'] = ace_ss_out
+ace_rt_out, _, _ = ace_rt_detector(hsi_sub, tgt_spectra)
+det_out['ACE RT'] = ace_rt_out
+ace_rt_max_out, _, _ = ace_rt_max_detector(hsi_sub, tgt_spectra)
+det_out['ACE RT Max'] = ace_rt_max_out
+amsd_out= amsd_detector(hsi_sub, tgt_spectra, n_dim_tgt = 1, n_dim_bg = 3)
+det_out['AMSD'] = amsd_out
+ccmf_out, _ = ccmf_detector(hsi_sub, tgt_spectra, n_comp = 2)
+det_out['CCMF'] = ccmf_out
+cem_out, w = cem_detector(hsi_sub, tgt_spectra)
+det_out['CEM'] = cem_out
+ctmf_out, _ = ctmf_detector(hsi_sub, tgt_spectra, n_cluster = 2)
+det_out['CTMF'] = ctmf_out
+ftmf_out = ftmf_detector(hsi_sub, tgt_spectra, gamma = 1)
+det_out['FTMF'] = ftmf_out
+ha_out = ha_detector(hsi_sub, tgt_spectra, ems, n_comp = 2)
+det_out['HA'] = ha_out
+hsd_out, _ = hsd_detector(hsi_sub, tgt_spectra, ems)
+det_out['HSD'] = hsd_out
+hsd_local_out = hsd_local_detector(hsi_sub, tgt_spectra, ems, guard_win = guard_win, bg_win = bg_win, beta = beta)
+det_out['HSD Local'] = hsd_local_out
+hua_out = hua_detector(hsi_sub, tgt_spectra, ems, n_comp = 2)
+det_out['HUA'] = hua_out
+mtmf_out,_ = mtmf_statistic(hsi_sub, tgt_spectra)
+det_out['MTMF'] = mtmf_out
+smf_out, _, _ = smf_detector(hsi_sub, tgt_spectra)
+det_out['SMF'] = smf_out
+smf_local_out = smf_local_detector(hsi_sub, tgt_spectra, guard_win = guard_win, bg_win = bg_win)
+det_out['SMF Local'] = smf_local_out
+smf_max_out = smf_max_detector(hsi_sub, tgt_spectra)
+det_out['SMF Max'] = smf_max_out
+fam_statistic_out = fam_statistic(hsi_sub, tgt_spectra)
+det_out['FAM Statistic'] = fam_statistic_out
+osp_out = osp_detector(hsi_sub, tgt_spectra, n_dim_ss = 10)
+det_out['OSP'] = osp_out
+qmf_out = qmf_detector(hsi_sub, tgt_spectra, 0.1 * np.eye(hsi_sub.shape[2]))
+det_out['QMF'] = qmf_out
+sam_out = sam_detector(hsi_sub, tgt_spectra)
+det_out['SAM'] = sam_out
+spsmf_out = spsmf_detector(hsi_sub, tgt_spectra)
+det_out['SPSMF'] = spsmf_out
+palm_out = palm_detector(hsi_sub, tgt_spectra, n_comp = 5)
+det_out['PALM'] = palm_out
+
+
+# Segmented Detector Examples
+
+# # # get Segments (using K-means here, but better ways to do this in general, see context-dependent methods for detection)
+# n_cluster = 3
+# n_row, n_col, n_band = hsi_sub.shape
+# idx = KMeans(n_clusters = n_cluster, n_init = 1).fit(hsi_sub.reshape((n_row * n_col, n_band), order='F')).labels_
+# idx_img = idx.reshape((n_row,n_col), order='F')
+
+# segments = np.zeros((n_cluster,n_row,n_col))
+# for i in range(n_cluster):
+# 	segments[i,:,:] = idx_img == i
+
+# # Segmented Spectral Angle Mapper
+# seg_sam_out = img_seg(sam_detector,hsi_sub, tgt_spectra, segments)
+# det_out['Seg SAM'] = seg_sam_out
+
+# # Segmented Spectral Angle Mapper
+# seg_ace_out,_,_ = img_seg(ace_detector,hsi_sub, tgt_spectra, segments)
+# det_out['Seg ACE'] = seg_ace_out
+# plt.imshow(seg_ace_out)
+# plt.show()
+
+
+# # visualization
+plt.figure(figsize=(10, 15))
+plt.subplots_adjust(hspace=.5)
+n_row = 5; n_col = 7
+#
+i = 1
+for key, value in det_out.items():
+	plt.subplot(n_row, n_col, i);
+	plt.imshow(value); plt.title(key)
+	i += 1
+plt.show()

signature_detectors/cem_detector.py

@@ -16,6 +16,9 @@ def fam_statistic(hsi_img, tgt_sig, mu = None, sig_inv = None):
 	6/2/2018 - Edited by Alina Zare
 	11/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	# assume target variance same as background variance
 	n_row, n_col, n_band = hsi_img.shape
 	n_pixel = n_row * n_col

signature_detectors/ctmf_detector.py

@@ -19,6 +19,9 @@ def ftmf_detector(hsi_img, tgt_sig, gamma = 1):
 	 is a scaled version of bg variance
 	Eismann pp 681
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	n_row, n_col, n_band = hsi_img.shape
 	n_pixel = n_row * n_col
 

signature_detectors/demo_signature_det.py

@@ -24,6 +24,9 @@ def ha_detector(hsi_img, tgt_sig, ems, mask = None, n_comp = 2):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	ha_out, kwargsout = img_det(ha_helper, hsi_img, tgt_sig, mask, ems = ems, n_comp = n_comp)
 	return ha_out
 

signature_detectors/fam_statistic.py

@@ -30,6 +30,9 @@ def hsd_detector(hsi_img, tgt_sig, ems, mask = None, sig_inv = None):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	hsd_out, kwargsout = img_det(hsd_helper, hsi_img, tgt_sig, mask, ems = ems, sig_inv = sig_inv)
 	return hsd_out, kwargsout['tgt_p']
 

signature_detectors/ftmf_detector.py

@@ -24,6 +24,9 @@ def hsd_local_detector(hsi_img, tgt_sig, ems, mask = None, guard_win = 2, bg_win
 	6/3/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	n_row, n_col, n_band = hsi_img.shape
 	hsi_data = hsi_img.reshape((n_row * n_col, n_band), order='F').T
 

signature_detectors/ha_detector.py

@@ -30,6 +30,9 @@ def hua_detector(hsi_img, tgt_sig, ems, mask = None, n_comp = 2, sig_inv = None)
 	6/3/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	hua_out, kwargsout = img_det(hua_helper, hsi_img, tgt_sig, mask, ems = ems, n_comp = n_comp, sig_inv = sig_inv)
 	return hua_out
 

signature_detectors/hsd_detector.py

@@ -22,6 +22,9 @@ def mtmf_statistic(hsi_img,tgt_sig, mask = None):
 	8/12/2012 - Taylor C. Glenn - [email protected]
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	mnf_img, n_dim, mnf_vecs, mnf_eigvals, mnf_mu = mnf(hsi_img,1);
 	# tgt_sig = tgt_sig[:n_dim,0][:,np.newaxis]
 	s = mnf_vecs @ (tgt_sig - mnf_mu)

signature_detectors/hsd_local_detector.py

@@ -22,6 +22,9 @@ def osp_detector(hsi_img, tgt_sig, mask = None, n_dim_ss = 2):
 	6/2/2018 - Edited by Alina Zare
 	11/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	osp_out, kwargsout = img_det(osp_helper, hsi_img, tgt_sig, mask, n_dim_ss = n_dim_ss)
 
 	return osp_out

signature_detectors/hua_detector.py

@@ -22,6 +22,9 @@ def palm_detector(hsi_img, tgt_sig, mask = None, n_comp = 5):
 	6/2/2018 - Edited by Alina Zare
 	12/2018 - Python Implementation by Yutai Zhou
 	"""
+	if tgt_sig.ndim == 1:
+		tgt_sig = tgt_sig[:, np.newaxis]
+
 	palm_out, kwargsout = img_det(palm_helper, hsi_img, tgt_sig, mask, n_comp = n_comp)
 	return palm_out