def kmea(colorArray, iterations, fileName):
print 'Kmeans'
print colorArray
print iterations
print fileName
dataset = tifwork.openTIF(fileName)
(cols, rows, bands, bandArr) = tifwork.detailsTIF(dataset)
bandArr = tifwork.getBand(dataset, bands, bandArr)
imageArray = np.array(bandArr, dtype=float)
clusters = len(colorArray)
print 'clusters = ', clusters
#iterations = 3
(clusterNumber, colorArr) = kmeans(imageArray, clusters, iterations)
#print colorArray.shape
#print clusterNumber
clusteredArray = np.zeros((rows, cols, 3))
for i in range(clusters):
index = clusterNumber == i
clusteredArray[index] = colorArray[i]
scipy.misc.imsave('kMeans.jpg', clusteredArray)
imageGUI.imdisplay('kMeans.jpg', 'Kmeans-Image')
print 'kmeans done'
def kmeans(X,
max_clusters=10,
max_iterations=20,
distance='euclidean',
**kwargs):
# input processing ########################################################################
X, distance = _how_spectral_library_expects_data_and_distance(X, distance)
# do the clustering (call spectral.kmeans)
clus_idx, clus_centers = spectral.kmeans(X,
nclusters=max_clusters,
max_iterations=max_iterations,
distance=distance,
**kwargs)
return _how_I_like_clus_idx_and_clus_centers(clus_idx, clus_centers)
#Adjust (either zero-pad or cut) classification array to work with source raster
(cx, cy) = maskar.shape
if src_raster_num_bands > classification_images_num_bands:
zerar = np.zeros((cx, cy))
diff = src_raster_num_bands - classification_images_num_bands
for i in range(diff):
classar = np.dstack((classar, zerar))
#Create training class and model
trcls = sp.create_training_classes(classar, maskar)
gmlc = sp.GaussianClassifier(trcls)
mldc = sp.MahalanobisDistanceClassifier(trcls)
#Classify image and display results
(kclmap, c) = sp.kmeans(barall, 12, 30) #unsupervised
gclmap = gmlc.classify_image(barall) #supervised
mclmap = mldc.classify_image(barall) #supervised
#Define classification colors for array conversion
def num2colR(arg):
switcher = {
1: 255,
2: 0,
3: 255,
4: 255,
5: 255,
6: 0,
7: 0,
8: 0,
import matplotlib.pyplot as plt
import numpy as np
import spectral as spy
from scipy.io import loadmat
if __name__ == '__main__':
data = loadmat('Indian_pines_corrected.mat')
data = data['indian_pines_corrected']
gt = loadmat('Indian_pines_gt.mat')
gt = gt['indian_pines_gt']
ntopics = 17 # number of topics to generate
(kmeans_classes, c) = spy.kmeans(data, nclusters=ntopics, max_iterations=100)
kmeans_classes += 1
fig = plt.figure(figsize=(12,6))
p = plt.subplot(2, 1, 1)
v = spy.imshow(classes=gt, fignum=fig.number)
p.set_title('Ground Truth')
p = plt.subplot(2, 1, 2)
v = spy.imshow(classes=kmeans_classes , fignum=fig.number)
p.set_title('k-means classes');
plt.show(v)
def perform_kmeans_clustering(self, filePath):
img = open_image(filePath).load()
(self.kmeans_map, self.kmeans_clusters) = kmeans(img, self.numClusters, self.numIterations)
print 'Pixel Size: ',data_f.GetGeoTransform()[1],',',data_f.GetGeoTransform()[5]
#Create training class and model
tclass = sp.create_training_classes(tdata, tmask)
gmlc = sp.GaussianClassifier(tclass)
mldc = sp.MahalanobisDistanceClassifier(tclass)
# Read in data raster
data = np.zeros((data_f.RasterYSize, data_f.RasterXSize, data_nband))
for i in range(len(trefs)):
for j in range(data_nband):
data[:, :, j] = data_f.GetRasterBand(j+1).ReadAsArray()
#Classify image and display results
print("K-Means")
(kclmap,c) = sp.kmeans(data,kmeans_clusters,kmeans_iterations) #unsupervised
print("Gaussian")
gclmap = gmlc.classify_image(data) #supervised
print("Mahalanobis")
mclmap = mldc.classify_image(data) #supervised
#Define classification colors for array conversion
rlut = np.array([0, 255, 0, 255, 255, 255, 0, 0, 0, 100, 255, 255, 100])
glut = np.array([0, 255, 255, 0, 255, 0, 255, 0, 0, 255, 100, 255, 100])
blut = np.array([0, 255, 255, 255, 0, 0, 0, 255, 0, 255, 255, 100, 255])
#Convert kmeans array
print 'Kmeans Unsupervised Classification .tif Generation'
r = rlut[kclmap].astype('uint8')
g = glut[kclmap].astype('uint8')
b = blut[kclmap].astype('uint8')
folder = r"D:\osgeopy-data\Landsat\Utah"
raster_fns = ["LE70380322000181EDC02_60m.tif", "LE70380322000181EDC02_TIR_60m.tif"]
out_fn = "kmeans_prediction_60m.tif"
# Function from list 10.10.
def stack_bands(filenames):
"""Returns a 3D array containing all band data from all files."""
bands = []
for fn in raster_fns:
ds = gdal.Open(fn)
for i in range(1, ds.RasterCount + 1):
bands.append(ds.GetRasterBand(i).ReadAsArray())
return np.dstack(bands)
# Stack the bands and run the analysis.
os.chdir(folder)
data = pb.stack_bands(raster_fns)
classes, centers = spectral.kmeans(data)
# Save the output.
ds = gdal.Open(raster_fns[0])
out_ds = pb.make_raster(ds, out_fn, classes, gdal.GDT_Byte)
levels = pb.compute_overview_levels(out_ds.GetRasterBand(1))
out_ds.BuildOverviews("NEAREST", levels)
out_ds.FlushCache()
out_ds.GetRasterBand(1).ComputeStatistics(False)
del out_ds, ds
'LE70380322000181EDC02_60m.tif', 'LE70380322000181EDC02_TIR_60m.tif'
]
out_fn = 'kmeans_prediction_60m.tif'
# Function from list 10.10.
def stack_bands(filenames):
"""Returns a 3D array containing all band data from all files."""
bands = []
for fn in raster_fns:
ds = gdal.Open(fn)
for i in range(1, ds.RasterCount + 1):
bands.append(ds.GetRasterBand(i).ReadAsArray())
return np.dstack(bands)
# Stack the bands and run the analysis.
os.chdir(folder)
data = pb.stack_bands(raster_fns)
classes, centers = spectral.kmeans(data)
# Save the output.
ds = gdal.Open(raster_fns[0])
out_ds = pb.make_raster(ds, out_fn, classes, gdal.GDT_Byte)
levels = pb.compute_overview_levels(out_ds.GetRasterBand(1))
out_ds.BuildOverviews('NEAREST', levels)
out_ds.FlushCache()
out_ds.GetRasterBand(1).ComputeStatistics(False)
del out_ds, ds
)[5]
#Create training class and model
tclass = sp.create_training_classes(tdata, tmask)
gmlc = sp.GaussianClassifier(tclass)
mldc = sp.MahalanobisDistanceClassifier(tclass)
# Read in data raster
data = np.zeros((data_f.RasterYSize, data_f.RasterXSize, data_nband))
for i in range(len(trefs)):
for j in range(data_nband):
data[:, :, j] = data_f.GetRasterBand(j + 1).ReadAsArray()
#Classify image and display results
print("K-Means")
(kclmap, c) = sp.kmeans(data, kmeans_clusters,
kmeans_iterations) #unsupervised
print("Gaussian")
gclmap = gmlc.classify_image(data) #supervised
print("Mahalanobis")
mclmap = mldc.classify_image(data) #supervised
#Define classification colors for array conversion
rlut = np.array([0, 255, 0, 255, 255, 255, 0, 0, 0, 100, 255, 255, 100])
glut = np.array([0, 255, 255, 0, 255, 0, 255, 0, 0, 255, 100, 255, 100])
blut = np.array([0, 255, 255, 255, 0, 0, 0, 255, 0, 255, 255, 100, 255])
#Convert kmeans array
print 'Kmeans Unsupervised Classification .tif Generation'
r = rlut[kclmap].astype('uint8')
g = glut[kclmap].astype('uint8')
b = blut[kclmap].astype('uint8')
def kmeans_spy(img):
time1 = timer()
(m, n) = spy.kmeans(img, 3, 10) # spectral /spy (data, clusters, iters)
time2 = timer()
print('kmeans time: ', time2 - time1)
return m
import matplotlib.pyplot as plt
import numpy as np
import spectral
from task_2c import atmospheric_correction
from task_2b import OBPG_algorithm
# vegetation: [417, 137]
# ocean : [20, 20]
HICO_original, HICO_noisy, hico_wl, seawater_Rs = get_info('data/HICO.mat')
land_mask = plt.imread('data/land_mask.png')[:, :, 0] == 0
deep_water_Rrs = np.loadtxt('data/deep_water_Rrs.txt')
shallow_water_Rrs = np.loadtxt('data/shallow_water_Rrs.txt')
valid_bands_Rrs = np.loadtxt('data/valid_bands_Rrs.txt')
(m, c) = spectral.kmeans(HICO_original, 6, 30)
I = pseudo_RGB_img(HICO_original, hico_wl)
land = np.empty_like(land_mask)
for i in range(m.shape[0]):
for j in range(m.shape[1]):
if m[i][j] != 0:
land[i][j] = True
else:
land[i][j] = False
I[land] = 0
plt.imshow(I)
# Plot a RGB pseudo img