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)