def __load_qb_data(self):
# sensor filter
sensor_filter = envi.open(
resource_filename(
sbc.__name__,
"tests/data/sensor_filters/qbtest_filter_350_900nm.hdr"),
resource_filename(
sbc.__name__,
"tests/data/sensor_filters/qbtest_filter_350_900nm.lib"),
).spectra
# input spectra
input_spectra = envi.open(
resource_filename(sbc.__name__,
"tests/data/qbtest_input_spectra.hdr"),
resource_filename(sbc.__name__,
"tests/data/qbtest_input_spectra.lib"),
).spectra[0]
# output spectra
output_spectra = envi.open(
resource_filename(sbc.__name__,
"tests/data/qbtest_output_spectra.hdr"),
resource_filename(sbc.__name__,
"tests/data/qbtest_output_spectra.lib"),
).spectra[0]
return sensor_filter, input_spectra, output_spectra
def read_hyper_data(path, folder_name):
"""
Read hyperspectral data in ENVI fromat.
:param path: the path containing the folders of the data.
:param folder_name: the name of the data folder.
:return: {'white:', hypercube_of_white, 'dark:', hypercube_of_dark, 'plant:', hypercube_of_object}, meta_of_plant\
Author: Huajian liu
version: v0 (10 May, 2018)
"""
import spectral.io.envi as envi
spectral.settings.envi_support_nonlowercase_params = True
# Reading data
meta_white = envi.open(
path + '/' + folder_name + '/' + 'capture' + '/' + 'WHITEREF_' +
folder_name + '.hdr', path + '/' + folder_name + '/' + 'capture' +
'/' + 'WHITEREF_' + folder_name + '.raw')
meta_dark = envi.open(
path + '/' + folder_name + '/' + 'capture' + '/' + 'DARKREF_' +
folder_name + '.hdr', path + '/' + folder_name + '/' + 'capture' +
'/' + 'DARKREF_' + folder_name + '.raw')
meta_plant = envi.open(
path + '/' + folder_name + '/' + 'capture' + '/' + folder_name +
'.hdr', path + '/' + folder_name + '/' + 'capture' + '/' +
folder_name + '.raw')
return {
'white': meta_white.load(),
'dark': meta_dark.load(),
'plant': meta_plant.load()
}, meta_plant
def crism_CreateModeledImage(self, abImgName, saveImg=0, targetFolder=''):
"""
@function name :crism_CreateModeledImage
@description :This function will be used to created modeled image from the constituents generated
using the UMass Pipeline
----------------------------------------------------------------------------------------------------------------
INPUTS
----------------------------------------------------------------------------------------------------------------
:param self:
:param abImgName: Name/address of the absoprtion image generated by the UMass Pipeline
:param saveImg: Flag to decide if the modeled image is to be saved. The image is saved if the flag is not 0.
(default = 0)
----------------------------------------------------------------------------------------------------------------
OUTPUTS
----------------------------------------------------------------------------------------------------------------
:return: msImg: The image modeled by the UMass pipeline
"""
'The absorption image header is'
abHdrName = abImgName.replace('.img', '.hdr')
'Read in the background image'
abImg = envi.open(abHdrName, abImgName)
abCube = abImg.load()
abHeader = envi.read_envi_header(abHdrName)
'The background image name is'
bgImgName = abImgName.replace('_AB.img', '_Bg.img')
bgHdrName = bgImgName.replace('.img', '.hdr')
bgImg = envi.open(bgHdrName, bgImgName)
bgCube = bgImg.load()
'The modeled image is'
msCube = abCube * bgCube
if (saveImg != 0):
finalLoc = abImgName.rfind('/')
imgName = abImgName[(finalLoc + 1):]
imgName = imgName.replace('_AB.img', '_MS.hdr')
if targetFolder:
if not os.path.isdir(targetFolder):
os.makedirs(targetFolder)
imgName = targetFolder + imgName
else:
localFolder = os.getcwd() + '/out'
if not os.path.isdir(localFolder):
os.makedirs(localFolder)
imgName = localFolder + imgName
'Save the image'
envi.save_image(imgName,
msCube,
dtype=np.float32,
force=True,
interleave='bil',
metadata=abHeader)
return imgName.replace('.hdr', '.img')
else:
str = 'Completed'
return str
def remap(inputfile, labels, outputfile, flag, chunksize):
"""."""
ref_file = inputfile
lbl_file = labels
out_file = outputfile
nchunk = chunksize
ref_img = envi.open(ref_file + '.hdr', ref_file)
ref_meta = ref_img.metadata
ref_mm = ref_img.open_memmap(interleave='source', writable=False)
ref = np.array(ref_mm[:, :])
lbl_img = envi.open(lbl_file + '.hdr', lbl_file)
lbl_meta = lbl_img.metadata
labels = lbl_img.read_band(0)
nl = int(lbl_meta['lines'])
ns = int(lbl_meta['samples'])
nb = int(ref_meta['bands'])
out_meta = dict([(k, v) for k, v in ref_meta.items()])
out_meta["samples"] = ns
out_meta["bands"] = nb
out_meta["lines"] = nl
out_meta['data type'] = ref_meta['data type']
out_meta["interleave"] = "bil"
out_img = envi.create_image(out_file + '.hdr',
metadata=out_meta,
ext='',
force=True)
out_mm = out_img.open_memmap(interleave='source', writable=True)
# Iterate through image "chunks," restoring as we go
for lstart in np.arange(0, nl, nchunk):
print(lstart)
del out_mm
out_mm = out_img.open_memmap(interleave='source', writable=True)
# Which labels will we extract? ignore zero index
lend = min(lstart + nchunk, nl)
lbl = labels[lstart:lend, :]
out = flag * np.ones((lbl.shape[0], nb, lbl.shape[1]))
for row in range(lbl.shape[0]):
for col in range(lbl.shape[1]):
out[row, :, col] = np.squeeze(ref[int(lbl[row, col]), :])
out_mm[lstart:lend, :, :] = out
def open_file():
open_file.has_been_called = True
filedialog.askopenfilename.has_been_called = True
file_name = filedialog.askopenfilename(initialdir=os.path.expanduser("/"),
filetypes=(("ENVI", "*.envi"),
("All files", "*")))
if str(file_name).endswith(".envi"):
img = envi.open(file_name + ".hdr", file_name + ".envi")
else:
img = envi.open(file_name + ".hdr", file_name)
file_save = file_name.split('/')
file_save = file_save[:-1]
save_dir = ""
for string in file_save:
save_dir = save_dir + string + "/"
print(save_dir)
filedialog.askopenfilename.has_been_called = False
imshow.has_been_called = True
imshow(img, bands=(55, 32, 20), aspect=0.45, stretch=0.25)
print(img)
print(file_name)
noisy_bands_info = hy.noise_removal(file_name,
min_threshold=0,
max_threshold=0.55)
noisy_bands_info.reflectance_plot()
print("--------- List of noisy bands ---------")
x = noisy_bands_info.show_noisy_bands_with_min_max()
print(len(x))
for values in x:
print(values)
nb = noisy_bands_info.show_noisy_bands()
pre = hy.preprocessing(img_path=file_name.split(".")[0] + ".hdr",
save_directory=save_dir,
available_memory_gb=8)
pre.perform(ndvi_threshold=125,
data_ignore_value=-9999.0,
NIR=90,
RED=55,
min_threshold=0,
max_threshold=0.55,
noisy_bands=nb)
file2_header = file_name + "_part_1"
pre_image = envi.open(file2_header + ".hdr", file2_header)
imshow(pre_image, bands=(55, 32, 20), aspect=0.45, stretch=0.25)
imshow.has_been_called = True
print(pre_image)
if imshow.has_been_called == False and filedialog.askopenfilename.has_been_called == False:
open_file.has_been_called = False
def crism_fillNanRows(self, imgName):
"""
This function fill the empty of NaN rows using the neighbors.
:param imgName: Name/address of the image to be smoothed
:return:
"""
hdrName = imgName.replace('.img', '.hdr')
header = envi.read_envi_header(hdrName)
'Read in the background image'
crImg = envi.open(hdrName, imgName)
crCube = crImg.load()
[rows, cols, bands] = crCube.shape
arrCrImg = crCube.reshape((rows * cols, bands))
arrCrImgCrop = arrCrImg[:, self.strtBand:self.stopBand]
'Fill the NaNs in the columns'
arrCrImgCrop = generalUtilities().fill_nan(arrCrImgCrop)
'Fill the NaNs in the rows'
arrCrImgCrop = generalUtilities().fill_nan(arrCrImgCrop.T)
arrCrImg[:, self.strtBand:self.stopBand] = arrCrImgCrop.T
'Reshape to image size'
crCube_nr = arrCrImg.reshape((rows, cols, bands))
'Save the background image'
outFileName1 = imgName.replace('_MS_CR.img', '_MS_CRnR.hdr')
envi.save_image(outFileName1,
crCube_nr,
dtype='single',
force=True,
interleave='bil',
metadata=header)
return outFileName1.replace('.hdr', '.img')
def train(self, threshold, path):
filenames = [join(path, name) for name in os.listdir(path)]
centroids = np.zeros((0, self.input_dim))
for filename in filenames:
if filename.find(".lan") > 0:
img = open_image(filename)
elif filename.find(".hdr") > 0:
img = envi.open(filename)
elif filename.find(".mat") > 0:
img_mat = loadmat(filename)
for i in img_mat:
img = img_mat[i]
# cv2 dodaj dla rgb
else:
continue
if img.shape[2] != self.input_dim:
continue
for i in self.generator_image(img.shape[0], img.shape[1]):
input_vec = self.create_input_vec(img, i)
if (np.min(np.linalg.norm(input_vec - centroids[range(centroids.shape[0])])) > threshold):
np.append(centroids, input_vec)
for iter in range(self._learn_iterations):
if (iter%10000 == 0):
print("Training: " + str(100.0 * iter//self._learn_iterations) + "%")
for input_vec in centroids:
self._sess.run(self._training_op, feed_dict={self._input_vec: input_vec, self._learning_iteration: iter})
np.random.shuffle(centroids)
print("training done")
def getdatesimage(dt):
print 'Getting %s'%dt
for (dirpath, dirnames, filenames) in walk('../londiani/%s'%dt):
filenames = sorted(filenames)
im = []
for f in filenames:
#print f
if f[-3:] =='hdr':
img = envi.open('../londiani/%s/%s'%(dt,f))
l = img.load()
m = img.open_memmap()
im.append(m)
i = im
#print len(im)
if len(im) == 7:
big = np.dstack((im[0],im[1],im[2],im[3],im[4],im[5],im[6]))
if len(im) == 6:
big = np.dstack((im[0],im[1],im[2],im[3],im[4],im[5]))
if len(im) == 5:
big = np.dstack((im[0],im[1],im[2],im[3],im[4]))
if len(im) == 4:
big = np.dstack((im[0],im[1],im[2],im[3]))
return big
def load_raw_cube(hdr_file):
data = envi.open(hdr_file).asarray()
data = data.astype(float)
metadata = _read_metadata(hdr_file)
cube = RawCube(data, metadata)
return cube
def load_urban_dataset():
envi_data = envi.open('../data/real/urban/urban.hdr')
img = envi_data[:, :, :]
hsi_path = '../data/real/urban/urban.mat'
ground_truth_path = '../data/real/urban/urban.gt'
hsi = sio.loadmat(hsi_path)
Y = hsi['Y'][:, :]
ground_truth = sio.loadmat(ground_truth_path)['M']
endmembers_names = [
'Asphalt Road', 'Grass', 'Tree', 'Roof', 'Metal', 'Dirt'
]
number_rows = hsi['nRow'][0][0]
number_columns = hsi['nCol'][0][0]
number_pixels = int(number_rows) * int(number_columns)
number_endmembers = ground_truth.shape[1]
number_bands = Y.shape[0]
dimensions = [number_rows, number_columns, number_bands, number_pixels]
selected_bands = hsi['SlectBands'].T[0]
null_bands = list(
set(list(range(0, len(ground_truth)))) - set(selected_bands))
ground_truth_plot = ground_truth.copy()
ground_truth_plot[null_bands, :] = None
bandsSelection = [selected_bands, null_bands]
dimensions_plot = [2, 3]
ground_truth = normalize_data(ground_truth)
return Y, img, dimensions, number_endmembers, ground_truth, ground_truth_plot, endmembers_names, dimensions_plot, bandsSelection, 'Urban'
def load_S3_image(image_path):
"""
load S3 image downloaded with SNAP, applies conversion to TOA and compute ratios
:param image_path: path to .data/ dir
:return: 3D np.array with the image bands sorted in BAND_NAMES_S3_RATIOS order
"""
inputs = [os.path.join(image_path,"Oa%s_reflectance.hdr"%b) for b in BAND_NAMES_S3]
images = []
for ip in inputs:
metadata = envi.read_envi_header(ip)
gain = np.array([float(m) for m in metadata['data gain values']])
offset = np.array([float(m) for m in metadata['data offset values']])
img = np.float64(envi.open(ip)[:,:,:])
img *= gain
img += offset
img/= np.pi
images.append(img)
S3ratio1 = (images[7]) / (images[3])
S3ratio2 = (images[10]) / (images[3])
images.append(S3ratio1)
images.append(S3ratio2)
images = np.concatenate(images,axis=2)
return images
def get_data(name, remove_bands=True, clean=True, path=PATH_DATA):
"""
Returns HSI data from a datacube
Parameters:
---------------------
name: name
remove_bands: if True, noisy bands are removed (leaving 113 bands)
clean: if True, remove damaged line
Returns:
-----------------------
data, wavelenghts as numpy arrays (float32)
"""
name = convert_name(name)
filename = "{}data/{}".format(path, name)
hsimage = envi.open('{}.hdr'.format(filename), '{}.float'.format(filename))
wavs = np.asarray(hsimage.bands.centers)
data = np.asarray(hsimage[:, :, :], dtype=np.float32)
#removal of damaged sensor line
if clean and name != 'F_2k':
data = np.delete(data, 445, 0)
if not remove_bands:
return data, wavs
return data[:, :, get_good_indices(name)], wavs[get_good_indices(name)]
def envi_to_array(img, hdr):
img = envi.open(hdr, img)
return img.read_bands(np.arange(img.shape[2]))
def _load_fixemask(self, slice_=None):
import spectral.io.envi as envi
if slice_ is None:
slice_ = (slice(None), slice(None))
return envi.open(self.hdr_file)[slice_]
def read_envi(hdr_file):
"""Load an ENVI map from the .hdr header file
Parameters:
-----------
hdr_file: string
file path for a .hdr file
Returns:
--------
out : object
a spectral.io.bipfile.BipFile object
Examples:
---------
>>> hdr_file = os.path.join(test_data_home, 'test_envi.hdr')
>>> img = envi.open(hdr_file)
(17, 32, 1738)
"""
# read in parameter list in the header file
params = []
with open(hdr_file, 'r', encoding='utf-8', errors='ignore') as header:
for line in header:
params.append(line.split('=')[0].strip())
# if parameter 'byte order' is not found, append 'byte order = 0' to the header file
if 'byte order' not in params:
with open(hdr_file, 'a', encoding='utf-8', errors='ignore') as header:
header.write('byte order = 0\n')
img = envi.open(hdr_file)
return img
def preview_cluster(pred8c_hdr, pred8c_img, band, slice_region, columns, rgb):
img = envi.open(pred8c_hdr, pred8c_img)
full_shape = img.shape[:2]
band_names = img.metadata['band names']
if (slice_region[0] != -1):
ymin, xmin, ymax, xmax = slice_region
sl = np.s_[slice_region[0]:slice_region[2], slice_region[1]:slice_region[3]]
else:
ymin, xmin, ymax, xmax = (0, 0, full_shape[0], full_shape[1])
sl = np.s_[:, :]
if rgb:
fig1, ax1 = plt.subplots()
r = img.read_band(band[0], use_memmap=True)[sl]
g = img.read_band(band[1], use_memmap=True)[sl]
b = img.read_band(band[2], use_memmap=True)[sl]
ax1.imshow(np.stack((r, g, b), axis=-1))
elif len(band):
cols = min(columns, len(band))
rows = np.math.ceil(len(band) / cols)
fig = plt.figure(figsize=(rows, cols))
for i, _b in enumerate(band):
b = img.read_band(_b, use_memmap=True)[sl]
ax = fig.add_subplot(rows, cols, i + 1)
plt.imshow(b)
plt.tight_layout()
ax.tick_params(axis='both', which='major', labelsize=8)
ax.tick_params(axis='both', which='minor', labelsize=6)
ax.xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f'{int(x + xmin)}'))
ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda y, _: f'{int(y + ymin)}'))
ax.set_title(band_names[_b], fontdict={'fontsize': 8})
plt.subplots_adjust(bottom=0.01, left=0.04, wspace=0.1, hspace=0.1, right=0.99, top=0.99)
plt.show()
def get_pure_spectra_library():
img = envi.open('Data/usgs_min.hdr', 'Data/usgs_min.sli')
spectra = pd.DataFrame(img.spectra, index=img.names, columns=[x*1000 for x in img.bands.centers]).T
spectra = spectra[(spectra.index > 1000) & (spectra.index < 2540)]
for column in spectra.columns:
spectra[column] = spectra[[column]].apply(normalize).apply(savgol).values
return spectra
def hsiNan_fill(self, imgHdrName):
"""
This function can be used to fill in the nans based on the other data in the image.
:param imgHdrName: location of the HDR file associated with the envi image of choice
:return:
"""
imgName = imgHdrName.replace('.hdr', '.img')
header = envi.read_envi_header(imgHdrName)
'Read in the background image'
crImg = envi.open(imgHdrName, imgName)
crCube = crImg.load()
[rows, cols, bands] = crCube.shape
arrCrImg = crCube.reshape((rows * cols, bands))
'Fill the NaNs in the columns'
arrCrImg = generalUtilities().fill_nan(arrCrImg)
'Fill the NaNs in the rows'
arrCrImgCrop = arrCrImg[:, 4:244]
arrCrImgCrop = generalUtilities().fill_nan(arrCrImgCrop.T)
arrCrImg[:, 4:244] = arrCrImgCrop.T
'Reshape to image size'
crCube_nr = arrCrImg.reshape((rows, cols, bands))
'Save the background image'
outFileName1 = imgName.replace('.img', '_CRnR.hdr')
envi.save_image(outFileName1, crCube_nr, dtype='single',
force=True, interleave='bil', metadata=header)
return outFileName1
def create_Mask4CRISMImages(self, imgName, sigAbsoprtionLevel=0.99):
"""
@function name :create_Mask4CRISMImages
@description :This function accepts the smoothed continuum removed image and flag spectra which have a
comparitively large absorptions and are worthy of further analysis.
----------------------------------------------------------------------------------------------------------------
INPUTS
----------------------------------------------------------------------------------------------------------------
1) imgName: Address of the Continuum Removed smoothed image.
2) sigAbsoprtionLevel: The threshold below which the spectra can be considered as having absorptions of which
can be considered significant.
----------------------------------------------------------------------------------------------------------------
OUTPUTS
----------------------------------------------------------------------------------------------------------------
1) mapName: Address of the Hyperspectral image which contains the mask image.
"""
hdrName = imgName.replace('.img', '.hdr')
'Read in the background image'
img = envi.open(hdrName, imgName)
sCRCube = img.load()
sCRCube = sCRCube[:, :, self.strtBand:self.stopBand]
sCRCubeMap = np.min(sCRCube, axis=2)
temp = np.zeros(sCRCubeMap.shape)
temp[sCRCubeMap < sigAbsoprtionLevel] = 1
outFileName = imgName.replace('.img', '_mask.hdr')
envi.save_image(outFileName, temp, dtype=np.float32, force=True,
interleave='bil')
return outFileName.replace('.hdr', '.img')
def load_mask(image_path):
"""
laod the water mask from S3 image
:param image_path: path to .data/ dir
:return:
"""
mask_file = os.path.join(image_path,"WQSF_lsb.hdr")
mask = envi.open(mask_file)[:,:,0]
mask = mask[:,:,0]
dim_file,_ = os.path.splitext(image_path)
dim_file+=".dim"
e = emt.parse(dim_file).getroot()
gp = e.find("./Flag_Coding[@name='WQSF_lsb']")
flag_to_index = dict([(f.find("Flag_Name").text,int(f.find("Flag_Index").text)) for f in gp.getchildren()])
mascara = np.zeros(mask.shape,dtype=mask.dtype)
masks_to_use = ["CLOUD","CLOUD_AMBIGUOUS","CLOUD_MARGIN","SNOW_ICE","HIGHGLINT"]
for m in masks_to_use:
mascara |= ((mask & flag_to_index[m])!=0)
mascara = (mascara==1)
masks_to_use = ["WATER","INLAND_WATER"]
mascara_water = np.zeros(mask.shape,dtype=mask.dtype)
for m in masks_to_use:
mascara_water |= ((mask & flag_to_index[m])!=0)
mascara_water = (mascara_water == 1)
mascara |= (~mascara_water)
return mascara
def main(infile):
inhdr = infile + ".hdr"
outhdr = os.path.basename(infile)[0:-11] + "_glint900metric.hdr"
img = envi.open(inhdr, infile)
wl = s.array([float(w) for w in img.metadata['wavelength']])
if (wl[0] < 100):
wl = wl * 1000
fwhm = s.array([float(w) for w in img.metadata['fwhm']])
b900 = s.argmin(abs(wl - 900.0))
## b1050 = s.argmin(abs(wl-1050.0))
b900imgs = img.read_bands([b900 - 1, b900, b900 + 1])
## b1050imgs = img.read_bands([b1050-1, b1050, b1050+1])
glintm900 = np.median(b900imgs, axis=2).reshape(
(b900imgs.shape[0], 1, b900imgs.shape[1]))
## glintm1050 = np.median(b1050imgs, axis=2).reshape((b1050imgs.shape[0], 1, b1050imgs.shape[1]))
# make output glint metric file and open memmap
metadata = img.metadata.copy()
metadata['bands'] = '%i' % 1
metadata['interleave'] = 'bil'
metadata['data type'] = '4'
out = envi.create_image(outhdr, metadata, ext='', force=True)
outmm = out.open_memmap(interleave='source', writable=True)
outmm[:, :, :] = glintm900
del outmm, out, glintm900, img
def open_file(self):
self.name = QtGui.QFileDialog.getOpenFileName(None, 'Open File')
global lib
lib = envi.open(str(self.name))
collection = lib.names
for x in collection:
self.listview.addItem(x)
def getdatesimage(dt):
print 'Getting %s' % dt
for (dirpath, dirnames, filenames) in walk('../londiani/%s' % dt):
filenames = sorted(filenames)
im = []
for f in filenames:
#print f
if f[-3:] == 'hdr':
img = envi.open('../londiani/%s/%s' % (dt, f))
l = img.load()
m = img.open_memmap()
im.append(m)
i = im
#print len(im)
if len(im) == 7:
big = np.dstack((im[0], im[1], im[2], im[3], im[4], im[5], im[6]))
if len(im) == 6:
big = np.dstack((im[0], im[1], im[2], im[3], im[4], im[5]))
if len(im) == 5:
big = np.dstack((im[0], im[1], im[2], im[3], im[4]))
if len(im) == 4:
big = np.dstack((im[0], im[1], im[2], im[3]))
return big
def load_cuprite_dataset():
envi_data = envi.open('../data/real/cuprite/cuprite.hdr')
img = envi_data[:, :, :]
hsi_path = '../data/real/cuprite/cuprite.mat'
ground_truth_path = '../data/real/cuprite/cuprite.gt'
hsi = sio.loadmat(hsi_path)
Y = hsi['Y'][1:, :]
ground_truth = sio.loadmat(ground_truth_path)['M']
ground_truth = ground_truth[1:, :]
endmembers_names = [
'Alunite', 'Andradite', 'Buddingtonite', 'Dumortierite', 'Kaolinite_1',
'Kaolinite_2', 'Muscovite', 'Montmorillonite', 'Nontronite', 'Pyrope',
'Sphene', 'Chalcedony'
]
number_rows = hsi['nRow'][0][0]
number_columns = hsi['nCol'][0][0]
number_pixels = int(number_rows) * int(number_columns)
number_endmembers = ground_truth.shape[1]
number_bands = Y.shape[0]
dimensions = [number_rows, number_columns, number_bands, number_pixels]
selected_bands = hsi['SlectBands'].T[0]
selected_bands = selected_bands[1:]
null_bands = list(
set(list(range(0, len(ground_truth)))) - set(selected_bands))
ground_truth_plot = ground_truth.copy()
ground_truth_plot[null_bands, :] = None
bandsSelection = [selected_bands, null_bands]
ground_truth = ground_truth[selected_bands]
dimensions_plot = [4, 3]
ground_truth = normalize_data(ground_truth)
return Y, img, dimensions, number_endmembers, ground_truth, ground_truth_plot, endmembers_names, dimensions_plot, bandsSelection, 'Cuprite'
def importSpectralData(self):
headerFilePath = QtGui.QFileDialog.getOpenFileName(
self, 'Select header file to open...', '', ".hdr(*.hdr)")
imageFilePath = QtGui.QFileDialog.getOpenFileName(
self, 'Select image file to open...', '',
"all(*);;.img(*.img);;.bip(*.bip)")
self.hsImage = envi.open(str(headerFilePath), str(imageFilePath))
#Generate a numpy nd array of the hyperspectral dataset.
hsArray = self.hsImage.load()
#Assign a class variable to the array
self.hsArray = hsArray
#Also provide the child graphicsview widget with access to the array
self.drawArea.img = hsArray
#get the dimensions of the nd array.
x, y, z = hsArray.shape
#Slice the array to retrieve the band 0 layer
hsArray = hsArray[:, :, 0]
hsArray = np.reshape(hsArray, (x, y))
self.drawArea.display_Image_From_Array(hsArray, True)
self.isEmpty = False
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 __init__(self, in_file, cloud_file=None):
sensor = 'MODIS'
super(ReadModisEnvi, self).__init__(in_file, sensor)
self.cloud_file = cloud_file
img = envi.open(self.in_file)
bands = range(0, 44)
img_data = img.read_bands(bands)
self.data = img_data
def get_images(img_dir, d_img_name, s_img_name, l_img_name):
"""
"""
# Replace all NULLs with zeros
ddr_img = envi.open(file=img_dir + d_img_name + '.hdr')
# ddr_img = remove_nulls(ddr_img)
ddr_img = ddr_img[:, :, :]
s_img = envi.open(file=img_dir + s_img_name + '.hdr')
# s_img = remove_nulls(s_img)
s_img = s_img[:, :, :]
l_img = envi.open(file=img_dir + l_img_name + '.hdr')
# l_img = remove_nulls(l_img)
l_img = l_img[:, :, :]
return ddr_img, s_img, l_img
def add_files(self, hdr_file, dat_file):
self.idx_dta = QSettings.ENVIITEMS
self.envi_img = envi.open(hdr_file, dat_file)
wavenum = envi.read_envi_header(hdr_file)['wavelength']
self.bands = np.array([float(i) for i in wavenum])
self.maxidx = len(self.idx_dta)
def data_dims(self):
'''
# Returns the predicted number of samples and the number of bands.
'''
# these would be used to take care of boundary conditions
h_rep = 0
w_rep = 0
rows = self.__masks.shape[0] + h_rep
cols = self.__masks.shape[1] + w_rep
annotated_pixels = np.zeros((self.__masks.shape[0], self.__masks.shape[1]))
for i in range(self.__num_masks):
annotated_pixels += self.__masks[:, :, i]
annotated_pixels[annotated_pixels > 1] = 0
num_samples = 0
if self.__balance:
if self.__num_samples is None:
max_samples = np.amax(self.__samples_per_class)
for i in range(0, self.__num_masks):
num_samples += self.__samples_per_class[i] * int(
floor(max_samples / self.__samples_per_class[i]))
num_samples += max_samples % self.__samples_per_class[i] # add remaining samples
else:
num_samples = 0
max_samples = np.amax(self.__samples_per_class)
for i in range(0, self.__num_masks):
num_samples += self.__samples_per_class[i] * int(
floor(max_samples / self.__samples_per_class[i]))
num_samples += max_samples % self.__samples_per_class[i] # add remaining samples
elif self.__num_samples is None:
num_samples = np.count_nonzero(annotated_pixels)
# print('\n========>num_samples: ', num_samples)
else:
for i in range(0, self.__num_masks):
if self.__num_samples > np.count_nonzero(self.__masks[:, :, i]):
num_samples += np.count_nonzero(self.__masks[:, :, i])
else:
num_samples += self.__num_samples
# print('balancing -- num-samples: ', num_samples)
# assuming a reader object has been initialized and filenames has been loaded
file_name = self.__data_file_names[0]
file_name = path.join(self.__data_folder_name, file_name)
# only load metadata
cur_data = envi.open(file_name + HDR_EXT, file_name)
return num_samples, cur_data.nbands, rows, cols
def __init__(self):
# Load dataset
trainingset = envi.open('Flevoland/Data/Flevoland.hdr',
'Flevoland/Data/Flevoland.raw')
# trainingset_gt = np.array(Image.open('Flevoland/Data/TrainingSet/cm3253_ground_truth_training.tiff'))
trainingset_gt = envi.open(
'Flevoland/Data/Flevoland_gt_corrected.hdr',
'Flevoland/Data/Flevoland_gt_corrected.raw')
# Dataset variables
# Input data shape: (145,145,200)
self.height = trainingset.nrows
self.width = trainingset.ncols
self.bands = trainingset.nbands
self.num_pixels = self.height * self.width
self.num_classes = int(trainingset.metadata['classes']) - 1
self.class_names = trainingset.metadata['class names'][1:]
# Complete ground truth
# self.complete_gt = self.convert_gt(scipy.io.loadmat("IndianPines/Data/Indian_pines_gt.mat")['indian_pines_gt'])
# Obtain train data
self.input_data = trainingset.load()
self.train_data = trainingset_gt.load().squeeze()
self.padded_data = self.input_data
self.complete_gt = self.train_data
# Obtain test data by comparing training set to complete ground truth
# self.test_data = self.get_test_data()
# Store number of pixels training/test
self.train_pixels = np.count_nonzero(self.train_data)
# self.test_pixels = np.count_nonzero(self.test_data)
# Color scale to display image
class_colors = np.asarray(trainingset.metadata['class lookup'],
dtype=int)
class_colors = class_colors.reshape((int(class_colors.size / 3), 3))
self.color_scale = ColorScale(
[x for x in range(class_colors.shape[0])], class_colors)
def load_envi(self, path):
basename = os.path.basename(path)
dest = os.path.join(tempdir, basename)
if not os.path.exists(dest):
self.download(path, dest)
raw = f"{dest.split('.')[0]}.raw"
if not os.path.exists(raw):
self.download(f"{path.split('.')[0]}.raw", raw)
return np.array(envi.open(dest, raw)[:, :, :])
def load_image(path):
hdrpath = path+'.hdr'
for p in [path, hdrpath]:
if not os.path.exists(p):
raise IOError('Cannot find %s\n' % p)
img = envi.open(hdrpath)
if img.sample_size != 4:
raise ValueError('I need 4 byte floating point values\n')
if img.bands.band_unit == 'Nanometers':
img.bands.band_unit = 'Microns'
img.bands.centers = [v/1000.0 for v in img.bands.centers]
img.bands.bandwidths = [v/1000.0 for v in img.bands.bandwidths]
return img, path
def load_ENVI_spec_lib(file_name):
"""
Load a ENVI .sli file.
Parameters:
file_name: `path string`
The complete path to the library file to load.
Returns: `numpy array`
A (n x p) HSI cube.
head: `dictionary`
Starting at version 0.13.1, the ENVI file header
"""
sli = envi.open(file_name)
head = envi.read_envi_header(file_name)
return sli.spectra, head
def envi_to_array(img, hdr):
"""Function which used the spectralpy package to convert envi style images
to numpy style arrays.
Parameters:
-----------
img - .img file
.img file with the image
hdr - header file
Returns
-------
Numpy array - (n by m by d) array
"""
img = envi.open(hdr, img)
return img.read_bands(np.arrange(img.shape[2]))
def load_ENVI_file(file_name):
"""
Load the data and the header from an ENVI file.
It use the SPy (spectral) library. At 'file_name' give the envi header file name.
Parameters:
file_name: `path string`
The complete path to the file to load. Use the header file name.
Returns: `tuple`
data: `numpy array`
A (m x n x p) HSI cube.
head: `dictionary`
Starting at version 0.13.1, the ENVI file header
"""
img = envi.open(file_name)
head = envi.read_envi_header(file_name)
return np.array(img.load()), head
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 __init__(self, fname):
self.f_handle = envi.open(fname)
self.spectra = self.f_handle.spectra
self.head = envi.read_envi_header(fname)
self.wvl = [float(x) for x in self.head['wavelength']]
self.spectra_names = self.head['spectra names']
plotspeed=False
### load the .nc file #####
data = loadnc('runs/' +grid+'/' + name + '/output/',singlename=grid + '_0001.nc')
print('done load')
data = ncdatasort(data,trifinder=True)
print('done sort')
img=envi.open('data/kelp_data/NDVI_1999-2013_autumn-mean.hdr','data/kelp_data/NDVI_1999-2013_autumn-mean.img')
A=np.squeeze(img[:,:]).T
startx=432105
starty=5928375
Asize=A.shape
def DIRSIG(directory):
from spectral.io import envi
#get phase history
phs_fname = getWildcard(directory, '*.hdr')
phs = envi.open(phs_fname).load(dtype = np.complex128)
phs = np.squeeze(phs)
#get platform geometry
ppd_fname = getWildcard(directory, '*.ppd')
tree = ET.parse(ppd_fname)
root = tree.getroot()
pos_dirs = []
for children in root.iter('point'):
pos_dirs.append(float(children[0].text))
pos_dirs.append(float(children[1].text))
pos_dirs.append(float(children[2].text))
pos_dirs = np.asarray(pos_dirs).reshape([len(pos_dirs)/3,3])
t_dirs=[]
for children in root.iter('datetime'):
t_dirs.append(float(children.text))
t_dirs = np.asarray(t_dirs)
#get platform system paramters
platform_fname = getWildcard(directory, '*.platform')
tree = ET.parse(platform_fname)
root = tree.getroot()
#put metadata into a dictionary
metadata = root[0]
keys = []; vals = []
for children in metadata:
keys.append(children[0].text)
vals.append(children[1].text)
metadata = dict(zip(keys,vals))
#obtain key parameters
c = 299792458.0
nsamples = int(phs.shape[1])
npulses = int(phs.shape[0])
vp = float(get(root, 'speed'))
delta_t = float(get(root, 'delta'))
t = np.linspace(-nsamples/2, nsamples/2, nsamples)*delta_t
prf = float(get(root, 'clockrate'))
chirprate = float(get(root, 'chirprate'))/pi
T_p = float(get(root, 'pulseduration'))
B = T_p*chirprate
B_IF = (t.max() - t.min())*chirprate
delta_r = c/(2*B_IF)
f_0 = float(get(root, 'center'))*1e9
freq = f_0+chirprate*t
omega = 2*pi*freq
k_r = 2*omega/c
T0 = float(get(root, 'min'))
T1 = float(get(root, 'max'))
#compute slowtime position
ti = np.linspace(0,1.0/prf*npulses, npulses)
x = np.array([np.interp(ti, t_dirs, pos_dirs[:,0])]).T
y = np.array([np.interp(ti, t_dirs, pos_dirs[:,1])]).T
z = np.array([np.interp(ti, t_dirs, pos_dirs[:,2])]).T
pos = np.hstack((x,y,z))
L = norm(pos[-1]-pos[0])
k_y = np.linspace(-npulses/2,npulses/2,npulses)*2*pi/L
#Vector to scene center at synthetic aperture center
if np.mod(npulses,2)>0:
R_c = pos[npulses/2]
else:
R_c = np.mean(
pos[npulses/2-1:npulses/2+1],
axis = 0)
#Derived Parameters
if np.mod(nsamples,2)==0:
T = np.arange(T0, T1+0*delta_t, delta_t)
else:
T = np.arange(T0, T1, delta_t)
#Mix signal
signal = np.zeros(phs.shape)+0j
for i in range(0,npulses,1):
r_0 = norm(pos[i])
tau_c = 2*r_0/c
ref = np.exp(-1j*(2*pi*f_0*(T-tau_c)+pi*chirprate*(T-tau_c)**2))
signal[i,:] = ref*phs[i,:]
platform = \
{
'f_0' : f_0,
'freq' : freq,
'chirprate' : chirprate,
'B' : B,
'B_IF' : B_IF,
'nsamples' : nsamples,
'npulses' : npulses,
'delta_r' : delta_r,
'delta_t' : delta_t,
'vp' : vp,
'pos' : pos,
'R_c' : R_c,
't' : t,
'k_r' : k_r,
'k_y' : k_y,
'metadata' : metadata
}
return(signal, platform)
def load_spec_lib(lib_path, lib_hdr_name):
dfin = osp.join(lib_path, lib_hdr_name)
sli = envi.open(dfin)
return sli.spectra
def fmle(image_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso", roi_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso_map_verifi", gt_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso_map_entre",img_dest= "C:\\Users\\jose\\Desktop\\",m=1.5):
''''
Ejecucion del algoritmo fmle .
Parameteros:
image_path: ruta de la imagen a clasificar.
roi_path: ruta del mapa de entrenamiento.
gt_path: ruta del mapa de verificacion.
img_dest=: ruta donde se desea guardar el mapa de clasificacion.
'''
from numpy import zeros, transpose, dot, newaxis,compress, indices, reshape, not_equal
## crea un ImageArray object que contiene toda la interface de un numpy array, apartir de la ruta de la roi .
roi = envi.open( roi_path + '.hdr', roi_path).read_band(0)
## crea un ImageArray object que contiene toda la interface de un numpy array, apartir de un archivo de cabecera envi, que contien la imagen.
img = envi.open( image_path + '.hdr', image_path).load()
gt = envi.open( gt_path + '.hdr', gt_path).read_band(0)
tiempo_inicial = clock()
#crea las clases de entrenamiento
classes = create_training_classes(img, gt,m=m)
d = len(classes.classes)
#crea el clasificador gaussiano
gmlc = FuzzyGaussianClassifier(classes)
#clasificacion de la imagen
clMap = gmlc.classify_image(img)
tiempo_final = clock()
(nrows, ncols) = clMap.shape
class_indices = set(roi.ravel())
k = len(class_indices)-1
class_indices = class_indices.difference([0])
class_indices =list(class_indices)
ind_clas ={}
for i in range(k):
ind_clas[class_indices[i]]=i
(nrows, ncols) = roi.shape
mask_index = numpy.not_equal(roi, 0.0)
inds = transpose(indices((nrows, ncols)), (1, 2, 0))
inds = reshape(inds, (nrows * ncols, 2))
inds = compress(numpy.not_equal(mask_index.ravel(), 0), inds, 0).astype('h')
ne= len(inds)
roi_test = zeros(ne)
img_test = zeros(ne)
for i in range(inds.shape[0]):
x = roi[inds[i,0],inds[i,1]]
roi_test[i]= ind_clas[x]
y = clMap[inds[i][0], inds[i][1]]
img_test[i]= int(y)
w = np.zeros((nrows, ncols, 3))
table_color = lookup_table()
for i in range(nrows):
for j in range(ncols):
maxi = int(clMap[i,j])
w[i,j,:] = table_color[maxi+1]
if (maxi == k) :
w[i,j,:] = table_color[0]
imagen = save_image(img_dest, "classified_image_by_fmle", w)
print "runtime of FMLE is: %f " % (tiempo_final - tiempo_inicial)
return (roi_test,img_test)
def create_image_from_envi_header(image_path):
img = envi.open(image_path + '.hdr' , image_path)
img = img.load()
return img
def main(argv=None):
class usage(Exception):
def __init__(self, msg):
self.msg = usage_msg
if argv is None:
argv = sys.argv
try:
try:
longopts = ['verbose','flip','norm','help']
longoptsp = ['dat','ref','bands','matkey','load-rois','scale','wvl']
shortopts = ''.join([o[0] for o in longopts])
shortopts += ''.join([o[0]+':' for o in longoptsp])
opts, args = getopt.getopt(argv[1:], shortopts, longopts)
datf = args[0]
except (getopt.error, IndexError), msg:
raise usage(msg)
verbose = False
flipdat = False
norm = False
refbands = [0,1,2]
scalec = 1.0
bbox,wvlf = None,None
reff,refkey = None,None
colorf,roif = None,None
for opt, val in opts:
if opt in ('--verbose','-v'):
verbose=True
elif opt in ('--help','-h'):
print __doc__
print usage_msg
sys.exit(0)
elif opt in ('--bands','-b'):
refbands = np.asarray(val.split(','),int)
elif opt in ('--ref','-r'):
reff = val.split(':')
if len(reff)==2:
refkey = reff[1]
reff = reff[0]
elif opt in ('--colorfile', '-c'):
colorf = val
elif opt in ('--flip', '-f'):
flipdat = True
elif opt in ('--norm', '-n'):
norm = True
elif opt in ('--load-rois', '-l'):
roif = val
elif opt in ('--scale','-s'):
scalec = float(val)
elif opt in ('--wvl', '-w'):
wvlf = val
if len(args) != 1:
raise usage(usage_msg)
print datf
datf = datf.split(':')
if len(datf)==2:
datkey = datf[1]
datf = datf[0]
if len(refbands) > 3:
print "Too many refbands"
return
colortab = None
if colorf is not None:
# colorf = 'cm_jet16.txt'
colortab = np.loadtxt(colorf,dtype=float)
colortab = np.c_[colortab,np.ones([colortab.shape[0],1])*0.75]
dfile,dext = os.path.splitext(datf)
normf = '%s_normed.mat'%dfile
if norm and pathexists(normf):
print "Loading precomputed normalized data file %s"%normf
dat = load_matlab(normf,'normed')
print "Finished loading normalized data"
if dext == '.mat':
dat = load_matlab(datf,datkey)
if len(dat)==0:
return -1
elif dext in ('.img','.hdr'):
import spectral.io.envi as envi
dinfo = envi.open(datf)
dat = dinfo.read_bands(range(dinfo.shape[2])).squeeze()
else:
dat = pl.imread(datf)
x,y,z = np.atleast_3d(dat).shape
if verbose:
print "Loaded %d x %d x %d image data from file %s"%(x,y,z,datf)
if norm and not pathexists(normf):
from scipy.io import savemat
print "Saving normalized data to file %s"%normf
dat = dat.reshape([x*y,z])
normv = np.apply_along_axis(np.linalg.norm,1,dat)
normv[normv==0] = 1.0
dat = (dat.T / normv.T).T
dat = dat.reshape([x,y,z])
savemat(normf,{'normed':dat})
print "Finished saving normalized data"
if flipdat:
dat = dat[::-1,:,:]
if reff is None:
ref = dat[:,:,refbands]
else:
rfile,rext = os.path.splitext(reff)
if rext == '.mat':
ref = load_matlab(reff,refkey)
if len(ref)==0:
return -1
else:
ref = pl.imread(reff)
if scalec != 1.0:
reftype = ref.dtype
ref = (ref.astype(float)*scalec).astype(reftype)
if verbose:
print "Reference image bands=%s, scaling factor=%f"%(refbands,scalec)
if wvlf is None:
wvl = np.arange(dat.shape[2])
else:
wvl = load_matlab(wvlf,'wvl')
if tuple(dat.shape[:2]) != tuple(ref.shape[:2]):
print 'Data and Reference images not the same size:',
print dat.shape, ref.shape
return -1
if roif is None:
roif = dfile+'_rois.mat'
lab = LABELER(dat,ref,wvl=wvl,colortab=colortab,roifile=roif,
verbose=verbose)
pl.ioff()
pl.show()
import time
from spectral import *
import spectral.io.envi as envi
import numpy as np
i = []
dir = '1Jan1979'
names = [2,3,4,5,6,7]
for n in names:
img = envi.open('../londiani/%s/band%s.hdr'%(dir,n))
l = img.load()
m = img.open_memmap()
i.append(m)
big = np.dstack((i[0],i[1],i[2],i[3],i[4],i[5]))
#rgb= np.dstack((s5,s4,s3))
(mm,c) = kmeans(big,20,20)
clusters = {}
for i in range(20):
clusters[i] = np.sum(mm==i)
print clusters
a =sorted(clusters.items(), key=lambda clusters: clusters[1])
a.reverse()
clusters = a
pc = principal_components(big)
if not os.path.exists(savepath): os.makedirs(savepath)
region=regions(regionname)
nidx=get_nodes(data,region)
eidx=get_elements(data,region)
ll=np.loadtxt('data/kelp_data/newkelp_ll_nad.dat')
np.save('data/kelp_data/newkelp_ll_nad.npy',ll)
ll=np.load('data/kelp_data/newkelp_ll_nad.npy')
img=envi.open('data/kelp_data/NDVI_1999-2013_winter-mean.hdr','data/kelp_data/NDVI_1999-2013_winter-mean.img')
#img2=envi.open('data/kelp_data/NDVI_1999-2013_summer-mean.hdr','data/kelp_data/NDVI_1999-2013_summer-mean.img')
#A2=(np.squeeze(img2[:,:]).T)
#indata = np.genfromtxt('data/kelp_data/NDVI_1999-2013_summer-mean_LL.txt',skip_header=5)
#A=indata[:,2]
A=(np.squeeze(img[:,:]).T)
lonin=ll[:,0]
latin=ll[:,1]
lonin2=lonin.reshape(A.T.shape).T
latin2=latin.reshape(A.T.shape).T
#lonin2=indata[:,0]
#latin2=indata[:,1]
for d in dirnames:
print d
filenames= []
for (dirpath, dirnames, filenames) in walk('../londiani/%s'%d):
filenames = sorted(filenames)
i = []
for f in filenames:
print f
if f[-3:] =='hdr':
print f
img = envi.open('../londiani/%s/%s'%(d,f))
l = img.load()
m = img.open_memmap()
i.append(m)
#got i now process
print len(i)
if len(i) == 6:
big = np.dstack((i[0],i[1],i[2],i[3],i[4],i[5]))
if len(i) == 5:
big = np.dstack((i[0],i[1],i[2],i[3],i[4]))
if len(i) == 4:
big = np.dstack((i[0],i[1],i[2],i[3]))
#Do kmeans clustering on original image
dokmeans = False
if dokmeans:
(mm,c) = kmeans(big,maxclasses,20)
def super(type='e',emax=1.e-10, imax=150,m=2.,image_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso", roi_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso_map_verifi", gt_path="C:\\Users\\jose\\Desktop\\imagenes\\remanso_map_entre",img_dest="C:\\Users\\jose\\Desktop\\",win_size = 3):
''''
Ejecucion del algoritmo FCM,GKFCM,WFCM, de naturaleza supervisada .
Parameteros:
image_path: ruta de la imagen a clasificar.
img_dest: ruta donde se desea guardar el mapa de clasificacion.
roi_path: ruta del mapa de entrenamiento.
gt_path: ruta del mapa de verificacion.
type: metodo a ejecutar.
emax: umbral de error.
imax: numero de iteraciones maximas permitidas.
m: grado de borrosidad.
'''
from numpy import zeros, transpose, dot, newaxis,compress, indices, reshape, not_equal,amax
img = create_image_from_envi_header(image_path)
roi = envi.open( roi_path + '.hdr', roi_path).read_band(0)
gt = envi.open( gt_path + '.hdr', gt_path).read_band(0)
(nrows, ncols, nbands) = img.shape
N = nrows * ncols
if type == 'e':
fcm = SupFuzzyCMeans(img,gt,m,False)
elif type == 'gus':
fcm = SupGKFuzzyCMeans(img,gt,m,False)
elif type == 'w':
fcm = SupWFuzzyCMeans(img,gt,m,False,win_size=win_size)
tiempo_inicial = clock()
fcm(emax=emax,imax=imax)
tiempo_final = clock()
membership = fcm.mu
des=fcm.desvs
me=fcm.means
ind_clas =fcm.index_class
(_,nclas) = membership.shape
cen=fcm.c
count=0
print membership
w = zeros(N)
classified = zeros((N,3))
table_color = lookup_table()
for k in range(N):
maxi = argmax(membership[k,:])
w[k] = maxi
classified[k,:]=table_color[maxi+1]
if amax(membership[k,:]) < 0.51:
count = count + 1
w[k] = int(nclas)
classified[k,:]=table_color[0]
w = w.reshape((nrows,ncols))
classified = classified.reshape((nrows,ncols,3))
mask_index = numpy.not_equal(roi, 0.0)
inds = transpose(indices((nrows, ncols)), (1, 2, 0))
inds = reshape(inds, (nrows * ncols, 2))
inds = compress(numpy.not_equal(mask_index.ravel(), 0), inds, 0).astype('h')
ne= len(inds)
roi_test = zeros(ne)
img_test = zeros(ne)
for i in range(inds.shape[0]):
x = roi[inds[i,0],inds[i,1]]
roi_test[i]= ind_clas[x]
y = w[inds[i][0], inds[i][1]]
img_test[i]= int(y)
if type == 'e':
imagen = save_image(img_dest, "classified_image_by_SFCM", classified)
print "runtime of FCM is: %f " % (tiempo_final - tiempo_inicial)
elif type == 'gus':
imagen = save_image(img_dest, "classified_image_by_SGK", classified)
print "runtime of GUSTAFON_KESSEL is: %f " % (tiempo_final - tiempo_inicial)
elif type == 'w':
imagen = save_image(img_dest, "classified_image_by_SWFCM", classified)
print "runtime of WFCM is: %f " % (tiempo_final - tiempo_inicial)
return (img_test,roi_test,count)
import time
from spectral import *
import spectral.io.envi as envi
img3 = envi.open('./8Dec2013/band3.hdr')
l = img3.load()
m = img3.open_memmap()
s3 = m.astype('uint8')
img4 = envi.open('./8Dec2013/band4.hdr')
l4 = img4.load()
m4 = img4.open_memmap()
s4 = m4.astype('uint8')
img5 = envi.open('./8Dec2013/band5.hdr')
l5 = img5.load()
m5= img5.open_memmap()
s5 = m5.astype('uint8')
import numpy as np
rgb= np.dstack((s5,s4,s3))
v = imshow(rgb)
time.sleep(3)
import time
from spectral import *
import spectral.io.envi as envi
import numpy as np
i = []
names = [2,3,4,5,6,7]
for n in names:
img = envi.open('../londiani/8Dec2013/band%s.hdr'%n)
l = img.load()
m = img.open_memmap()
i.append(m)
big = np.dstack((i[0],i[1],i[2],i[3],i[4],i[5]))
#rgb= np.dstack((s5,s4,s3))
(mm,c) = kmeans(big,20,20)
clusters = {}
for i in range(20):
clusters[i] = np.sum(mm==i)
print clusters
a =sorted(clusters.items(), key=lambda clusters: clusters[1])
a.reverse()
clusters = a
pc = principal_components(big)
pc_090 = pc.reduce(fraction=0.99)
import time
from spectral import *
import spectral.io.envi as envi
import numpy as np
import Image
i = []
names = [2,3,4,5,6,7]
for n in names:
img = envi.open('./8Dec2013/band%s.hdr'%n)
l = img.load()
m = img.open_memmap()
i.append(m)
big = np.dstack((i[0],i[1],i[2],i[3],i[4],i[5]))
#rgb= np.dstack((s5,s4,s3))
(mm,c) = kmeans(big,20,20)
clusters = {}
for i in range(20):
clusters[i] = np.sum(mm==i)
print clusters
a =sorted(clusters.items(), key=lambda clusters: clusters[1])
a.reverse()
clusters = a
pc = principal_components(big)
pc_090 = pc.reduce(fraction=0.90)
def load_signal_to_detect(detect_path, detect_hdr_name):
dfin = osp.join(detect_path,detect_hdr_name)
sli = envi.open(dfin)
y = sli.spectra[0,:].tolist()
return np.array(y)
matplotlib.pyplot.show()
# scale for natural color display
rows, cols, bands = im.shape
print 'im shape: ', str(im.shape)
rgb = im[:, :, 2:5]
rgbScaled = (rgb * 255.0).astype('uint8')
view = matplotlib.pyplot.imshow(rgbScaled.astype('uint8'))
matplotlib.pyplot.show()
# PIL image module
from PIL import Image
# spectral python
import spectral.io.envi as envi
im = envi.open('/Users/vscholl/Downloads/sr_stacked_scaled/LC80840092015152LGN00/LC80840092015152LGN00_sr_stackedScaled.tif.hdr','/Users/vscholl/Downloads/sr_stacked_scaled/LC80840092015152LGN00/LC80840092015152LGN00_sr_stackedScaled.tif')
rgb = im[:,:,2:5]
# loop through bands
for i in range(0, bands):
print i
# set a variable for each landsat band used in classification, for readability
coastal = im[:, :, 0].reshape([rows,cols])
blue = im[:, :, 1].reshape([rows,cols])
green = im[:, :, 2].reshape([rows,cols])
red = im[:, :, 3].reshape([rows,cols])
nir = im[:, :, 4].reshape([rows,cols])
swir1 = im[:, :, 5].reshape([rows,cols])
swir2 = im[:, :, 6].reshape([rows,cols])