Beispiel #1
0
def seed_file(File,outName,refList,ref_x='',ref_y=''):
    ## Seed Input File with reference value in refList
    print 'Reference value: '
    print refList

    #####  IO Info
    atr = readfile.read_attributes(File)
    k = atr['FILE_TYPE']
    print 'file type: '+k

    ##### Multiple Dataset File
    if k in ['timeseries','interferograms','wrapped','coherence']:
        ##### Input File Info
        h5file = h5py.File(File,'r')
        epochList = h5file[k].keys()
        epochList = sorted(epochList)
        epochNum  = len(epochList)
        print 'number of epochs: '+str(epochNum)
        
        ##### Check Epoch Number
        if not epochNum == len(refList):
            print '\nERROR: Reference value has different epoch number'+\
                  'from input file.'
            print 'Reference List epoch number: '+str(refList)
            print 'Input file     epoch number: '+str(epochNum)
            sys.exit(1)
  
        ##### Output File Info
        h5out = h5py.File(outName,'w')
        group = h5out.create_group(k)
        print 'writing >>> '+outName

    ## Loop
    if k == 'timeseries':
        for i in range(epochNum):
            epoch = epochList[i]
            print epoch
            data = h5file[k].get(epoch)[:]
            
            data -= refList[i]
  
            dset = group.create_dataset(epoch, data=data, compression='gzip')

        atr  = seed_attributes(atr,ref_x,ref_y)
        for key,value in atr.iteritems():   group.attrs[key] = value

    elif k in ['interferograms','wrapped','coherence']:
        for i in range(epochNum):
            epoch = epochList[i]
            #print epoch
            data = h5file[k][epoch].get(epoch)[:]
            atr  = h5file[k][epoch].attrs

            data -= refList[i]
            atr  = seed_attributes(atr,ref_x,ref_y)

            gg = group.create_group(epoch)
            dset = gg.create_dataset(epoch, data=data, compression='gzip')
            for key, value in atr.iteritems():    gg.attrs[key] = value

            ut.printProgress(i+1,epochNum,'seeding:',epoch)
  
    ##### Single Dataset File
    else:
        data,atr = readfile.read(File)

        data -= refList
        atr  = seed_attributes(atr,ref_x,ref_y)

        writefile.write(data,atr,outName)
  
    ##### End & Cleaning
    try:
        h5file.close()
        h5out.close()
    except: pass

    return 1
Beispiel #2
0
def main(argv):

    ## Default value
    phase_velocity = "no"  # 'no' means use 'phase history'
    update_timeseries = "yes"

    if len(sys.argv) > 2:
        try:
            opts, args = getopt.getopt(argv, "h:f:F:o:v:", ["phase-velocity", "no-timeseries-update"])
        except getopt.GetoptError:
            print "Error in reading input options!"
            Usage()
            sys.exit(1)

        for opt, arg in opts:
            if opt in ["-h", "--help"]:
                Usage()
                sys.exit()
            elif opt == "-f":
                timeSeriesFile = arg
            elif opt == "-F":
                igramsFile = arg
            elif opt == "-o":
                outname = arg
            elif opt == "--phase-velocity":
                phase_velocity = "yes"
            elif opt == "--no-timeseries-update":
                update_timeseries = "no"

    elif len(sys.argv) == 2:
        if argv[0] in ["-h", "--help"]:
            Usage()
            sys.exit(1)
        else:
            timeSeriesFile = argv[0]
    else:
        Usage()
        sys.exit(1)

    try:
        outname
    except:
        outname = timeSeriesFile.replace(".h5", "") + "_demCor.h5"

    ##### Read Time Series
    print "\n*************** Topographic Error Correction ****************"
    print "Loading time series: " + timeSeriesFile
    atr = readfile.read_attributes(timeSeriesFile)
    h5timeseries = h5py.File(timeSeriesFile)
    dateList = h5timeseries["timeseries"].keys()
    dateList = sorted(dateList)
    lt = len(dateList)
    print "number of epochs: " + str(lt)

    dateIndex = {}
    for ni in range(len(dateList)):
        dateIndex[dateList[ni]] = ni

    nrows = int(atr["FILE_LENGTH"])
    ncols = int(atr["WIDTH"])
    timeseries = np.zeros((len(dateList), nrows * ncols), np.float32)
    for date in dateList:
        print date
        d = h5timeseries["timeseries"].get(date)[:]
        timeseries[dateIndex[date]][:] = d.flatten("F")
    del d
    h5timeseries.close()
    print "**************************************"

    ##### Temporal Baseline
    print "read temporal baseline"
    tbase, date_dict = ptime.date_list2tbase(dateList)
    tbase = np.array(tbase).reshape(lt, 1)

    ##### Perpendicular Baseline
    try:
        Bp = [float(i) for i in atr["P_BASELINE_TIMESERIES"].split()]
        Bp = np.array(Bp).reshape(lt, 1)
    except:
        print "Cannot find P_BASELINE_TIMESERIES from timeseries file."
        print "Trying to calculate it from interferograms file"
        try:
            Bp = ut.Baseline_timeseries(igramsFile)
            Bp = np.array(Bp).reshape(lt, 1)
        except:
            print "Error in calculating baseline time series!"
            sys.exit(1)
    Bp_v = (Bp[1:lt] - Bp[0 : lt - 1]) / (tbase[1:lt] - tbase[0 : lt - 1])

    ##### Cubic Temporal Deformation Model
    ## Formula (10) in (Fattahi and Amelung, 2013, TGRS)
    if phase_velocity == "yes":
        print "using phase velocity history"
        M1 = np.ones((lt - 1, 1))
        M2 = (tbase[1:lt] + tbase[0 : lt - 1]) / 2
        M3 = (tbase[1:lt] ** 2 + tbase[1:lt] * tbase[0 : lt - 1] + tbase[0 : lt - 1] ** 2) / 6
        M = np.hstack((M1, M2, M3))
    else:
        print "using phase history"
        M = np.hstack((0.5 * tbase ** 2, tbase, np.ones((lt, 1))))

    ## Testing
    # teta = (tetaN+tetaF)/2
    # r = (rN+rF)/2
    # teta=19.658799999999999*np.pi/180
    # r=846848.2
    # Bperp=1000*np.random.random((lt,1))

    ##### Range and Look Angle
    near_range = float(atr["STARTING_RANGE1"])
    dR = float(atr["RANGE_PIXEL_SIZE"])
    r = float(atr["EARTH_RADIUS"])
    H = float(atr["HEIGHT"])
    far_range = near_range + dR * (ncols - 1)
    incidence_n = np.pi - np.arccos((r ** 2 + near_range ** 2 - (r + H) ** 2) / (2 * r * near_range))
    incidence_f = np.pi - np.arccos((r ** 2 + far_range ** 2 - (r + H) ** 2) / (2 * r * far_range))

    various_range = "yes"
    if various_range == "yes":
        range_x = np.linspace(near_range, far_range, num=ncols, endpoint="FALSE")
        look_angle_x = np.linspace(incidence_n, incidence_f, num=ncols, endpoint="FALSE")
    else:
        print "using center range and look angle to represent the whole area"
        center_range = (near_range + far_range) / 2
        center_look_angle = np.pi - np.arccos((r ** 2 + center_range ** 2 - (r + H) ** 2) / (2 * r * center_range))
        range_x = np.tile(center_range, ncols)
        look_angle_x = np.tile(center_look_angle, ncols)
    # C1_v = Bp_v / (center_range * np.sin(center_look_angle))
    # C1   = Bp   / (center_range * np.sin(center_look_angle))
    # timeseries_v = (timeseries[1:lt,:] - timeseries[0:lt-1,:]) / (tbase[1:lt] - tbase[0:lt-1])

    ##### Inversion column by column
    print "inversing using L2-norm minimization (unweighted least squares)..."
    dz = np.zeros([1, nrows * ncols])

    for i in range(ncols):
        ## Design Matrix Inversion
        C1_v = Bp_v / (range_x[i] * np.sin(look_angle_x[i]))
        C1 = Bp / (range_x[i] * np.sin(look_angle_x[i]))
        if phase_velocity == "yes":
            C = np.hstack((M, C1_v))
        else:
            C = np.hstack((M, C1))

        # print '    rank of the design matrix : '+str(np.linalg.matrix_rank(C))
        # if np.linalg.matrix_rank(C) == 4:  print '    design matrix has full rank'
        Cinv = np.linalg.pinv(C)

        ## (Phase) Velocity History
        ts_x = timeseries[:, i * nrows : (i + 1) * nrows]
        ts_xv = (ts_x[1:lt, :] - ts_x[0 : lt - 1, :]) / (tbase[1:lt] - tbase[0 : lt - 1])

        ## DEM error
        if phase_velocity == "yes":
            par = np.dot(Cinv, ts_xv)
        else:
            par = np.dot(Cinv, ts_x)
        dz_x = par[3].reshape((1, nrows))

        ## Update DEM error matrix and timeseries matrix
        dz[0][i * nrows : (i + 1) * nrows] = dz_x
        timeseries[:, i * nrows : (i + 1) * nrows] -= np.dot(C1, dz_x)

        ut.printProgress(i + 1, ncols)

    # dz[0][:] = par[3][:]
    dz = np.reshape(dz, [nrows, ncols], order="F")

    ########## Output - DEM error #######################
    # print '**************************************'
    # print 'writing DEM_error.hgt'
    # writefile.write_float32(dz,'DEM_error.hgt')
    # f = open('DEM_error.hgt.rsc','w')
    # f.write('FILE_LENGTH       '+str(int(nrows))+'\n')
    # f.write('WIDTH             '+str(int(ncols))+'\n')
    # print '**************************************'

    h5fileDEM = "DEM_error.h5"
    print "writing >>> " + h5fileDEM
    h5rmse = h5py.File(h5fileDEM, "w")
    group = h5rmse.create_group("dem")
    dset = group.create_dataset(os.path.basename("dem"), data=dz, compression="gzip")
    for key, value in atr.iteritems():
        group.attrs[key] = value
    group.attrs["UNIT"] = "m"
    print "**************************************"

    ########### Output - Corrected Time Series ##########
    if update_timeseries == "yes":
        print "writing >>> " + outname
        print "number of dates: " + str(len(dateList))

        h5timeseriesDEMcor = h5py.File(outname, "w")
        group = h5timeseriesDEMcor.create_group("timeseries")
        for i in range(len(dateList)):
            print dateList[i]
            d = np.reshape(timeseries[i][:], [nrows, ncols], order="F")
            dset = group.create_dataset(dateList[i], data=d, compression="gzip")
        # for date in dateList:
        #    print date
        #    if not date in h5timeseriesDEMcor['timeseries']:
        #        d = np.reshape(timeseries[dateIndex[date]][:],[nrows,ncols],order='F')
        #        dset = group.create_dataset(date, data=d, compression='gzip')
        for key, value in atr.iteritems():
            group.attrs[key] = value
        h5timeseriesDEMcor.close()
Beispiel #3
0
def main(argv):
    try:
        igramsFile = argv[0]
        timeSeriesFile = argv[1]
    except:
        Usage()
        sys.exit(1)

    try:
        tempCohFile = argv[2]
    except:
        tempCohFile = "temporal_coherence.h5"

    ########################################################
    print "\n********** Temporal Coherence ****************"
    print "load time series: " + timeSeriesFile
    atr_ts = readfile.read_attributes(timeSeriesFile)
    h5timeseries = h5py.File(timeSeriesFile)
    dateList = h5timeseries["timeseries"].keys()
    numDates = len(dateList)

    print "number of epoch: " + str(numDates)
    dateIndex = {}
    for ni in range(numDates):
        dateIndex[dateList[ni]] = ni

    dset = h5timeseries["timeseries"].get(h5timeseries["timeseries"].keys()[0])
    nrows, ncols = np.shape(dset)
    timeseries = np.zeros((len(h5timeseries["timeseries"].keys()), np.shape(dset)[0] * np.shape(dset)[1]), np.float32)

    for i in range(numDates):
        date = dateList[i]
        dset = h5timeseries["timeseries"].get(date)
        d = dset[0 : dset.shape[0], 0 : dset.shape[1]]
        timeseries[dateIndex[date]][:] = d.flatten(0)
        ut.printProgress(i + 1, numDates, "loading:", date)
    del d
    h5timeseries.close()

    lt, numpixels = np.shape(timeseries)
    range2phase = -4 * np.pi / float(atr_ts["WAVELENGTH"])
    timeseries = range2phase * timeseries

    ######################################################
    print "load interferograms: " + igramsFile
    h5igrams = h5py.File(igramsFile)
    ifgramList = h5igrams["interferograms"].keys()
    numIfgrams = len(ifgramList)
    print "number of epochs: " + str(numIfgrams)
    A, B = design_matrix(h5igrams)
    p = -1 * np.ones([A.shape[0], 1])
    Ap = np.hstack((p, A))

    print "calculating temporal coherence ..."
    # data = np.zeros((numIfgrams,numpixels),np.float32)
    qq = np.zeros(numpixels) + 0j
    for ni in range(numIfgrams):
        ## read interferogram
        igram = ifgramList[ni]
        dset = h5igrams["interferograms"][igram].get(igram)
        data = dset[0 : dset.shape[0], 0 : dset.shape[1]]
        data = data.flatten(0)

        ## calculate difference between observed and estimated data
        ## interferogram by interferogram, less memory, Yunjun - 2016.06.10
        dataEst = np.dot(Ap[ni, :], timeseries)
        dataDiff = data - dataEst
        qq += np.exp(1j * dataDiff)

        ## progress bar
        ut.printProgress(ni + 1, numIfgrams, "calculating:", igram)
    del timeseries, data, dataEst, dataDiff
    h5igrams.close()

    # qq=np.absolute(np.sum(np.exp(1j*dataDiff),0))/numIfgrams
    qq = np.absolute(qq) / numIfgrams
    Temp_Coh = np.reshape(qq, [nrows, ncols])

    ##### write temporal coherence file ####################
    print "writing >>> " + tempCohFile
    h5TempCoh = h5py.File(tempCohFile, "w")
    group = h5TempCoh.create_group("temporal_coherence")
    dset = group.create_dataset(os.path.basename("temporal_coherence"), data=Temp_Coh, compression="gzip")
    for key, value in atr_ts.iteritems():
        group.attrs[key] = value
    group.attrs["UNIT"] = "1"
    h5TempCoh.close()