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)
