coregistration.hh

Go to the documentation of this file.

/*
 * Copyright (c) 1999-2003 Bert Kampes
 * Copyright (c) 1999-2003 Delft University of Technology, The Netherlands
 *
 * This file is part of Doris, the Delft o-o radar interferometric software.
 *
 * Doris program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Doris is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Publications that contain results produced by the Doris software should
 * contain an acknowledgment. (For example: The interferometric processing
 * was performed using the freely available Doris software package developed
 * by the Delft Institute for Earth-Oriented Space Research (DEOS), Delft
 * University of Technology, or include a reference to: Bert Kampes and
 * Stefania Usai. \"Doris: The Delft Object-oriented Radar Interferometric
 * software.\" In: proceedings 2nd ITC ORS symposium, August 1999. (cdrom)).
 *
 */
/****************************************************************
 * $Source: /users/kampes/DEVELOP/DORIS/doris/src/RCS/coregistration.hh,v $
 * $Revision: 3.10 $
 * $Date: 2005/04/06 15:29:03 $
 * $Author: kampes $
 *
 * Routines for coregistration.
 ****************************************************************/


#ifndef COREGISTRATION_H
#define COREGISTRATION_H

#include "constants.hh"                 // typedefs
#include "readinput.hh"                 // input structs
#include "orbitbk.hh"                   // my orbit class, includes my matrix class
#include "slcimage.hh"                  // my slc image class
#include "productinfo.hh"               // my 'products' class
#include "bk_baseline.hh"               // my 'baseline' class



// ______ Prototypes ______
#ifdef __USE_VECLIB_LIBRARY__
// ______This typedef is needed for output of veclib routine cdot?______
typedef struct {real4 re,im;} STUPID_cr4;

extern "C" { void  cgemv (char*, int32*, int32*, complr4*, complr4*,  int32*,
                         complr4*, int32*,
                         complr4*, complr4*, int32*, int32); }

extern "C" { STUPID_cr4 cdotu (int32*, complr4*, int32*, complr4*, int32*); }
#endif

//  // ====== Inline functions ======
//  // ______ For resampling output ci2, this might be slow, make function
//  //        i16 myround(real4) to avoid overhead real() ______
//  inline compli16 cr4toci2(complr4 x)
//    { return compli16((x.real() > 0) ? short(x.real()+.5) : short(x.real()-.5),
//                  (x.imag() > 0) ? short(x.imag()+.5) : short(x.imag()-.5));}


// ====== Prototypes ======
// ______ Compute coarse coregistration ______
void coarseporbit(
        const input_ell         &ell,
        const slcimage  &master,
        const slcimage  &slave,
        orbit           &masterorbit,
        orbit           &slaveorbit,
        const BASELINE  &baseline);


// ______ Coarse coregistration ______
void coarsecorrel(
        const input_coarsecorr  &input, 
        const slcimage  &minfo,
        const slcimage  &sinfo);


// ______ Corr by fft ______
void coarsecorrelfft(
        const input_coarsecorr  &input, 
        const slcimage  &minfo,
        const slcimage  &sinfo);


// ______ Corr by fft ______
real4 corrfft( 
        const matrix<real4>     &magnitudeMaster,
        const matrix<real4>     &magnitudeMask,
        real4                   &offsetL,
        real4                   &offsetP);


// ______ Distribute nW windows over win ______
matrix<uint> distributepoints(
        real4                     numberofpoints,
        const window             &win);


// ______ Estimate offset based on consistency ______
void getoffset(
        const matrix<real4>     &Result,
        int32                   &offsetLines,
        int32                   &offsetPixels);



// ______ Fine coregistration ______
void finecoreg(
        const input_fine        &fineinput,
        const slcimage  &minfo,
        const slcimage  &sinfo);


// ______ Correlation with FFT ______
real4 coherencefft(
        const input_fine        &fineinput, 
        const matrix<complr4>   &Master,
        const matrix<complr4>   &Mask,
        real4                   &offsetL,
        real4                   &offsetP);


// ______ Correlation in space domain ______
real4 coherencespace(
        const input_fine        &fineinput, 
        const matrix<complr4>   &Master,
        const matrix<complr4>   &Mask,
        real4                   &offsetL,
        real4                   &offsetP);


// ______ Compute coregistration parameters ______
void coregpm(
        const window            &originalmaster,
        const char              *i_resfile,
        const input_coregpm     &coregpminput,
        uint                    oversamplingsfactor);


// ______ Read observations from file ______
matrix<real4> getofffile(
        const char              *file,
        real4                    threshold);


// ______ Resample slave ______
void resample(
        //const window            &originalmaster,
        const input_gen         &generalinput,
        const input_resample    &resampleinput,
        const slcimage          &master,
        const slcimage          &slave,
        //const productinfo     &interferogram,
        const matrix<real8>     &cpmL,
        const matrix<real8>     &cpmP);


// ______Interpolation kernals______
matrix<real4> cc4(const  matrix<real4> &x);
matrix<real4> cc6(const  matrix<real4> &x);
matrix<real4> ts6(const  matrix<real4> &x);
matrix<real4> ts8(const  matrix<real4> &x);
matrix<real4> ts16(const matrix<real4> &x);
matrix<real4> rect(const matrix<real4> &x);
matrix<real4> tri(const  matrix<real4> &x);
// ___ knab: oversampling factor of signal CHI, number of points N ___
matrix<real4> knab(const matrix<real4> &x, const real4 CHI, const int32 N);



#endif // COREGISTRATION_H

---