def main(): usage = ''' Usage: ------------------------------------------------ RX anomaly detection for multi- and hyperspectral images python %s [OPTIONS] filename Options: -h this help -------------------------------------------------''' % sys.argv[0] options, args = getopt.getopt(sys.argv[1:], 'h') for option, value in options: if option == '-h': print usage return gdal.AllRegister() infile = args[0] path = os.path.dirname(infile) basename = os.path.basename(infile) root, ext = os.path.splitext(basename) outfile = path + '/' + root + '_rx' + ext print '------------ RX ---------------' print time.asctime() print 'Input %s' % infile start = time.time() # input image, convert to ENVI format inDataset = gdal.Open(infile, GA_ReadOnly) cols = inDataset.RasterXSize rows = inDataset.RasterYSize projection = inDataset.GetProjection() geotransform = inDataset.GetGeoTransform() driver = gdal.GetDriverByName('ENVI') enviDataset = driver.CreateCopy('imagery/entmp', inDataset) inDataset = None enviDataset = None # RX-algorithm img = envi.open('imagery/entmp.hdr') arr = img.load() rx = RX(background=calc_stats(arr)) res = rx(arr) # output driver = gdal.GetDriverByName('GTiff') outDataset = driver.Create(outfile,cols,rows,1,\ GDT_Float32) if geotransform is not None: outDataset.SetGeoTransform(geotransform) if projection is not None: outDataset.SetProjection(projection) outBand = outDataset.GetRasterBand(1) outBand.WriteArray(np.asarray(res, np.float32), 0, 0) outBand.FlushCache() outDataset = None os.remove('imagery/entmp') os.remove('imagery/entmp.hdr') print 'Result written to %s' % outfile print 'elapsed time: %s' % str(time.time() - start)
def __call__(self, X): '''Compute ACE detector scores for X. Arguments: `X` (numpy.ndarray): For an image with shape (R, C, B), `X` can be a vector of length B (single pixel) or an ndarray of shape (R, C, B) or (R * C, B). Returns numpy.ndarray or float: The return value will be the RX detector score (squared Mahalanobis distance) for each pixel given. If `X` is a single pixel, a float will be returned; otherwise, the return value will be an ndarray of floats with one less dimension than the input. ''' from spectral.algorithms.algorithms import calc_stats if not isinstance(X, np.ndarray): raise TypeError('Expected a numpy.ndarray.') shape = X.shape if X.ndim == 1: # Compute ACE score for single pixel if self._background.mean is not None: X = X - self._background.mean z = self._background.sqrt_inv_cov.dot(X) return z.dot(self._P).dot(z) / (z.dot(z)) if self._background is None: self.set_background(calc_stats(X)) if self.vectorize: # Compute all scores at once if self._background.mean is not None: X = X - self._background.mean if X.ndim == 3: X = X.reshape((-1, X.shape[-1])) z = self._background.sqrt_inv_cov.dot(X.T).T zP = np.dot(z, self._P) zPz = np.einsum('ij,ij->i', zP, z) zz = np.einsum('ij,ij->i', z, z) return (zPz / zz).reshape(shape[:-1]) else: # Call recursively for each pixel return np.apply_along_axis(self, -1, X)
def main(): gdal.AllRegister() path = auxil.select_directory('Input directory') if path: os.chdir(path) # input image, convert to ENVI format infile = auxil.select_infile(title='Image file') if infile: inDataset = gdal.Open(infile, GA_ReadOnly) cols = inDataset.RasterXSize rows = inDataset.RasterYSize projection = inDataset.GetProjection() geotransform = inDataset.GetGeoTransform() driver = gdal.GetDriverByName('ENVI') enviDataset=driver\ .CreateCopy('entmp',inDataset) inDataset = None enviDataset = None else: return outfile, outfmt= \ auxil.select_outfilefmt(title='Output file') # RX-algorithm img = envi.open('entmp.hdr') arr = img.load() rx = RX(background=calc_stats(arr)) res = rx(arr) # output driver = gdal.GetDriverByName(outfmt) outDataset = driver.Create(outfile,cols,rows,1,\ GDT_Float32) if geotransform is not None: outDataset.SetGeoTransform(geotransform) if projection is not None: outDataset.SetProjection(projection) outBand = outDataset.GetRasterBand(1) outBand.WriteArray(np.asarray(res, np.float32), 0, 0) outBand.FlushCache() outDataset = None print 'Result written to %s' % outfile
def __call__(self, X): '''Applies the RX anomaly detector to X. Arguments: `X` (numpy.ndarray): For an image with shape (R, C, B), `X` can be a vector of length B (single pixel) or an ndarray of shape (R, C, B) or (R * C, B). Returns numpy.ndarray or float: The return value will be the RX detector score (squared Mahalanobis distance) for each pixel given. If `X` is a single pixel, a float will be returned; otherwise, the return value will be an ndarray of floats with one less dimension than the input. ''' from spectral.algorithms.algorithms import calc_stats if not isinstance(X, np.ndarray): raise TypeError('Expected a numpy.ndarray.') if self.background is None: self.set_background(calc_stats(X)) X = (X - self.background.mean) C_1 = self.background.inv_cov ndim = X.ndim shape = X.shape if ndim == 1: return X.dot(C_1).dot(X) if ndim == 3: X = X.reshape((-1, X.shape[-1])) A = X.dot(C_1) r = np.einsum('ij,ij->i', A, X) return r.reshape(shape[:-1])
def main(): gdal.AllRegister() path = auxil.select_directory("Input directory") if path: os.chdir(path) # input image, convert to ENVI format infile = auxil.select_infile(title="Image file") if infile: inDataset = gdal.Open(infile, GA_ReadOnly) cols = inDataset.RasterXSize rows = inDataset.RasterYSize projection = inDataset.GetProjection() geotransform = inDataset.GetGeoTransform() driver = gdal.GetDriverByName("ENVI") enviDataset = driver.CreateCopy("entmp", inDataset) inDataset = None enviDataset = None else: return outfile, outfmt = auxil.select_outfilefmt(title="Output file") # RX-algorithm img = envi.open("entmp.hdr") arr = img.load() rx = RX(background=calc_stats(arr)) res = rx(arr) # output driver = gdal.GetDriverByName(outfmt) outDataset = driver.Create(outfile, cols, rows, 1, GDT_Float32) if geotransform is not None: outDataset.SetGeoTransform(geotransform) if projection is not None: outDataset.SetProjection(projection) outBand = outDataset.GetRasterBand(1) outBand.WriteArray(np.asarray(res, np.float32), 0, 0) outBand.FlushCache() outDataset = None print "Result written to %s" % outfile
def matched_filter(X, target, background=None, window=None, cov=None): r'''Computes a linear matched filter target detector score. Usage: y = matched_filter(X, target, background) y = matched_filter(X, target, window=<win> [, cov=<cov>]) Given target/background means and a common covariance matrix, the matched filter response is given by: .. math:: y=\frac{(\mu_t-\mu_b)^T\Sigma^{-1}(x-\mu_b)}{(\mu_t-\mu_b)^T\Sigma^{-1}(\mu_t-\mu_b)} where :math:`\mu_t` is the target mean, :math:`\mu_b` is the background mean, and :math:`\Sigma` is the covariance. Arguments: `X` (numpy.ndarray): For the first calling method shown, `X` can be an image with shape (R, C, B) or an ndarray of shape (R * C, B). If the `background` keyword is given, it will be used for the image background statistics; otherwise, background statistics will be computed from `X`. If the `window` keyword is given, `X` must be a 3-dimensional array and background statistics will be computed for each point in the image using a local window defined by the keyword. `target` (ndarray): Length-K vector specifying the target to be detected. `background` (`GaussianStats`): The Gaussian statistics for the background (e.g., the result of calling :func:`calc_stats` for an image). This argument is not required if `window` is given. `window` (2-tuple of odd integers): Must have the form (`inner`, `outer`), where the two values specify the widths (in pixels) of inner and outer windows centered about the pixel being evaulated. Both values must be odd integers. The background mean and covariance will be estimated from pixels in the outer window, excluding pixels within the inner window. For example, if (`inner`, `outer`) = (5, 21), then the number of pixels used to estimate background statistics will be :math:`21^2 - 5^2 = 416`. If this argument is given, `background` is not required (and will be ignored, if given). The window is modified near image borders, where full, centered windows cannot be created. The outer window will be shifted, as needed, to ensure that the outer window still has height and width `outer` (in this situation, the pixel being evaluated will not be at the center of the outer window). The inner window will be clipped, as needed, near image borders. For example, assume an image with 145 rows and columns. If the window used is (5, 21), then for the image pixel at (0, 0) (upper left corner), the the inner window will cover `image[:3, :3]` and the outer window will cover `image[:21, :21]`. For the pixel at (50, 1), the inner window will cover `image[48:53, :4]` and the outer window will cover `image[40:51, :21]`. `cov` (ndarray): An optional covariance to use. If this parameter is given, `cov` will be used for all matched filter calculations (background covariance will not be recomputed in each window) and only the background mean will be recomputed in each window. If the `window` argument is specified, providing `cov` will allow the result to be computed *much* faster. Returns numpy.ndarray: The return value will be the matched filter scores distance) for each pixel given. If `X` has shape (R, C, K), the returned ndarray will have shape (R, C). ''' if background is not None and window is not None: raise ValueError('`background` and `window` are mutually ' \ 'exclusive arguments.') if window is not None: from .spatial import map_outer_window_stats def mf_wrapper(bg, x): return MatchedFilter(bg, target)(x) return map_outer_window_stats(mf_wrapper, X, window[0], window[1], dim_out=1, cov=cov) else: from spectral.algorithms.algorithms import calc_stats if background is None: background = calc_stats(X) return MatchedFilter(background, target)(X)
def matched_filter(X, target, background=None, window=None, cov=None): r'''Computes a linear matched filter target detector score. Usage: y = matched_filter(X, target, background) y = matched_filter(X, target, window=<win> [, cov=<cov>]) Given target/background means and a common covariance matrix, the matched filter response is given by: .. math:: y=\frac{(\mu_t-\mu_b)^T\Sigma^{-1}(x-\mu_b)}{(\mu_t-\mu_b)^T\Sigma^{-1}(\mu_t-\mu_b)} where :math:`\mu_t` is the target mean, :math:`\mu_b` is the background mean, and :math:`\Sigma` is the covariance. Arguments: `X` (numpy.ndarray): For the first calling method shown, `X` can be an image with shape (R, C, B) or an ndarray of shape (R * C, B). If the `background` keyword is given, it will be used for the image background statistics; otherwise, background statistics will be computed from `X`. If the `window` keyword is given, `X` must be a 3-dimensional array and background statistics will be computed for each point in the image using a local window defined by the keyword. `target` (ndarray): Length-K vector specifying the target to be detected. `background` (`GaussianStats`): The Gaussian statistics for the background (e.g., the result of calling :func:`calc_stats` for an image). This argument is not required if `window` is given. `window` (2-tuple of odd integers): Must have the form (`inner`, `outer`), where the two values specify the widths (in pixels) of inner and outer windows centered about the pixel being evaulated. Both values must be odd integers. The background mean and covariance will be estimated from pixels in the outer window, excluding pixels within the inner window. For example, if (`inner`, `outer`) = (5, 21), then the number of pixels used to estimate background statistics will be :math:`21^2 - 5^2 = 416`. If this argument is given, `background` is not required (and will be ignored, if given). The window is modified near image borders, where full, centered windows cannot be created. The outer window will be shifted, as needed, to ensure that the outer window still has height and width `outer` (in this situation, the pixel being evaluated will not be at the center of the outer window). The inner window will be clipped, as needed, near image borders. For example, assume an image with 145 rows and columns. If the window used is (5, 21), then for the image pixel at (0, 0) (upper left corner), the the inner window will cover `image[:3, :3]` and the outer window will cover `image[:21, :21]`. For the pixel at (50, 1), the inner window will cover `image[48:53, :4]` and the outer window will cover `image[40:51, :21]`. `cov` (ndarray): An optional covariance to use. If this parameter is given, `cov` will be used for all matched filter calculations (background covariance will not be recomputed in each window). Only the background mean will be recomputed in each window). If the `window` argument is specified, providing `cov` will allow the result to be computed *much* faster. Returns numpy.ndarray: The return value will be the matched filter scores distance) for each pixel given. If `X` has shape (R, C, K), the returned ndarray will have shape (R, C). ''' if background is not None and window is not None: raise ValueError('`background` and `window` are mutually ' \ 'exclusive arguments.') if window is not None: from .spatial import map_outer_window_stats def mf_wrapper(bg, x): return MatchedFilter(bg, target)(x) return map_outer_window_stats(mf_wrapper, X, window[0], window[1], dim_out=1, cov=cov) else: from spectral.algorithms.algorithms import calc_stats if background is None: background = calc_stats(X) return MatchedFilter(background, target)(X)