def pcaRaster(raster): # Open up raster image and load into an n dimensional array where n is number of bands image = gdal.Open(raster) data = np.zeros((image.RasterYSize, image.RasterXSize, image.RasterCount), gdal_array.GDALTypeCodeToNumericTypeCode( image.GetRasterBand(1).DataType)) for b in range(data.shape[2]): data[:, :, b] = image.GetRasterBand(b + 1).ReadAsArray() # Load nd-array into PCA class object pca = principal_components(data) # Print eigenvalues eigenvalues = pca.eigenvalues print eigenvalues # Reduce data array to where 99% of data variance is explained pcdata = pca.reduce(fraction=.99).transform(data) # Save data array into a GTiff raster rasterout = raster.split('.')[0] + '_PCAReduced.TIF' array2raster(pcdata, image, rasterout) return pcdata
def test_gmlc_classify_transformedimage_runs(self): '''Tests that GaussianClassifier classifies a TransformedImage object.''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.GaussianClassifier(ts) ret = gmlc.classify_image(ximg)
def test_mahalanobis_classify_transformedimage_runs(self): '''Mahalanobis classifier works with a TransformedImage object.''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.MahalanobisDistanceClassifier(ts) ret = gmlc.classify_image(ximg)
def test_gmlc_classify_transformedimage_runs(self): '''Tests that GaussianClassifier classifies a TransformedImage object.''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.GaussianClassifier(ts) ret = gmlc.classify_image(ximg)
def test_mahalanobis_classify_transformedimage_runs(self): '''Mahalanobis classifier works with a TransformedImage object.''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.MahalanobisDistanceClassifier(ts) ret = gmlc.classify_image(ximg)
def test_gmlc_classify_ndarray_transformedimage_equal(self): '''Gaussian classification of an ndarray and TransformedImage are equal''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.GaussianClassifier(ts) cl_ximg = gmlc.classify_image(ximg) cl_ndarray = gmlc.classify_image(pc.transform(self.data)) assert(np.all(cl_ximg == cl_ndarray))
def test_gmlc_classify_ndarray_transformedimage_equal(self): '''Gaussian classification of an ndarray and TransformedImage are equal''' pc = spy.principal_components(self.data).reduce(num=3) ximg = pc.transform(self.image) ts = spy.create_training_classes(pc.transform(self.data), self.gt, calc_stats=True) gmlc = spy.GaussianClassifier(ts) cl_ximg = gmlc.classify_image(ximg) cl_ndarray = gmlc.classify_image(pc.transform(self.data)) assert (np.all(cl_ximg == cl_ndarray))
def _fetch_pca(self, image_path): t1 = time.time() #print("Fetching file : "+ file_name) img = open_image(image_path) nbands = img.nbands pc = principal_components(img) t2 = time.time() - t1 print('\nTook {:.4f} seconds / {:.4f} min to run.\n'.format( t2, t2 / 60)) return nbands, pc
def _fetch_pca(self, image_path): """Function calculates the eigen vectors and eigen values for given image :param image_path: Image to perfrom PCA :return: number of bands and PCA statistics """ print("Fetching file : "+ image_path) t1 = time.time() img = open_image(image_path) # open image using spectral nbands = img.nbands pc = principal_components(img) t2 = time.time() - t1 print('\nTook {:.4f} seconds / {:.4f} min to run.\n'.format(t2,t2/60)) return nbands, pc
def getPca(cube): # compute pca and display covariance matrix pc = spectral.principal_components(cube) plt.imshow(pc.cov) plt.show() # retain minimum of 99.9% of total image variance. pc_0999 = pc.reduce(fraction=0.999) print(len(pc_0999.eigenvalues)) # display 66 bands as 3 pcs cube_pc = pc_0999.transform(cube) plt.imshow(cube_pc[:, :, :3]) plt.show() return pc_0999
def prepare_data(self, img_path, gt_path): if img_path[-3:] == 'mat': import scipy.io as sio img_mat = sio.loadmat(img_path) gt_mat = sio.loadmat(gt_path) img_keys = img_mat.keys() gt_keys = gt_mat.keys() img_key = [k for k in img_keys if k != '__version__' and k != '__header__' and k != '__globals__'] gt_key = [k for k in gt_keys if k != '__version__' and k != '__header__' and k != '__globals__'] return img_mat.get(img_key[0]).astype('float64'), gt_mat.get(gt_key[0]).astype('int8') else: import spectral as spy img = spy.open_image(img_path).load() gt = spy.open_image(gt_path) a = spy.principal_components() a.transform() return img, gt.read_band(0)
def generatePrincipalComponentProducts(self, dataset, out_path): """ Placeholder """ # create product path product_path = os.path.join(out_path, 'pca') if not os.path.exists(product_path): os.makedirs(product_path, 0o755) # get channel images pertaining to product print('Creating principal component products: {}'.format(product_path)) for product in self._products['pca']: channels = [] for index in product['channels']: channels.append(self.getChannelData(dataset, index)) img = np.dstack(channels) # compute pca transformation pc = principal_components(img) img_pc = pc.transform(img) # save rgb image rgb_pathname = os.path.join(product_path, product['name'] + '.jpg') save_rgb(rgb_pathname, img_pc[:, :, :3], stretch=(0.05, 0.95)) # save decorrelation stretch version of rgb image dcs_pathname = rgb_pathname.replace('.jpg', '-dcs.jpg') execute( os.path.join(os.path.dirname(sys.path[0]), '../bin/dstretch'), [rgb_pathname, dcs_pathname]) # copy dcs image into geotiff self.writeGeoImage(dcs_pathname, dataset['srs']) return
def pca_fit(x): return principal_components(x)
def setup(self): import spectral as spy self.data = spy.open_image('92AV3C.lan').open_memmap() self.pc = spy.principal_components(self.data)
def test_pca_runs_from_stats(self): '''Should be able to pass image stats to PCA function.''' data = self.data stats = spy.calc_stats(data) xdata = spy.principal_components(stats).transform(data)
def test_pca_runs(self): '''Should be able to compute PCs and transform data.''' data = self.data xdata = spy.principal_components(data).transform(data)
def test_pca_runs_from_stats(self): '''Should be able to pass image stats to PCA function.''' data = self.data stats = spy.calc_stats(data) xdata = spy.principal_components(stats).transform(data)
def test_pca_runs(self): '''Should be able to compute PCs and transform data.''' data = self.data xdata = spy.principal_components(data).transform(data)
def setup(self): self.data = spy.open_image('92AV3C.lan').open_memmap() self.pc = spy.principal_components(self.data)