def readLatlon(self, latlon=None, datFile=None):
'''
Reads lat/lon file - using set filenames, or specifiy with
latlon=basefilename
'''
# read datFile if needed.
if self.nr < 1 or self.na < 1:
try:
self.readOffsetsDat(datFile=datFile)
except Exception:
myerror(f'Could not read lat/lon dat file {datFile}')
#
if latlon is not None:
self.latlonName(latlon=latlon)
#
if os.path.exists(self.latFile) and os.path.exists(self.lonFile):
if self.verbose:
print(f'Reading {self.latFile} and {self.lonFile} with size '
f'{self.nr}x{self.na}')
self.lat = readImage(self.latFile, self.nr, self.na, '>f8')
self.lon = readImage(self.lonFile, self.nr, self.na, '>f8')
else:
myerror(f'Offsets tried to read an invalid lat or lon file '
f'- {self.latFile} {self.lonFile}')
def readOffsets(self, fileRoot=None, rangeFile=None, datFile=None):
'''
Read da/dr offset file at previously set up offset names, or specify
directly with values as defined for init.
'''
# over ride names if needed.
if len(self.azimuthFile) == 0 or rangeFile is not None \
or fileRoot is not None:
self.offsetFileNames(fileRoot, rangeFile=None)
# read datFile if needed.
if self.nr < 1 or self.na < 1:
self.readOffsetsDat(datFile=datFile)
#
if os.path.exists(self.azimuthFile) and os.path.exists(self.rangeFile):
if self.verbose:
print(f'Reading {self.azimuthFile} of size {self.nr}x'
f'{self.na}')
self.azOff = readImage(self.azimuthFile, self.nr, self.na, '>f4')
self.azOff[np.isnan(self.azOff)] = -2.e9
if self.verbose:
print(f'Reading {self.rangeFile} of size {self.nr}x{self.na}')
self.rgOff = readImage(self.rangeFile, self.nr, self.na, '>f4')
self.rgOff[np.isnan(self.rgOff)] = -2.e9
else:
myerror(f'Offsets tried to read offset files: '
f'{self.azimuthFile} {self.rangeFile}')
return self.rgOff.astype(float), self.azOff.astype(float)
def readFiles(self, fileNames, dType, tiff=False):
# get the values that match the type
myTypes = {
'scalar': ['x'],
'velocity': ['vx', 'vy'],
'error': ['ex', 'ey']
}[self.geoType]
minValue = {
'scalar': -2.e9,
'velocity': -2.e9,
'error': -2.e9
}[self.geoType]
sx, sy = self.geo.sizeInPixels()
# loop over arrays and file names to read data
for myType, fileName in zip(myTypes, fileNames):
if not tiff:
# print(fileName, sx, sy, dType)
myArray = readImage(fileName, sx, sy, dType)
else:
myArray = self.readMyTiff(fileName)
# handle no data nans if present
if np.sum(np.isnan(myArray)) > 0:
myArray[np.isnan(myArray)] = np.nan
elif isinstance(myArray[0, 0], np.floating):
# print(minValue)
myArray[myArray <= minValue] = np.nan
exec(f'self.{myType}=myArray')
#
# compute mag for velocity and errors
if self.geoType == 'velocity':
self.v = np.sqrt(
np.square(self.vx.astype(float)) +
np.square(self.vy.astype(float)))
elif self.geoType == 'error':
self.e = np.sqrt(np.square(self.ex) + np.square(self.ey))
def collectImages(directory):
'''Function that accepts a full path to a directory and adds all images found to the database'''
# create schema (if necessary)
DB.createSchema()
i = 0
images = []
for fn in os.listdir(directory):
full_path = directory + '\\' + fn
filename, file_extension = os.path.splitext(full_path)
img_arr = readImage(full_path)
if type(img_arr) == np.ndarray:
opened_image = getOpening(img_arr)
img_hash = hashImage(full_path)
color_vector = np.asarray(cd.describe(img_arr))
image = [img_hash, full_path, img_arr, opened_image, color_vector]
images.append(image)
# commit every 100 images
if i == 100:
DB.addImages(images)
i = 0
images = []
else:
i += 1
# commit any remaining images
if len(images) > 0:
DB.addImages(images)
print 'Images added to database'
def readCC(self, ccFile=None, datFile=None):
''' reads cross corr data (cc) name '''
# makes sure there is a name
if self.ccFile is None or ccFile is not None:
self.ccFileName(ccFile=ccFile)
# get sizes if needed
if self.nr < 1 or self.na < 1:
self.readOffsetsDat(datFile=datFile)
self.cc = readImage(self.ccFile, self.nr, self.na, '>f4')
def readSigma(self, sigmaAFile=None, sigmaRFile=None):
'''
Reads sigmaA/R files - assumes filenames set - but can override with
sigmaAFile, sigmaRFile
'''
#
# set file name only if specified, assumes defaults tried in init
if sigmaAFile is not None or sigmaRFile is not None:
self.sigmaFileName(sigmaAFile=sigmaAFile, sigmaRFile=sigmaRFile)
# read fresults after checking existence
if os.path.exists(self.sigmaAFile) and os.path.exists(self.sigmaRFile):
if self.verbose:
print(f'Reading {self.sigmaAFile} and {self.sigmaRFile} with '
f'size {self.nr}x{self.na}')
self.sigmaA = readImage(self.sigmaAFile, self.nr, self.na, '>f4')
self.sigmaR = readImage(self.sigmaRFile, self.nr, self.na, '>f4')
else:
myerror(f'Offsets tried to read an invalid sigmaA/R file - '
f'{self.sigmaAFile} and {self.sigmaRFile}')
exit()
return self.sigmaR, self.sigmaA
def readMask(self, maskFile=None):
'''
Reads mask files - assumes filenames set, or specify here with
maskFile=filename
'''
if maskFile is not None:
self.maskFileName(maskFile=maskFile)
if len(self.maskFile) == 0:
myerror(f'\n\nError: Offsets tried to read an blank mask file -'
f'{self.maskFile}')
if os.path.exists(self.maskFile):
if self.verbose:
print(f'Reading {self.maskFile} with size {self.nr}x{self.na}')
self.mask = readImage(self.maskFile, self.nr, self.na, 'u1')
else:
myerror(f'\n\nOffsets tried to read an invalid mask '
'file {self.maskFile} ')
return self.mask