def toRadar(maskin, latin, lonin, output):
maskim = createImage()
maskim.load(maskin + '.xml')
latim = createImage()
latim.load(latin + '.xml')
lonim = createImage()
lonim.load(lonin + '.xml')
mask = np.fromfile(maskin, maskim.toNumpyDataType())
lat = np.fromfile(latin, latim.toNumpyDataType())
lon = np.fromfile(lonin, lonim.toNumpyDataType())
mask = np.reshape(mask,
[maskim.coord2.coordSize, maskim.coord1.coordSize])
startLat = maskim.coord2.coordStart
deltaLat = maskim.coord2.coordDelta
startLon = maskim.coord1.coordStart
deltaLon = maskim.coord1.coordDelta
#remember mask starts from top left corner
#deltaLat < 0
lati = np.clip(((lat - startLat) / deltaLat).astype(np.int), 0,
mask.shape[0] - 1)
loni = np.clip(((lon - startLon) / deltaLon).astype(np.int), 0,
mask.shape[1] - 1)
cropped = (mask[lati, loni] + 1).astype(maskim.toNumpyDataType())
cropped = np.reshape(cropped,
(latim.coord2.coordSize, latim.coord1.coordSize))
cropped.tofile(output)
croppedim = createImage()
croppedim.initImage(output, 'read', cropped.shape[1], maskim.dataType)
croppedim.renderHdr()
def cropImage(self, geoname, inname, outname, which):
im1 = createImage()
im1.load(geoname)
if which == 'dem':
im2 = createDemImage()
elif which == 'wbd':
im2 = createImage()
else:
raise Exception('Unrecognized image type')
im2.load(inname)
latstart1 = im1.coord2.coordStart
latsize1 = im1.coord2.coordSize
latdelta1 = im1.coord2.coordDelta
lonstart1 = im1.coord1.coordStart
lonsize1 = im1.coord1.coordSize
londelta1 = im1.coord1.coordDelta
latstart2 = im2.coord2.coordStart
latsize2 = im2.coord2.coordSize
latdelta2 = im2.coord2.coordDelta
lonstart2 = im2.coord1.coordStart
lonsize2 = im2.coord1.coordSize
londelta2 = im2.coord1.coordDelta
ilatstart = abs(int(round((latstart2 - latstart1) / latdelta2)))
ilatend = ilatstart + latsize1
ilonstart = abs(int(round((lonstart2 - lonstart1) / londelta2)))
ilonend = ilonstart + lonsize1
imIn = im2.memMap(band=0)
#if it the resolutions are different the ration will normally be either twice or half
#or some integer (or inverse integer ratio)
if ((londelta2 / londelta1) > 1.5 or (londelta2 / londelta1) < .8):
#make sure that is close to an int
if (abs(londelta2 / londelta1 - round(londelta2 / londelta1)) <
.001 or abs(londelta1 / londelta2 -
round(londelta1 / londelta2)) < .001):
imIn = self.resample((londelta2 / londelta1), imIn)
else:
raise Exception(
'Cannot resample DEM and water mask to data grid')
#create mmap of goename size but dem data type
imCrop = np.memmap(outname,
im2.toNumpyDataType(),
'w+',
shape=(latsize1, lonsize1))
imCrop[:, :] = imIn[ilatstart:ilatend, ilonstart:ilonend]
im3 = im2.clone()
im3.filename = outname
im3.coord2.coordStart = latstart1
im3.coord2.coordSize = latsize1
im3.coord2.coordDelta = latdelta1
im3.coord2.coordEnd = latstart1 + latsize1 * latdelta1
im3.coord1.coordStart = lonstart1
im3.coord1.coordSize = lonsize1
im3.coord1.coordDelta = londelta1
im3.coord1.coordEnd = lonstart1 + lonsize1 * londelta1
im3.renderHdr()
def createImage(self, lat, lon, source, outname):
image = createImage()
delta = 1 / 3600.0
try:
os.makedirs(self._downloadDir)
except:
#dir already exists
pass
width = self.getDemWidth(lon, 1)
image.initImage(outname, 'read', width, 'BYTE')
length = image.getLength()
dictProp = {
'METADATA_LOCATION': outname + '.xml',
'Coordinate1': {
'size': width,
'startingValue': min(lon[0], lon[1]),
'delta': delta
},
'Coordinate2': {
'size': length,
'startingValue': max(lat[0], lat[1]),
'delta': -delta
},
'FILE_NAME': outname
}
#no need to pass the dictionaryOfFacilities since init will use the default one
image.init(dictProp)
self._image = image
return image
def write2xml(data, xFirst, yFirst, dx, dy, outName, projection='lat/lon'):
length = data.shape[0]
width = data.shape[1]
xStep = dx
yStep = dy
proj = projection
xmlName = outName + '.xml'
xmldict = {
'METADATA_LOCATION': xmlName,
'data_type': 'Float',
'image_type': 'BIL',
'Coordinate1': {
'size': width,
'startingValue': xFirst,
'delta': xStep
},
'Coordinate2': {
'size': length,
'startingValue': yFirst,
'delta': yStep
},
'FILE_NAME': outName,
'number_bands': 1
}
demImage = createImage()
demImage.init(xmldict)
demImage.renderHdr()
def loadImage(self, imgxml, band=None):
if imgxml == self._imgMap['dem']['name']:
img = createDemImage()
else:
img = createImage()
img.load(imgxml)
img.filename = os.path.basename(img.filename)
return img.memMap(band=band)
def createImage(self, lats, lons, filename):
img = createImage()
lons = np.sort(lons)
img.initImage(filename, 'read',
self._tileWidth * int(np.diff(lons)[0]))
img._metadataLocation = filename + '.xml'
img.coord1.coordStart = lons[0]
img.coord1.coordDelta = 1. / self._tileWidth
img.coord2.coordStart = np.sort(lats)[-1]
img.coord2.coordDelta = -1. / self._tileWidth
img.dataType = self._dtype
return img
def createImages(self):
demWidth = self.computeGeoImageWidth()
demLength = self.computeGeoImageLength()
if self.demCropFilename:
self.demCropImage = createDemImage()
demAccessMode = 'write'
self.demCropImage.initImage(self.demCropFilename, demAccessMode,
demWidth)
self.demCropImage.createImage()
self.demCropAccessor = self.demCropImage.getImagePointer()
else:
self.demCropAccessor = 0
if self.geoFilename is None:
raise ValueError('Output geoFilename not specified')
#the topophase files have the same format as the int file. just reuse the previous info
self.geoImage = createIntImage()
IU.copyAttributes(self.inputImage, self.geoImage)
self.geoImage.imageType = self.inputImage.imageType
self.geoImage.setFilename(self.geoFilename)
self.geoImage.setAccessMode('write')
self.geoImage.setWidth(demWidth)
self.geoImage.coord1.coordEnd = None
self.geoImage.coord2.coordEnd = None
if not self.geoImage.dataType.upper().count('FLOAT'):
self.geoImage.setCaster('write', 'FLOAT')
self.geoImage.createImage()
self.geoImage.createFile(demLength)
self.geoAccessor = self.geoImage.getImagePointer()
if (self.losImage == None and self.losFilename not in ('', None)):
self.losImage = createImage()
accessMode = 'write'
dataType = 'FLOAT'
bands = 2
scheme = 'BIL'
width = demWidth
self.losImage.initImage(self.losFilename,
accessMode,
width,
dataType,
bands=bands,
scheme=scheme)
self.losImage.createImage()
self.losAccessor = self.losImage.getImagePointer()
self.polyDopplerAccessor = self.polyDoppler.exportToC()
def main(inps):
'''
The main driver.
'''
if inps.infile.endswith('.xml'):
inFileXml = inps.infile
inFile = os.path.splitext(inps.infile)[0]
else:
inFile = inps.infile
inFileXml = inps.infile + '.xml'
if inps.outfile is None:
spl = os.path.splitext(inFile)
ext = '.{0}alks_{1}rlks'.format(inps.azlooks, inps.rglooks)
outFile = spl[0] + ext + spl[1]
elif inps.outfile.endswith('.xml'):
outFile = os.path.splitext(inps.outfile)[0]
else:
outFile = inps.outfile
print('Output filename : {0}'.format(outFile))
#hackish, just to know the image type to instantiate the correct type
#until we put the info about how to generate the instance in the xml
from iscesys.Parsers.FileParserFactory import createFileParser
FP = createFileParser('xml')
tmpProp, tmpFact, tmpMisc = FP.parse(inFileXml)
if ('image_type' in tmpProp and tmpProp['image_type'] == 'dem'):
inImage = createDemImage()
else:
inImage = createImage()
inImage.load(inFileXml)
inImage.filename = inFile
lkObj = Looks()
lkObj.setDownLooks(inps.azlooks)
lkObj.setAcrossLooks(inps.rglooks)
lkObj.setInputImage(inImage)
lkObj.setOutputFilename(outFile)
lkObj.looks()
return outFile
look(longitude, multilookLongitude, width, numberRangeLooks2,
numberAzimuthLooks2, 3, 0, 1)
look(height, multilookHeight, width, numberRangeLooks2,
numberAzimuthLooks2, 3, 0, 1)
#creat xml
create_xml(multilookLatitude, width2, length2, 'double')
create_xml(multilookLongitude, width2, length2, 'double')
create_xml(multilookHeight, width2, length2, 'double')
#los has two bands, use look program in isce instead
#cmd = "looks.py -i {} -o {} -r {} -a {}".format(self._insar.los, self._insar.multilookLos, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2)
#runCmd(cmd)
#replace the above system call with function call
from mroipac.looks.Looks import Looks
from isceobj.Image import createImage
inImage = createImage()
inImage.load(los + '.xml')
lkObj = Looks()
lkObj.setDownLooks(numberAzimuthLooks2)
lkObj.setAcrossLooks(numberRangeLooks2)
lkObj.setInputImage(inImage)
lkObj.setOutputFilename(multilookLos)
lkObj.looks()
#water body
#this looking operation has no problems where there is only water and land, but there is also possible no-data area
#look(self._insar.wbdOut, self._insar.multilookWbdOut, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 0, 0, 1)
#create_xml(self._insar.multilookWbdOut, width2, length2, 'byte')
#use waterBodyRadar instead to avoid the problems of no-data pixels in water body
waterBodyRadar(multilookLatitude, multilookLongitude, wbdFile,
def createImages(self):
if self.rangeImageName:
self.rangeImage = createImage()
self.rangeImage.setFilename(self.rangeImageName)
self.rangeImage.setAccessMode('write')
if self.outputPrecision.upper() == 'SINGLE':
self.rangeImage.setDataType('FLOAT')
self.rangeImage.setCaster('write', 'DOUBLE')
elif self.outputPrecision.upper() == 'DOUBLE':
self.rangeImage.setDataType('DOUBLE')
else:
raise Exception('Undefined output precision for range image in geo2rdr.')
self.rangeImage.setWidth(self.demWidth)
self.rangeImage.createImage()
if self.rangeOffsetImageName:
self.rangeOffsetImage = createImage()
self.rangeOffsetImage.setFilename(self.rangeOffsetImageName)
self.rangeOffsetImage.setAccessMode('write')
if self.outputPrecision.upper() == 'SINGLE':
self.rangeOffsetImage.setDataType('FLOAT')
self.rangeOffsetImage.setCaster('write', 'DOUBLE')
elif self.outputPrecision.upper() == 'DOUBLE':
self.rangeOffsetImage.setDataType('DOUBLE')
else:
raise Exception('Undefined output precision for range offset image in geo2rdr.')
self.rangeOffsetImage.setWidth(self.demWidth)
self.rangeOffsetImage.createImage()
if self.azimuthImageName:
self.azimuthImage = createImage()
self.azimuthImage.setFilename(self.azimuthImageName)
self.azimuthImage.setAccessMode('write')
if self.outputPrecision.upper() == 'SINGLE':
self.azimuthImage.setDataType('FLOAT')
self.azimuthImage.setCaster('write', 'DOUBLE')
elif self.outputPrecision.upper() == 'DOUBLE':
self.azimuthImage.setDataType('DOUBLE')
else:
raise Exception('Undefined output precision for azimuth image in geo2rdr.')
self.azimuthImage.setWidth(self.demWidth)
self.azimuthImage.createImage()
if self.azimuthOffsetImageName:
self.azimuthOffsetImage = createImage()
self.azimuthOffsetImage.setFilename(self.azimuthOffsetImageName)
self.azimuthOffsetImage.setAccessMode('write')
if self.outputPrecision.upper() == 'SINGLE':
self.azimuthOffsetImage.setDataType('FLOAT')
self.azimuthOffsetImage.setCaster('write', 'DOUBLE')
elif self.outputPrecision.upper() == 'DOUBLE':
self.azimuthOffsetImage.setDataType('DOUBLE')
else:
raise Exception('Undefined output precision for azimuth offset image in geo2rdr.')
self.azimuthOffsetImage.setWidth(self.demWidth)
self.azimuthOffsetImage.createImage()
self.polyDopplerAccessor = self.polyDoppler.exportToC()
def geocoding(inputf, outputf, inps):
inImage = createImage()
inImage.load(inputf + '.xml')
inImage.filename = inputf
width = inImage.width
length = inImage.length
scheme = inImage.scheme
nbands = inImage.bands
print("number of bands : {}".format(nbands))
datatype = inImage.dataType
latImage = createImage()
latImage.load(inps.lat + '.xml')
latImage.filename = inps.lat
lonImage = createImage()
lonImage.load(inps.lon + '.xml')
lonImage.filename = inps.lon
if width != latImage.width or width != lonImage.width:
raise Exception('file width are different!')
if length != latImage.length or length != latImage.length:
raise Exception('file length are different!')
#convert to degrees
sample_size = inps.ssize / 3600.0
sample_size_lat = sample_size
sample_size_lon = sample_size
print("geocoding sample size: {} [arcsec]".format(inps.ssize))
print("geocoding sample size: {} [degree]".format(sample_size))
if inps.rmethod == 0:
rmethod = 'nearest'
elif inps.rmethod == 1:
rmethod = 'linear'
elif inps.rmethod == 2:
rmethod = 'cubic'
else:
raise Exception('unknow resampling method!')
print("interpolation method: {}".format(rmethod))
if inps.bbox:
bbox = [float(val) for val in inps.bbox.split(',')]
bbox = (bbox[0], bbox[1], bbox[2], bbox[3])
else:
bbox = (0, 0, 0, 0)
print("reading data to be geocoded")
bands = read_bands(inputf, length, width, scheme, nbands, datatype)
#get latitude
print("reading latitude")
lat = read_bands(inps.lat, length, width, latImage.scheme, latImage.bands,
latImage.dataType)
lat = lat[0]
lat2 = np.asarray(lat)
lat2[lat2 == 0] = np.nan
lat2 = np.reshape(lat2, [length, width])
win2 = np.ones((5, 5)) / 25
lat2m = conv2(lat2, win2, 'same')
lat2m = lat2m.flatten()
lat2 = lat2.reshape(length * width)
#get longitude
print("reading longitude")
lon = read_bands(inps.lon, length, width, lonImage.scheme, lonImage.bands,
lonImage.dataType)
lon = lon[0]
lon2 = lon
lon2[lon2 == 0] = np.nan
latlon = np.zeros((length * width, 2), dtype=np.float64)
lat = lat.reshape(length * width)
lon = lon.reshape(length * width)
diffll = np.abs(lat2 - lat2m)
diffll[np.isnan(diffll)] = 0
lat2[lat2 == 0] = np.nan
if bbox[0] == 0:
mask = (diffll > 0.1) | (np.isnan(lat2)) | (np.isnan(lat2m)) | (
np.isnan(bands[0].reshape(length * width)))
else:
latlonmask = (lat > bbox[0]) & (lat < bbox[1]) & (lon > bbox[2]) & (
lon < bbox[3])
mask = (diffll > 0.1) | (np.isnan(lat2)) | (np.isnan(lat2m)) | (
np.isnan(bands[0].reshape(length * width))) | np.invert(latlonmask)
lat = lat[mask == 0]
lon = lon[mask == 0]
if bbox[0] == 0 and bbox[1] == 0 and bbox[2] == 0 and bbox[3] == 0:
bbox = (np.nanmin(lat), np.nanmax(lat), np.nanmin(lon), np.nanmax(lon))
print("geocode bounding box:")
print("south: {}".format(bbox[0]))
print("north: {}".format(bbox[1]))
print("west: {}".format(bbox[2]))
print("east: {}".format(bbox[3]))
latlon = np.zeros((len(lat), 2), dtype=np.float64)
latlon[:, 0] = lat
latlon[:, 1] = lon
bands2 = np.zeros((nbands, len(lat)), dtype=np.float32)
for i in range(nbands):
temp = bands[i].reshape(length * width)
bands2[i] = temp[mask == 0]
# n s w e
grid_lat, grid_lon = np.mgrid[bbox[1]:bbox[0]:-sample_size_lat,
bbox[2]:bbox[3]:sample_size_lon]
msk = np.zeros([length, width])
msk[0:2, :] = 1
msk[-2:, :] = 1
msk[:, -2:] = 1
msk[:, 0:2] = 1
msk = msk.reshape(length * width)
msk = msk[mask == 0]
geomsk = griddata(latlon,
msk, (grid_lat, grid_lon),
method=rmethod,
fill_value=0.0)
print("interpolate input data")
bands_geo = []
for i in range(nbands):
geoband = griddata(latlon, (bands2[i]), (grid_lat, grid_lon),
method=rmethod,
fill_value=0.0)
bands_geo.append(np.multiply(geoband, (geomsk == 0)))
print("write result")
(length_geo, width_geo) = geoband.shape
write_bands(outputf, length_geo, width_geo, scheme, nbands, datatype,
bands_geo)
outImage = inImage
outImage.setFilename(outputf)
outImage.setWidth(width_geo)
outImage.setLength(length_geo)
outImage.coord2.coordDescription = 'Latitude'
outImage.coord2.coordUnits = 'degree'
outImage.coord2.coordStart = bbox[1]
outImage.coord2.coordDelta = -sample_size_lat
outImage.coord1.coordDescription = 'Longitude'
outImage.coord1.coordUnits = 'degree'
outImage.coord1.coordStart = bbox[2]
outImage.coord1.coordDelta = sample_size_lon
outImage.renderHdr()
cmdline = "gdal_translate {} {}".format(outputf + ".vrt",
outputf + ".tif")
os.system(cmdline)
inps.lat = os.path.basename(inps.lat)
if not os.path.isfile(os.path.basename(inps.lon)):
lon_cd = 1
os.symlink(inps.lon, os.path.basename(inps.lon))
shutil.copyfile(inps.lon + '.xml', os.path.basename(inps.lon) + '.xml')
inps.lon = os.path.basename(inps.lon)
##################################################################################################
cmd = 'isce2gis.py vrt -i ' + inps.input
runCmd(cmd)
cmd = 'isce2gis.py vrt -i ' + inps.lat
runCmd(cmd)
cmd = 'isce2gis.py vrt -i ' + inps.lon
runCmd(cmd)
inImage = createImage()
inImage.load(inps.input + '.xml')
latImage = createImage()
latImage.load(inps.lat + '.xml')
lonImage = createImage()
lonImage.load(inps.lon + '.xml')
width = inImage.width
length = inImage.length
if width != latImage.width or width != lonImage.width:
raise Exception('file widths are different!')
if length != latImage.length or length != latImage.length:
raise Exception('file lengths are different!')
lat_shift = 'lat.tmp'
lon_shift = 'lon.tmp'
def runLook(self):
'''take looks
'''
catalog = isceobj.Catalog.createCatalog(self._insar.procDoc.name)
self.updateParamemetersFromUser()
#referenceTrack = self._insar.loadTrack(reference=True)
#secondaryTrack = self._insar.loadTrack(reference=False)
wbdFile = os.path.abspath(self._insar.wbd)
insarDir = 'insar'
os.makedirs(insarDir, exist_ok=True)
os.chdir(insarDir)
amp = isceobj.createImage()
amp.load(self._insar.amplitude + '.xml')
width = amp.width
length = amp.length
width2 = int(width / self._insar.numberRangeLooks2)
length2 = int(length / self._insar.numberAzimuthLooks2)
if not ((self._insar.numberRangeLooks2 == 1) and
(self._insar.numberAzimuthLooks2 == 1)):
#take looks
look(self._insar.differentialInterferogram,
self._insar.multilookDifferentialInterferogram, width,
self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 4,
0, 1)
look(self._insar.amplitude, self._insar.multilookAmplitude, width,
self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 4,
1, 1)
look(self._insar.latitude, self._insar.multilookLatitude, width,
self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3,
0, 1)
look(self._insar.longitude, self._insar.multilookLongitude, width,
self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3,
0, 1)
look(self._insar.height, self._insar.multilookHeight, width,
self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 3,
0, 1)
#creat xml
create_xml(self._insar.multilookDifferentialInterferogram, width2,
length2, 'int')
create_xml(self._insar.multilookAmplitude, width2, length2, 'amp')
create_xml(self._insar.multilookLatitude, width2, length2, 'double')
create_xml(self._insar.multilookLongitude, width2, length2, 'double')
create_xml(self._insar.multilookHeight, width2, length2, 'double')
#los has two bands, use look program in isce instead
#cmd = "looks.py -i {} -o {} -r {} -a {}".format(self._insar.los, self._insar.multilookLos, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2)
#runCmd(cmd)
#replace the above system call with function call
from mroipac.looks.Looks import Looks
from isceobj.Image import createImage
inImage = createImage()
inImage.load(self._insar.los + '.xml')
lkObj = Looks()
lkObj.setDownLooks(self._insar.numberAzimuthLooks2)
lkObj.setAcrossLooks(self._insar.numberRangeLooks2)
lkObj.setInputImage(inImage)
lkObj.setOutputFilename(self._insar.multilookLos)
lkObj.looks()
#water body
#this looking operation has no problems where there is only water and land, but there is also possible no-data area
#look(self._insar.wbdOut, self._insar.multilookWbdOut, width, self._insar.numberRangeLooks2, self._insar.numberAzimuthLooks2, 0, 0, 1)
#create_xml(self._insar.multilookWbdOut, width2, length2, 'byte')
#use waterBodyRadar instead to avoid the problems of no-data pixels in water body
waterBodyRadar(self._insar.multilookLatitude,
self._insar.multilookLongitude, wbdFile,
self._insar.multilookWbdOut)
os.chdir('../')
catalog.printToLog(logger, "runLook")
self._insar.procDoc.addAllFromCatalog(catalog)
