constants.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/constants.hh,v $  *
 * $Revision: 3.25 $                                            *
 * $Date: 2005/04/13 11:12:23 $                                 *
 * $Author: kampes $                                            *
 *                                                              *
 * Definitions of some global (external) structs +functions,    *
 * constants                                                    *
 * define: SWNAME SWVERSION                                     *
 * __GplusplusCOMPILER__ then implement T sqr(T), cause no ansi c++ *
 * pragma: aCC things (removed since v3.8)                      * 
 *                                                              *
 * CLASSES IN THIS FILE:                                        *
 *   - ellips:  struct + functions                              *
 *   - cn:      3D coordinates + functions                      *
 *   - window:  in matrices/files + functions                   *
 ****************************************************************/


#ifndef CONSTANTS_H
#define CONSTANTS_H

using namespace std;                    // BK 29-Mar-2003, new compiler?

#include "bk_messages.hh"
#include "refsystems.hh"        // ellips class
#include "cstring"              // strcpy for exceptions

//#if defined __GNUC__ && __GNUC__ >= 2
//#else
//#endif
// g++ -v -c processor.cc gives (ao):
// -D__GNUC__=2 -D__GNUG__=2 -D__GNUC_MINOR__=95
#include <cmath>                        // for pi (atan)
#include <complex>                      // default known complex type
#include <iostream>                     // cout etc.
#include <strstream>                  // for memory stream



// ====== Globals for messages to stdout ======
extern bk_messages TRACE;
extern bk_messages DEBUG;
extern bk_messages INFO;
extern bk_messages PROGRESS;
extern bk_messages WARNING;
extern bk_messages ERROR;
// _____ Macros for abbreviation ______
// ___ Note that useage could be like PRINT_ERROR(WARNING.get_str()) ___
// ___ (normally WARNING.rewind() required after this, but exited) ___
// ___                                PRINT_ERROR(".") ___
// ___ w/o the ";"  (since in an if/else construction without {}{}
// ___ it will otherwise crash ___
// ___ use TRACE_FUNCTION ONLY SIMPLE WITH CHAR ARRAY "dadsa" ___
#define TRACE_FUNCTION(s) {TRACE.reset();\
  TRACE<<"["<<__FILE__<<"["<<__LINE__<<"]]: "<<s<<ends;\
  TRACE.print();}//
//#define PRINT_ERROR(s) {printcpu(); WARNING.summary();\
//  ERROR.terminate(); char cp_s[256]; strcpy(cp_s,s); ERROR.reset();\
//  ERROR<<"["<<__FILE__<<"["<<__LINE__<<"]]: "<<cp_s<<ends; ERROR.print();}//
#define PRINT_ERROR(s) {ERROR.terminate(); char cp_s[256]; strcpy(cp_s,s); ERROR.reset();\
  ERROR<<"["<<__FILE__<<"["<<__LINE__<<"]]: "<<cp_s<<ends; ERROR.print();}//




// ====== Define name/version ======
#define SWNAME    "Doris (Delft o-o Radar Interferometric Software)"
//#define SWVERSION "Version 2.0"       // 4-Nov-99
//#define SWVERSION "Version 2.2"       // 23-Feb-00 DEM subtraction
//#define SWVERSION "Version 2.3"       // 05-Apr-00 rangefilter
//#define SWVERSION "Version 2.4"       // 22-Jun-00 makefile for g++ all versions
//#define SWVERSION "Version 2.5"       // 07-Jul-00 linux x86 byteorder
//#define SWVERSION "Version 2.5.1"     // 19-Jul-00 orbit class
//#define SWVERSION "Version 2.6"       // 26-Oct-00 dinsar
//#define SWVERSION "Version 3.0"       // ??-???-00 filtphase, filtazi, filtrange2
//#define SWVERSION "Version 3.1"       // 04-May-01 DEM radarcode formats, general impr.
//#define SWVERSION "Version 3.3"       // 06-FEb-02 BEEP, PREVIEW,
                                        // Cygwin, COMPREFDEM (april).
//#define SWVERSION "Version 3.4 (01-NOV-2002)" // azishift resample change
                                                // ...snaphu unwrap
//#define SWVERSION "Version 3.5 (03-APR-2003)" // compatible with g++ v3.2 c++ standard
//#define SWVERSION "Version 3.6 (15-JUN-2003)" // envisat interface.
//#define SWVERSION "Version 3.7 (02-SEP-2003)" // auto coregpm. example scripts geocoding
//#define SWVERSION "Version 3.8 (22-SEP-2003)" // added fftw lib, quicklook option of runscript
//#define SWVERSION "Version 3.9 (16-OKT-2003)" // mainly release under GPL
//#define SWVERSION "Version 3.10 (16-JAN-2004)"        // ovs, resample, ...
//#define SWVERSION "Version 3.11 (13-MAY-2004)"        // envisat bugfix, height card
//#define SWVERSION "Version 3.12 (13-AUG-2004)"        // mainly radarsat added
//#define SWVERSION "Version 3.13 (01-OCT-2004)"        // fleafixes
//#define SWVERSION "Version 3.14 (07-MAR-2005)"        // fixes fdc computation; .h -> .hh
#define SWVERSION "Version 3.15 (07-MAR-2005)"  // baseline class, exceptions


// ====== Typedefs for portability ======
typedef short int       int16;
typedef int             int32;
typedef unsigned int    uint;
typedef float           real4;
typedef double          real8;
typedef complex<int16>  compli16;
typedef complex<int32>  compli32;
typedef complex<real4>  complr4;
typedef complex<real8>  complr8;


// ====== Pragma/Include ======
//#ifndef __GplusplusCOMPILER__ // assume aCC (hp)
//  #pragma COPYRIGHT "Bert Kampes, DEOS, Delft University of Technology"
//  #pragma COPYRIGHT_DATE "1998-2003"
//  #pragma VERSIONID SWVERSION
//#endif


// ====== function: Type sqr(Type) not in stdlib math.h! ======
// ====== Possibly also for other compilers that have errors this define will fix it ===
// note though that this is not save casted
//#ifdef __GplusplusCOMPILER__
#ifdef __GNUC__
inline int16 sqr(int16 x) {return(x*x);}
inline int32 sqr(int32 x) {return(x*x);}
inline uint  sqr(uint  x) {return(x*x);}
inline real4 sqr(real4 x) {return(x*x);}
inline real8 sqr(real8 x) {return(x*x);}
#endif



// ====== Global constants ======
// ______ General constants ______
const real8     SOL             = 299792458.0;  // speed of light in m/s
const real8     EPS             = 1e-13;        // small number
const int32     NaN             = -999;         // Not a Number
const int32     Inf             =  99999;       // Infinity
const real8     PI              = real8(4)*atan(real8(1));
//const int16           EIGHTY          = 80;
const int16     EIGHTY          = 200;// 80 seems to short for ASAR filenames
const int16     ONE27           = 127;

// ______ Handy for software, IDs have to be enumerated (used in loop) ______
const int16     LOGID           = 1;            // general identifier for log
const int16     MASTERID        = 2;            // general identifier for master
const int16     SLAVEID         = 3;            // general identifier for slave
const int16     INTERFID        = 4;            // general identifier for interferogram
const int16     FORMATCI2       = 11;           // formatflag
const int16     FORMATCR4       = 12;           // formatflag
const int16     FORMATR4        = 13;           // formatflag
const int16     FORMATI2        = 14;           // formatflag
const int16     FORMATI2_BIGENDIAN = 17;        // formatflag
const int16     FORMATHGT       = 15;           // formatflag unwrapped band interleaved ampl(1)/phase(2)
const int16     FORMATR8        = 16;           // formatflag

// ______ product specifier ______
const int16     SLC_ERS         = 1;            // ERS
const int16     SLC_ASAR        = 2;            // ENVISAT
const int16     SLC_RSAT        = 3;            // RadarSAT (and Atlantis processor??)
const int16     SLC_JERS        = 4;            // JERS (ceos?)
// ______ processor specifier ______
const int16     SARPR_VMP       = 11;            // ESA PAFs SAR processor SLC
const int16     SARPR_ATL       = 12;            // Atlantis created SLC
const int16     SARPR_TUD       = 13;            // TUDelft processor created SLC

// ====== Unique method selectors for interpolation ======
// ====== For ASAR (only 5 points), spline is not good ======
const int16     ORB_SPLINE      = -11; // else degree of polynomial
const int16     ORB_DEFAULT     = -12; // [degree of polynomial=numpoints-1, max=5]



// ====== class cn for coordinates + functions ======
class cn                                // coordinates
  {
  public:
  real8         x,                      // 
                y,                      //
                z;                      //
  // ______ Constructors ______
  cn()
    {x=0.0; y=0.0; z=0.0;};
  cn(real8 Px, real8 Py, real8 Pz)
    {x=Px; y=Py; z=Pz;};
  // ______ Copy constructor ______
  cn(const cn& P)
    {x=P.x; y=P.y; z=P.z;};
  // ______ Destructor ______
  ~cn()
    {;};// nothing to destruct that isn't destructed automatically
  // ______ Operators ______
  inline cn& operator = (const cn &P)// assignment operator
    {if (this != &P) {x=P.x; y=P.y; z=P.z;} return *this;};
  inline cn& operator += (const cn &P)
    {x+=P.x; y+=P.y; z+=P.z; return *this;}
  inline cn& operator -= (const cn &P)
    {x-=P.x; y-=P.y; z-=P.z; return *this;}
  inline cn& operator *= (const real8 s)// multiply by scalar
    {x*=s; y*=s; z*=s; return *this;}
  inline cn& operator *= (const cn &P)
    {x*=P.x; y*=P.y; z*=P.z; return *this;}
  inline cn& operator /= (const real8 s)// divide by scalar
    {x/=s; y/=s; z/=s; return *this;}
  inline cn& operator /= (const cn &P)
    {x/=P.x; y/=P.y; z/=P.z; return *this;}
  inline cn operator + () // unary plus
    {return cn(x,y,z);};
  inline cn operator + (const cn &P) // binary plus
    {return cn(x,y,z)+=P;};
  inline cn operator - ()// unary min
    {return cn(-x, -y, -z);};
  inline cn operator - (const cn &P)// binary min
    {return cn(x,y,z)-=P;};
  inline cn operator * (const real8 s) // Q=P*s
    {return cn(x,y,z)*=s;};
  inline cn operator * (const cn &P) // Q=P*Q
    {return cn(x,y,z)*=P;};
  inline cn operator / (const real8 s) // Q=P/s
    {return cn(x,y,z)/=s;};
  inline cn operator / (const cn &P) // Q=P/Q
    {return cn(x,y,z)/=P;};
  inline bool operator == (const cn &P) const // isequal operator
    {return (P.x==x && P.y==y && P.z==z) ? true : false;}
  inline bool operator != (const cn &P) const // isnotequal operator
    {return (P.x==x && P.y==y && P.z==z) ? false : true;}
  // ______ Public function in struct ______
  inline real8 in(cn P) const           // scalar product: r=P.in(Q);
    {return x*P.x+y*P.y+z*P.z;}
  inline cn out(cn P) const             // cross product cn r=P.out(Q);
    {return cn(y*P.z-z*P.y, z*P.x-x*P.z, x*P.y-y*P.x);}
  inline real8 dist(cn P) const         // distance: d=P.dist(Q);
    {return sqrt(sqr(x-P.x)+sqr(y-P.y)+sqr(z-P.z));}
  inline cn min(cn P) const             // cn r=P.min(Q);
    {return cn(x-P.x, y-P.y, z-P.z);}
  inline real8 norm2() const            // n=P.norm2();
    {return sqr(x)+sqr(y)+sqr(z);}
  inline real8 norm() const             // n=P.norm();
    {return sqrt(sqr(x)+sqr(y)+sqr(z));}
  inline cn normalize() const           // cn R=P.normalize();
    {return cn(x,y,z)/norm();}
    //{const real8 n=norm(); return cn(x/n, y/n, z/n);}
  inline real8 angle(cn A) const        // angle=A.angle(B); //0,pi;
    {return acos(in(A)/(norm()*A.norm()));}
  inline cn scale(real8 val) const // scaling of a point by a scalar KKM-05
    {return cn(x*val, y*val, z*val);}
  inline void showdata() const     // displays a point by KKM-05 Mar 9, 2005
    {DEBUG << "cn.x=" << x << "; cn.y=" << y << "; cn.z=" << z; DEBUG.print();}
  // --- Test program for coordinate class ----------------------------
  // --- This test is executed in inittest() --------------------------
  inline void test()
    {
    // constructors
    cn X(1,2,3);
    DEBUG << "cn X(1,2,3): "; X.showdata();
    cn Y;
    DEBUG << "cn Y:          "; Y.showdata();
    Y.x=4; Y.y=5; Y.z=6;
    DEBUG << "Y.x=4;Y.y=5;Y.z=6: "; Y.showdata();
    cn Z=Y;
    DEBUG << "Z=Y:           "; Z.showdata();
    // operators
    Z*=X;
    DEBUG << "Z*=X:          "; Z.showdata();
    Z/=X;
    DEBUG << "Z/=X:          "; Z.showdata();
    Z+=X;
    DEBUG << "Z+=X:          "; Z.showdata();
    Z-=X;
    DEBUG << "Z-=X:          "; Z.showdata();
    // operators
    DEBUG << "X+Y:           ";  (X+Y).showdata();
    DEBUG << "X-Y:           ";  (X-Y).showdata();
    DEBUG << "X/Y:           ";  (X/Y).showdata();
    DEBUG << "X*Y:           ";  (X*Y).showdata();
    DEBUG << "+X:            ";   (+X).showdata();
    DEBUG << "-X:            ";   (-X).showdata();
    DEBUG << "X==Y:          " << (X==Y); DEBUG.print();
    DEBUG << "X!=Y:          " << (X!=Y); DEBUG.print();
    // functions
    DEBUG << "X.min(Y):      "; (X.min(Y)).showdata();
    DEBUG << "X.normalize(): "; (X.normalize()).showdata();
    DEBUG << "X.scale(5):    "; (X.scale(5)).showdata();
    DEBUG << "X.out(Y):      "; (X.out(Y)).showdata();
    DEBUG << "X.dist(Y):     " << X.dist(Y); DEBUG.print();
    DEBUG << "X.norm():      " << X.norm(); DEBUG.print();
    DEBUG << "X.norm2():     " << X.norm2(); DEBUG.print();
    DEBUG << "X.angle(Y):    " << X.angle(Y); DEBUG.print();
    DEBUG << "X.in(Y):       " << X.in(Y); DEBUG.print();
    }
  };



// ====== Struct ellips + functions ======
class input_ell                 // ellips a,b   
  {
  public:
  real8         a;                      // semi major
  real8         b;                      // semi minor
  real8         e2;                     // squared first  eccentricity (derived)
  real8         e2b;                    // squared second eccentricity (derived)
  char          name[EIGHTY];
  // ______ Default constructor ______
  input_ell()
    {a   = WGS84_A;
     b   = WGS84_B; 
     e2  = (sqr(a)-sqr(b))/sqr(a);
     e2b = (sqr(a)-sqr(b))/sqr(b);
     strcpy(name,"WGS84");
    }
  // ______ Copy constructor ______
  input_ell(const input_ell& ell)
    {a=ell.a; b=ell.b; e2=ell.e2; e2b=ell.e2b; strcpy(name,ell.name);};
  // ______ Destructor ______
  ~input_ell()
    {;};// nothing to destruct that isn't destructed automatically
  // ______ Public function in struct ______
  inline input_ell& operator = (const input_ell &ell)// assignment operator
    {if (this != &ell) 
      {a=ell.a; b=ell.b; e2=ell.e2; e2b=ell.e2b; strcpy(name,ell.name);}
     return *this;};
  inline void ecc1st_sqr()              // first ecc.
    {e2=(sqr(a)-sqr(b))/sqr(a);}
  inline void ecc2nd_sqr()              // second ecc.
    {e2b=(sqr(a)-sqr(b))/sqr(b);}
  inline void showdata() const     // displays a point by KKM-05 Mar 9, 2005
    {DEBUG << "ELLIPS: "  << name 
           << ": ell.a="  << a  << "; ell.b="   << b 
           << "; ell.e2=" << e2 << "; ell.e2b=" << e2b;
     DEBUG.print();
    }
  // --- Test program for coordinate class ----------------------------
  // --- This test is executed in inittest() --------------------------
  inline void test()
    {
    // constructors
    input_ell X;
    //DEBUG << "input_ell X:   " << X.showdata();
    DEBUG << "ELLIPS: "  << X.name 
          << ": X.a="  << X.a  << "; X.b="   << X.b 
          << "; X.e2=" << X.e2 << "; X.e2b=" << X.e2b;
    DEBUG.print();
    //input_ell Y=X;
    //DEBUG << "Y=X:           " << Y.showdata();
    }
  };



// ====== Struct window + functions ======
// ______ image starts at 1, matrix starts at 0 ______
class window                            // window file={1,N,1,N}
  {
  public:
  uint          linelo,                         // min. line coord.
                linehi,                         // max. line coord.
                pixlo,                          // min. pix coord.
                pixhi;                          // max. pix coord.
  // ______ Constructors ______
  window()
    {linelo=0; linehi=0; pixlo=0; pixhi=0;};
  window(uint ll, uint lh, uint pl, uint ph)
    {linelo=ll; linehi=lh; pixlo=pl; pixhi=ph;};
  // ______ Copy constructor ______
  window(const window& w)
    {linelo=w.linelo; linehi=w.linehi; pixlo=w.pixlo; pixhi=w.pixhi;};
  // ______ Destructor ______
  ~window()
    {;};// nothing to destruct that isn't destructed automatically
  // ______ Public function in struct ______
  inline void disp() const                      // show content
    {DEBUG << "window l0, lN, p0, pN: "
           << linelo << ", " << linehi << ", "
           << pixlo  << ", " << pixhi; DEBUG.print();}; //  << endl;}
  inline uint lines() const                     // return number of lines
    {return linehi-linelo+1;}
  inline uint pixels() const                    // return number of pixels
    {return pixhi-pixlo+1;}
  inline window& operator = (const window &X)// assignment operator
    {if (this != &X)
      {linelo=X.linelo;linehi=X.linehi;pixlo=X.pixlo;pixhi=X.pixhi;}
     return *this;};
  inline bool operator == (const window &X) const
    {return (linelo==X.linelo&&linehi==X.linehi &&
              pixlo==X.pixlo && pixhi==X.pixhi) ?   true : false;};
  inline bool operator != (const window &X) const
    {return (linelo==X.linelo&&linehi==X.linehi &&
              pixlo==X.pixlo && pixhi==X.pixhi) ?   false : true;};
  // --- Test program for coordinate class ----------------------------
  // --- This test is executed in inittest() --------------------------
  inline void test()
    {
    // constructors
    window X;
    DEBUG << "window X:      "; X.disp();
    window Y(11,21,103,114);
    DEBUG << "window Y(11,21,103,114): "; Y.disp();
    // functions
    X=Y;
    DEBUG << "X=Y:           "; X.disp();
    DEBUG << "X.lines():     " <<  X.lines(); DEBUG.print();
    DEBUG << "X.pixels():    " <<  X.pixels(); DEBUG.print();
    DEBUG << "X==Y:          " <<  (X==Y); DEBUG.print();
    DEBUG << "X!=Y:          " <<  (X!=Y); DEBUG.print();
    }
  };


#endif // CONSTANTS_H

---