slcimage.cc

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/slcimage.cc,v $   *
 * $Revision: 3.26 $                                            *
 * $Date: 2005/04/22 11:30:15 $                                 *
 * $Author: kampes $                                            *
 *                                                              *
 * implementation of slc image class.                           *
 * - data filling/updating.                                     * 
 * - reading in matrices.                                       *
 * - etc.                                                       *
 #%// BK 14-Aug-2000                                            *
 ****************************************************************/


#include "constants.hh"                 // typedefs
#include "slcimage.hh"                  // declarations, constants.h
#include "ioroutines.hh"                // ?
#include "conversion.hh"                // deg2rad
#include "ioroutines.hh"                // filesize
#include "matrixbk.hh"                  // matrix
#include "exceptions.hh"                 // my exceptions class

#include <cstdio>                       // some compilers, remove function
#include <strstream>                    // for memory stream
#include <cstring>                      // strcat?
#include <ctime>                        // time
char *strptime(const char *s, const char  *format,  struct tm *tm);



/****************************************************************
 *    slcimage::constructor                                     *
 #%// Bert Kampes, 08-Apr-2005
 ****************************************************************/
slcimage::slcimage()
  {
  TRACE_FUNCTION("slcimage() (BK 14-Aug-2000)")
  DEBUG.print("initializing slcimage with ERS defaults");
  // ______Initialize______
  sensor                  = SLC_ERS;            // default (vs. SLC_ASAR, JERS, RSAT)
  sar_processor           = SARPR_VMP;          // (VMP (esa paf) or ATLANTIS or TUDELFT)
  approxcentreoriginal.x  = 0.;
  approxcentreoriginal.y  = 0.;
  approxcentreoriginal.z  = 0.;
  wavelength              = 0.0565646;          // [m] default ERS2
  t_azi1                  = 0.;                 // [s] sec of day
  t_range1                = 5.5458330/2.0e3;    // [s] one way, default ERS2
  prf                     = 1679.902;           // [Hz] default ERS2
  abw                     = 1378.0;             // [Hz] default ERS2
  f_DC_a0                 = 0.;                 // [Hz] default ERS2
  f_DC_a1                 = 0.;
  f_DC_a2                 = 0.;
  rsr2x                   = 18.9624680*2.0e6;   // [Hz] default ERS2
  rbw                     = 15.55e6;            // [Hz] default ERS2
  originalwindow.pixlo    = 0;
  originalwindow.pixhi    = 0;
  currentwindow.linelo    = 0;
  currentwindow.linehi    = 25000;              // set for normalization?
  currentwindow.pixlo     = 0;
  currentwindow.pixhi     = 5000;               // set for normalization?
  formatflag              = 0;
  originalwindow.linelo   = 1;
  originalwindow.pixlo    = 1;
  } // END slcimage::slcimage()




/****************************************************************
 *    slcimage::fillslcimage                                    *
 * Fills data of slscimage object, read from resultfile after   *
 * step readfiles.                                              *
 * Expects certain strings in outpfile.                         *
 *  Break loop and warn if not found but do not exit.           *
 *  Look in first 100 lines for strings, or return sooner.      *
 *  Use SI units (Hz,s,m).                                      *
 #%// BK 14-Aug-2000                                            *
 * added INFO for fDC.                                          *
 #%// BK 06-Nov-2000                                            *
 ****************************************************************/
void slcimage::fillslcimage(const char* file)
  {
  TRACE_FUNCTION("fillslcimage (BK 14-Aug-2000)")
  INFO << "Reading parameters from: " << file;
  INFO.print();

  // ______Open file______
  ifstream resfile(file, ios::in);
  bk_assert(resfile,file,__FILE__,__LINE__);

  // ______ Lookfor identifiers (strings) ______
  char  dummyline[ONE27];
  real8 latitude;
  real8 longitude;
  char  word[ONE27] = " ";
  uint  check       = 0;
  int32 linecounter = 0;
  // ______ BK test if this help for DEBUG etc. ______
  DEBUG << setiosflags(ios::fixed)
       << setprecision(8)
       << setiosflags(ios::showpoint);
       //<< setw(20);
  while(resfile && linecounter<1000)
    {
    ++linecounter;
    resfile.getline(dummyline,ONE27,'\n');              // next line
    resfile  >> word;                                   // read word

    if      (!strcmp(word,"Scene_centre_latitude:"))
      {
      resfile >> latitude;
      DEBUG << "[" << linecounter
           << "]: string: \"Scene_centre_latitude:\",      (derived) value: "
           << latitude;
      DEBUG.print();
      if (abs(latitude) > 90)
        WARNING.print("latitude larger than 90 degees?");
      check += 1;
      }

    else if (!strcmp(word,"Scene_centre_longitude:"))
      {
      resfile >> longitude;
      DEBUG << "[" << linecounter
           << "]: string: \"Scene_centre_longitude:\",     (derived) value: "
           << longitude;
      DEBUG.print();
      if (abs(longitude) > 360)
        WARNING.print("longitude larger than 360 degees?");
      check += 2;
      }

    else if (!strcmp(word,"Radar_wavelength"))          // (m):
      {
      resfile >> word >> wavelength;
      DEBUG << "[" << linecounter
           << "]: string: \"Radar_wavelength\",            (derived) value: "
           << wavelength;
      DEBUG.print();
      if (wavelength > 0.50)
        WARNING.print("wavelength is larger than 50 centimeter?");
      if (wavelength < 0.01)
        WARNING.print("wavelength is smaller than 1 centimeter?");
      check += 4;
      }

    else if (!strcmp(word,"Range_time_to_first_pixel"))
      {
      resfile >> word >> word >> t_range1;        // (2way) (ms):
      t_range1 /= 2000.;                          // 1 way, s
      DEBUG << "[" << linecounter
           << "]: string: \"Range_time_to_first_pixel\",   (derived) value: "
           << t_range1;
      DEBUG.print();
      check += 8;
      }

    else if (!strcmp(word,"First_pixel_azimuth_time"))
      {
      struct tm tijdstart;
      char c12tijd0[13];
      char c12tijd0_tmp[16];// allow for .123456 ms ASAR in reading
      resfile >> word >> utc1 >> c12tijd0_tmp;  // (UTC): 26-JUL-1995 09:49:23.394
      // ______ utc1 should be including time ______
      // ______ make sure not to put in ms since what are the consequenses
      // ______ for getorb, strptime, etc. ______
      strncpy(c12tijd0,c12tijd0_tmp,12);
      c12tijd0[12]='\0';

      strcat(utc1," ");
      strcat(utc1,c12tijd0);

      // ______ Compute sec. of day for this date ______
      strptime(c12tijd0,"%T",&tijdstart);
      char c12frac0[20]="0.";
      register int32 i;
      for (i=0; i<20; i++)
        if (c12tijd0_tmp[i]=='.') break;
      int32 j = 2;
      while (c12tijd0_tmp[i] != '\0')                       // use old value of i
        {
        i++;
        c12frac0[j]=c12tijd0_tmp[i];
        j++;
        }
      t_azi1 = tijdstart.tm_sec +
                     atof(c12frac0) +
                     60 * tijdstart.tm_min +
                     3600 * tijdstart.tm_hour;
      DEBUG << "[" << linecounter
           << "]: string: \"First_pixel_azimuth_time\",    (derived) value: "
           << t_azi1;
      DEBUG.print();
      INFO << "sec of day of first azimuth line: " << t_azi1;
      INFO.print();
      check += 32;
      }

    else if (!strcmp(word,"Pulse_Repetition_Frequency"))
      {
      resfile >> word >> word >> prf;             // (computed, Hz):
      DEBUG << "[" << linecounter
           << "]: string: \"Pulse_Repetition_Frequency\",  (derived) value: "
           << prf;
      DEBUG.print();
      check += 128;
      }

    else if (!strcmp(word,"Range_sampling_rate"))
      {
      resfile >> word >> word >> rsr2x;           // (computed, MHz):
      rsr2x *= 2000000.;                          // 2 times in Hz
      DEBUG << "[" << linecounter
           << "]: string: \"Range_sampling_rate\",         (derived) value: "
           << rsr2x;
      DEBUG.print();
      check += 256;
      }

    else if (!strcmp(word,"Number_of_lines_original:"))
      {
      resfile >> originalwindow.linehi;
      DEBUG << "[" << linecounter
           << "]: string: \"Number_of_lines_original:\",   (derived) value: "
           << originalwindow.linehi;
      DEBUG.print();
      if (originalwindow.linehi > 100000)
        WARNING.print("more than 100000 lines?");
      check += 512;
      }

    else if (!strcmp(word,"Number_of_pixels_original:"))
      {
      resfile >> originalwindow.pixhi;
      DEBUG << "[" << linecounter
           << "]: string: \"Number_of_pixels_original:\",  (derived) value: "
           << originalwindow.pixhi;
      DEBUG.print();
      if (originalwindow.pixhi > 100000)
        WARNING.print("more than 100000 range pixels?");
      check += 1024;
      }

    else if (!strcmp(word,"Total_azimuth_band_width"))  // (Hz):
      {
      resfile >> word >> abw;
      DEBUG << "[" << linecounter
           << "]: string: \"Total_azimuth_band_width\",    (derived) value: "
           << abw;
      DEBUG.print();
      check += 2048;
      }
    else if (!strcmp(word,"Total_range_band_width"))    // (MHz):
      {
      resfile >> word >> rbw;
      rbw *= 1000000.;                            // (Hz)
      DEBUG << "[" << linecounter
           << "]: string: \"Total_range_band_width\",      (derived) value: "
           << rbw;
      DEBUG.print();
      check += 4096;
      }
    else if (!strcmp(word,"Xtrack_f_DC_constant"))      // (Hz, early edge):
      {
      resfile >> word >> word >> word >> f_DC_a0;// also works for ATL: 1.0E+02
      DEBUG << "[" << linecounter
           << "]: string: \"Xtrack_f_DC_constant\",        (derived) value: "
           << f_DC_a0;
      DEBUG.print();
      check += 8192;
      }
    else if (!strcmp(word,"Xtrack_f_DC_linear"))        // (Hz/s, early edge):
      {
      resfile >> word >> word >> word >> f_DC_a1;
      if (abs(f_DC_a1)<1.0)
        {
        WARNING << "Strange value for f_DC_a1: " << f_DC_a1 
                << "; setting f_DC_a1=0 (expected ~1e7)";
        WARNING.print();
        WARNING.print("other definition of ATLANTIS?");
        f_DC_a1 = 0.0;
        }
      DEBUG << "[" << linecounter
           << "]: string: \"Xtrack_f_DC_linear\",          (derived) value: "
           << f_DC_a1;
      DEBUG.print();
      check += 16384;
      }
    else if (!strcmp(word,"Xtrack_f_DC_quadratic"))     // (Hz/s/s, early edge):
      {
      resfile >> word >> word >> word >> f_DC_a2;
      if (abs(f_DC_a2)<1.0)
        {
        WARNING << "strange value for f_DC_a2: " << f_DC_a2 
                << "; setting f_DC_a2=0 (expected ~1e12)";
        WARNING.print();
        WARNING.print("other definition of ATLANTIS?");
        f_DC_a2 = 0.0;
        }
      DEBUG << "[" << linecounter
           << "]: string: \"Xtrack_f_DC_quadratic\",       (derived) value: "
           << f_DC_a2;
      DEBUG.print();
      check += 32768;
      }

    // SAR_PROCESSOR key added, written in readleader()
    // if you want to force behavior, change this in master.res
    else if (!strcmp(word,"SAR_PROCESSOR:"))     // VMP ATLANTIS TUD
      {
      resfile >> word;
      DEBUG << "[" << linecounter
           << "]: string: \"SAR_PROCESSOR:\",              (derived) value: "
           << word;
      DEBUG.print();
      if (!strcmp(word,"VMP"))
        {
        DEBUG.print("SAR_PROCESSOR: ESA VMP identified.");
        sar_processor = SARPR_VMP;
        }
      else if (!strcmp(word,"ATLANTIS"))
        {
        sar_processor = SARPR_ATL;
        DEBUG.print("SAR_PROCESSOR: ATLANTIS identified.");
        }
      else if (!strcmp(word,"TUD"))
        {
        sar_processor = SARPR_TUD;
        DEBUG.print("SAR_PROCESSOR: TUD identified.");
        }
      else
        {
        sar_processor = SARPR_VMP;
        WARNING.print("SAR_PROCESSOR: not identified, using VMP.");
        }
      check += 0;// do not check this..
      }
    // ______ 11.08.2002 BK, sensor specifier ers or asar? _____
    // ______ Product type specifier: "PRODUCT:ERS-2.SAR.SLC"
    // ______ Product type specifier: "ASAR"  (forced by me)
    // ______ Product type specifier: "JERS"  (???)
    // ______ Product type specifier: "RSAT"  (???)
    else if (!strcmp(word,"Product"))
      {
      resfile >> word >> word >> word;
      DEBUG << "[" << linecounter
           << "]: string: \"Product\",                     (derived) value: "
           << word;
      DEBUG.print();
      check += 65536;
      // Best find substring ERS, but don't know if strchr is standard.
      // We force ASAR as sensor string for this goal.
      // but now with JERS, ERS, RSAT, ASAR, we search a bit...  assume caps
      char *pch;
      pch = strstr (word,"PRODUCT");// Atlantis seems to put "PRODUCT:" or "PRODUCT"
      if (pch != NULL) 
        {
        sensor = SLC_ERS;// Atlantis processor; also ERS... assume  this
        DEBUG.print("Substring \"PRODUCT\" (radarsat?) found in Product type specifier.");
        char next_word[ONE27] = " ";
        resfile >> next_word;
        char *next_pch;
        next_pch = strstr (next_word,"ERS");
        if (next_pch != NULL) 
          {
          DEBUG.print("Substring \"PRODUCT ERS\" found in Product type specifier.");
          sensor = SLC_ERS;// Atlantis processor; also ERS...
          // assume reader for cropping is not as for RSAT...
          }
        next_pch = strstr (next_word,"RSAT");
        if (next_pch != NULL) 
          {
          DEBUG.print("Substring \"PRODUCT RSAT\" found in Product type specifier.");
          sensor        = SLC_RSAT;// Atlantis processor; also does RSAT
          WARNING.print("Assuming Atlantis processor was used/format of SLC.");
          WARNING.print("If you don;t want this, change line in res file to:");
          WARNING.print("Product type specifier:                         ERS");
          }
        }
      pch = strstr (word,"RSAT");
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"RSAT\" found in Product type specifier.");
        sensor = SLC_RSAT;
        WARNING.print("Assuming Atlantis processor was used/format of SLC.");
        WARNING.print("If you don;t want this, change line in res file to:");
        WARNING.print("Product type specifier:                         ERS");
        }
      pch = strstr (word,"RADARSAT");
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"RADARSAT\" found in Product type specifier.");
        sensor        = SLC_RSAT;
        WARNING.print("Assuming Atlantis processor was used/format of SLC.");
        WARNING.print("If you don;t want this, change line in res file to:");
        WARNING.print("Product type specifier:                         ERS");
        }
      pch = strstr (word,"ES");// envisat official abbrev?
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"ES\" found in Product type specifier.");
        sensor = SLC_ASAR;
        }
      pch = strstr (word,"ASAR");
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"ASAR\" found in Product type specifier.");
        sensor = SLC_ASAR;
        }
      pch = strstr (word,"ENVISAT");
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"ENVISAT\" found in Product type specifier.");
        sensor = SLC_ASAR;
        }
      pch = strstr (word,"ERS");// first ERS since ERS is substring of JERS
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"ERS\" found in Product type specifier.");
        sensor = SLC_ERS;
        }
      pch = strstr (word,"JERS");
      if (pch != NULL) 
        {
        DEBUG.print("Substring \"JERS\" found in Product type specifier.");
        sensor = SLC_JERS;
        }
      DEBUG << "Product/sensor: " << sensor;
      DEBUG.print();
      }

// ______ Check if all parameters are read ______
    if (check == 1+2+4+8+32+128+256+512+1024+2048+4096+8192+16384+32768+65536)
      break;
    } // while file and < 1000 lines

  if (check != 1+2+4+8+32+128+256+512+1024+2048+4096+8192+16384+32768+65536)
    {
    WARNING << "Cannot find parameters in first 1000 lines of file: "
         << file
         << ". checksum = " << check << ". (see source code)";
    WARNING.print();
    showdata();
    }
  resfile.close();

  // ____ ____
  DEBUG << "sensor id: " << sensor;
  DEBUG.print();
  if (sensor==SLC_ERS)
    {
    DEBUG.print("ERS 1 or 2 sensor detected.");
    if (abs(wavelength-0.0565646) > 0.01)
      WARNING.print("wavelength seems to deviates more than 1 cm from ERS2 nominal.");
    if (abs(prf - 1680) > 100.0)
      WARNING.print("prf deviates more than 100 Hz from ERS2 nominal.");
    if (abs(rsr2x - 18.9624680*2.0e6) > 100000.0)
      WARNING.print("rsr deviates more than 0.1 MHz from ERS2 nominal.");
    if (abs(abw-1378.0) > 100)
      WARNING.print("ABW deviates more than 100 Hz from ERS2 nominal?");
    if (abs(rbw-15.55e6) > 1000)
      WARNING.print("RBW deviates more than 1 kHz from ERS2 nominal?");
    }
  if (sensor==SLC_ASAR) 
    {
    INFO.print("Yeah, EnviSAT!");
    if (abs(wavelength-0.0562356) > 0.01)
      WARNING.print("wavelength seems to deviates more than 1 cm from ASAR nominal.");
    if (abs(prf-1652.0) > 100.0)
      WARNING.print("prf deviates more than 100 Hz from ASAR nominal.");
    if (abs(rsr2x - 19.207680*2.0e6) > 100000.0)
      WARNING.print("rsr deviates more than 0.1 MHz from ASAR nominal.");
    if (abs(abw-1316.0) > 100)
      WARNING.print("ABW deviates more than 100 Hz from ASAR nominal?");
    if (abs(rbw-16.0e6) > 1000)
      WARNING.print("RBW deviates more than 1 kHz from ASAR nominal?");
    }
  if (sensor==SLC_JERS)
    {
    WARNING.print("JERS detected: still in testing phase.");
    if (abs(wavelength-0.23076920) > 0.01)
      WARNING.print("wavelength seems to deviates more than 1 cm from JERS nominal.");
    if (abs(prf-1555.0) > 100.0)
      WARNING.print("prf deviates more than 100 Hz from JERS nominal.");
    if (abs(rsr2x - 17.075998*2.0e6) > 100000.0)
      WARNING.print("rsr deviates more than 0.1 MHz from JERS nominal.");
    if (abs(abw-1555.0) > 100)
      WARNING.print("ABW deviates more than 100 Hz from JERS nominal?");
    if (abs(rbw-17.075998*2.0e6) > 1000)
      WARNING.print("RBW deviates more than 1 kHz from JERS nominal?");
    }
  if (sensor==SLC_RSAT)
    {
    WARNING.print("RSAT detected: this is still in development.");
    WARNING.print(" +main difficulty with orbit in earth fixed system; doppler.");
    WARNING.print(" +but it seems to work with polyfit(max) for orbit interp.");
    }
  // ______ Some info for range ______
  INFO << setiosflags(ios::fixed)
       << setiosflags(ios::showpoint)
       << setprecision(3);
  INFO << "Range to pixel 1 = "
       << pix2range(1.0);
       //<< pix2range(1,t_range1,rsr2x);
  INFO.print();
  INFO << "Range to pixel " << originalwindow.pixhi << " = " 
       << pix2range(originalwindow.pixhi);
       //<< pix2range(originalwindow.pixhi,t_range1,rsr2x);
  INFO.print();


  // ______ Give some info on Doppler centroid frequency fDC ______
  // ______ x=pixelnumber/RSR [s]; fDC=a0+a1x+a2x^2 [Hz] ______
  const real8 earlyedgefDC = f_DC_a0;// tau=0.0
  // ______ extreme of: y=ax^2+bx+c, dy/dx=0 at -b/2a ______
  const real8 extremepix   = (abs(f_DC_a2)<1e-9) ? 0.0: f_DC_a1/(-2.0*f_DC_a2);
  const real8 extremefDC   = f_DC_a0 +
        extremepix  * f_DC_a1 +
    sqr(extremepix) * f_DC_a2;
  const real8 faredgefDC   = f_DC_a0 + 
        real8(originalwindow.pixhi-1)/(rsr2x/2.0)  * f_DC_a1 +
    sqr(real8(originalwindow.pixhi-1)/(rsr2x/2.0)) * f_DC_a2;
  DEBUG << setiosflags(ios::scientific)
           << setprecision(8)
           << setiosflags(ios::showpos);
  DEBUG << "fDC(col) = " 
       << f_DC_a0
       << f_DC_a1 << "*(col-1)/"
       << rsr2x/2
       << f_DC_a2 << "*((col-1)/"
       << rsr2x/2 << ")^2" << ends;
  DEBUG.print();
  DEBUG << "fDC(col) = "
       << f_DC_a0
       << f_DC_a1/(rsr2x/2)    << "*(col-1)"
       << f_DC_a2/sqr(rsr2x/2) << "*(col-1)^2" << ends;
  DEBUG.print();

  // --- ---
  INFO << "Doppler centroid frequency: at pixel 1 (early edge): \t\t"
       << earlyedgefDC;
  INFO.print();
  INFO << "Doppler centroid frequency: at pixel "
       << originalwindow.pixhi << " (far edge): \t"
       << faredgefDC;
  INFO.print();
  INFO << "Doppler centroid frequency: at pixel " << extremepix*rsr2x/2.;
  // better if b<0 then max or somthinfg like that
  (extremefDC >= earlyedgefDC) ? 
    INFO << " (maximum):  " : INFO << " (minimum):  ";
  INFO << "\t"
       << extremefDC;
  INFO.print();
  //const real8 minfDC = min(min(earlyedgefDC,faredgefDC),);
  //mean    fDC = ... (integral, decide max or min, etc., reshape to rectangle)

  INFO << "sensor: " << sensor;
  INFO.print();

  // ====== Tidy up ======
  pol2xyz(approxcentreoriginal,                   // convert lat/lon to xyz
          deg2rad(latitude),deg2rad(longitude),0.);     //  on sphere

  currentwindow.linelo = originalwindow.linelo;
  currentwindow.linehi = originalwindow.linehi;
  currentwindow.pixlo  = originalwindow.pixlo;
  currentwindow.pixhi  = originalwindow.pixhi;

#ifdef __DEBUG
  DEBUG.print("Finished fillslcimage");
  DEBUG.print("content of struct:");
  showdata();
#endif
  DEBUG.reset();
  INFO.reset();
  } // END slcimage::fillslcimage



/****************************************************************
 *    updateslcimage                                            *
 *                                                              *
 *  Fills struct slcimage after step identified by iden         *
 * input:                                                       *
 *  - resultfilename                                            *
 *  - identifier                                                *
 *  - struct slcimage                                           *
 * output:                                                      *
 *  - (updated) struct slcimage                                 *
 *      current size of image                                   *
 *                                                              *
 *    Bert Kampes, 22-Dec-1998                                  *
 * put in class.                                                *
#%// BK 14-Aug-2000                                             *
 ****************************************************************/
void slcimage::updateslcimage(
        const char *resultfile,
        const char *iden)
  {
  TRACE_FUNCTION("updateslcimage (BK 14-Aug-2000)")
  char                  word[ONE27]=" ";
  char                  dummyline[ONE27];

  // ______Open file______
  ifstream resfile(resultfile, ios::in);
  bk_assert(resfile,resultfile,__FILE__,__LINE__);

  bool foundiden = false;
  while(resfile)
    {
    if (strcmp(word,iden))                              // Lookfor identifier
      {
      resfile.getline(dummyline,ONE27,'\n');            // next line
      resfile >> word;                                  // read word
      }
    else
      {
      foundiden = true;
      DEBUG << "updateimaginfo: found identifier: \"" << iden
           << "\" in file: \"" << resultfile << "\".";
      DEBUG.print();
      break;
      }
    }

// ______Check if section has been found______
  if (!foundiden)
    {
    ERROR << "(updateimaginfo). identifier: "
         << iden
         << " not found in file: " << resultfile;
    PRINT_ERROR(ERROR.get_str())
    throw(file_error);
    }

// ======Extract info (filename and window size)======
  int32 check = 0;
  while(resfile)                                        // i.e. rest of file
    {
    resfile.getline(dummyline,ONE27,'\n');              // next line
    resfile  >> word;                                   // read word
    if (!strcmp(word,"Data_output_file:"))
      {
      resfile >> file;
      DEBUG << "string: \"Data_output_file:\",        \t\tvalue: "
           << file;
      DEBUG.print();
      check += 1;
      }
    else if (!strcmp(word,"Data_output_format:"))
      {
      resfile >> word;
      if (!strcmp(word,"complex_short"))
        formatflag = FORMATCI2;
      else if (!strcmp(word,"complex_real4"))
        formatflag = FORMATCR4;
      else
        {
        PRINT_ERROR("wrong format specifier (impossible?)")
        throw(file_error);
        }
      DEBUG << "string: \"Data_output_format:\",      \t\tvalue: "
           << formatflag;
      DEBUG.print();
      check += 1;
      }
    else if (!strcmp(word,"First_line"))                // (w.r.t. original):
      {
      resfile >> word >> word >> currentwindow.linelo;
      DEBUG << "string: \"First_line\",               \t\tvalue: "
           << currentwindow.linelo;
      DEBUG.print();
      check += 10;
      }
    else if (!strcmp(word,"Last_line"))                 // (w.r.t. original):
      {
      resfile >> word >> word >> currentwindow.linehi ;
      DEBUG << "string: \"Last_line\",                \t\tvalue: "
           << currentwindow.linehi;
      DEBUG.print();
      check += 100;
      }
    else if (!strcmp(word,"First_pixel"))               // (w.r.t. original):
      {
      resfile >> word >> word >> currentwindow.pixlo ;
      DEBUG << "string: \"First_pixel\",              \t\tvalue: "
           << currentwindow.pixlo;
      DEBUG.print();
      check += 1000;
      }
    else if (!strcmp(word,"Last_pixel"))                // (w.r.t. original):
      {
      resfile >> word >> word >> currentwindow.pixhi ;
      DEBUG << "string: \"Last_pixel\",               \t\tvalue: "
           << currentwindow.pixhi;
      DEBUG.print();
      check += 10000;
      }
    if (check == 11112) break;
    } // while file

  if (check != 11112)
    {
    char str[EIGHTY];
    strcpy(str,"???");
    if (check == 11110)
      strcpy(str,"Data_output_file:");
    else if (check == 11101)
      strcpy(str,"First_line");
    else if (check == 11011)
      strcpy(str,"Last_line");
    else if (check == 10111)
      strcpy(str,"First_pixel");
    else if (check == 01111)
      strcpy(str,"Last_pixel");
    ERROR << "Missing info: " << str
         << " file: " << file
         << ". checksum= " << check << ".";
    PRINT_ERROR(ERROR.get_str())
    throw(some_error);
    }

  // ______ Check filesize with format/dimensions (BK 08-Mar-2001) ______
  ifstream tmpfile(file, ios::in);
  if (tmpfile) 
    {
    tmpfile.seekg(0,ios::end); // internal filesize, normal one exists if not exists
    uint filesizetrue  = tmpfile.tellg();
    // not ok, error in bk_assert: uint filesizetrue  = filesize(file); 
    int32 bytesperelem = 4;
    if (formatflag==FORMATCI2) bytesperelem=4;
    if (formatflag==FORMATCR4) bytesperelem=8;
    if (formatflag==FORMATR4) bytesperelem=4;
    if (formatflag==FORMATI2) bytesperelem=2;
    if (formatflag==FORMATI2_BIGENDIAN) bytesperelem=2;
    if (formatflag==FORMATR8) bytesperelem=8;
    if (formatflag==FORMATHGT) bytesperelem=8;
    int32 filesizecomp = currentwindow.lines()*currentwindow.pixels()*bytesperelem;
    DEBUG << "Checking format/dimensions file=" << file;
    DEBUG.print();
    if (filesizecomp != filesizetrue)
      {
      WARNING << "Fileformat or dimensions seem wrong"
           << "; bytesperpix=" << bytesperelem
           << "; #l=" << currentwindow.lines()
           << "; #p=" << currentwindow.pixels()
           << "; size=" << filesizetrue
           << "; size computed=" << filesizecomp;
      WARNING.print();
      }
    else
      {
      DEBUG.print("Fileformat and dimensions checked ok.");
      }
    tmpfile.close();
    } // if stream ok
  else
    {
    WARNING << "File: " << file
         << " does not seem to exist (may not be a problem).";
    WARNING.print();
    }


  // ______Tidy up______
  resfile.close();
#ifdef __DEBUG
  DEBUG.print("Finished updateslcimage");
  DEBUG.print("content of struct:");
  showdata();
#endif
  } // END updateslcimage





/****************************************************************
 * slcimage::readdata                                          *
 *  read data from file in a complr4 matrix                     *
 *  file may be complex short or complex real4 format           *
 * stored in row major order, pixel interleaved                 *
 %// BK 14-Aug-2000                                             *
 ****************************************************************/
matrix<complr4> slcimage::readdata(
        window win) const               // window to be read
  {
  TRACE_FUNCTION("readdata (BK 14-Aug-2000)")
  matrix<complr4> Result(win.lines(),win.pixels());
  switch (formatflag)
    {
    case FORMATCI2:
      {
      fileci2tomatcr4(Result,file,currentwindow.lines(),win,currentwindow);
      break;
      }
    case FORMATCR4:
      {
      //matrix<complr4> -> readfile(Result,file,currentwindow.lines(),win,currentwindow);
      //matrix<complr4>::readfile(Result,file,currentwindow.lines(),win,currentwindow);
      //readfilebk(Result,file,currentwindow.lines(),win,currentwindow);
      //readfile(Result,file,currentwindow.lines(),win,currentwindow);
      //matrix<complr4>::readfile(Result,file,currentwindow.lines(),win,currentwindow);
      //matrix<complr4> R(10,10);
      //readfile(R,file,currentwindow.lines(),win,currentwindow);
      readfile(Result,file,currentwindow.lines(),win,currentwindow);
      break;
      }
    default:
      PRINT_ERROR("readdata::not correct format on file.")
      throw(file_error);
    }
  return Result;

  } // END readdata


//____RaffaeleNutricato START MODIFICATION SECTION 1
/****************************************************************
 *    updateslcimageML                                          *
 *                                                              *
 *  Fills struct slcimage after step identified by iden         *
 *  taking into account the multilook factors.                  *
 * input:                                                       *
 *  - resultfilename                                            *
 *  - identifier                                                *
 *  - struct slcimage                                           *
 * output:                                                      *
 *  - (updated) struct slcimage                                 *
 *      current size of image                                   *
 *                                                              *
 *    Raffaele Nutricato, 12-Jan-2004                           *
 *                                                              *
 ****************************************************************/
void slcimage::updateslcimageML(
        const char *resultfile,
        const char *iden)
  {
  TRACE_FUNCTION("updateslcimageML (Raffaele Nutricato 12-Jan-2004)")
  char                  word[ONE27]=" ";
  char                  dummyline[ONE27];

  INFO << "Reading parameters from: " << resultfile;
  INFO.print();


// ______Open file______
  ifstream resfile(resultfile, ios::in);
  bk_assert(resfile,resultfile,__FILE__,__LINE__);

  bool foundiden = false;
  while(resfile)
    {
    if (strcmp(word,iden))                              // Lookfor identifier
      {
      resfile.getline(dummyline,ONE27,'\n');            // next line
      resfile >> word;                                  // read word
      }
    else
      {
      foundiden = true;
      DEBUG << "updateimaginfo: found identifier: \"" << iden
           << "\" in file: \"" << resultfile << "\".";
      DEBUG.print();
      break;
      }
    }

// ______Check if section has been found______
  if (!foundiden)
    {
    ERROR << "(updateimaginfo). identifier: "
         << iden
         << " not found in file: " << resultfile;
    PRINT_ERROR(ERROR.get_str())
    throw(some_error);
    }

// ======Extract info (filename and window size)======
  int32 numlineschecked = 0;                    // number of lines checked after iden
  bool foundfilename    = false;
  bool foundfileformat  = false;
  bool foundfirstline   = false;
  bool foundlastline    = false;
  bool foundfirstpixel  = false;
  bool foundlastpixel   = false;
  bool foundmlL         = false;
  bool foundmlP         = false;

  float tmpmultilookL; 
  float tmpmultilookP;
  uint tmplinelo;
  uint tmplinehi;
  uint tmppixlo;
  uint tmppixhi;


  while(resfile)                                        // i.e. rest of file
    {
    numlineschecked++;
    resfile.getline(dummyline,ONE27,'\n');              // next line
    resfile  >> word;                                   // read word
    if (!strcmp(word,"Data_output_file:"))
      {
      if (!foundfilename)
        {
        foundfilename = true;
        resfile >> file;
        DEBUG << "string: \"Data_output_file:\",        \t\tvalue: "
              << file;
        DEBUG.print();
          }
      else
          WARNING.print("String: \"Data_output_file:\" found again (ignored).");
      }
    else if (!strcmp(word,"Data_output_format:"))
      {
      if (!foundfileformat)
        {
        foundfileformat = true;
        resfile >> word;
        if (!strcmp(word,"complex_short"))
          formatflag = FORMATCI2;
        else if (!strcmp(word,"complex_real4"))
          formatflag = FORMATCR4;
        else
          {
          PRINT_ERROR("wrong format specifier (impossible?)")
          throw(file_error);
          }
        DEBUG << "string: \"Data_output_format:\",      \t\tvalue: "
              << formatflag;
        DEBUG.print();
        }
      else
          WARNING.print("String: \"Data_output_format:\" found again (ignored).");
      }

    else if (!strcmp(word,"Multilookfactor_azimuth_direction:"))
      {
      if (!foundmlL)
        {
        foundmlL = true;
        resfile >> tmpmultilookL; 
        DEBUG << "String: \"Multilookfactor_azimuth_direction:\", value: "
                << tmpmultilookL;
        DEBUG.print();
        if (tmpmultilookL > 1)
          {
          PRINT_ERROR("Decimation of slc along azimuth direction not implemented yet.");
          throw(file_error);
          }
        }
      else
          WARNING.print("String: \"Multilookfactor_azimuth_direction:\" found again (ignored).");
      }
    else if (!strcmp(word,"Multilookfactor_range_direction:"))
      {
      if (!foundmlP)
        {
        foundmlP = true;
        resfile >> tmpmultilookP; // TOGLIMI SISTEMAMI
        DEBUG << "String: \"Multilookfactor_range_direction:\", \tvalue: "
              << tmpmultilookP;
        DEBUG.print();
        if (tmpmultilookP > 1)
          {
          PRINT_ERROR("Decimation of slc along range direction not implemented yet.");
          throw(file_error);
          }
        }
      else
          WARNING.print("String: \"Multilookfactor_range_direction:\" found again (ignored).");
      }
    else if (!strcmp(word,"First_line"))                // (w.r.t. original):
      {
      if (!foundfirstline)
        {
        foundfirstline = true;
        resfile >> word >> word >> tmplinelo;
        DEBUG << "string: \"First_line\",               \t\tvalue: "
              << tmplinelo;
        DEBUG.print();
        }
      else
        WARNING.print("String: \"First_line:\" found again (ignored).");
      }
    else if (!strcmp(word,"Last_line"))                 // (w.r.t. original):
      {
      if  (!foundlastline)
          {
        foundlastline = true;
        resfile >> word >> word >> tmplinehi ;
        DEBUG << "string: \"Last_line\",                \t\tvalue: "
              << tmplinehi;
        DEBUG.print();
        }
      else
        WARNING.print("String: \"Last_line:\" found again (ignored).");
      }
    else if (!strcmp(word,"First_pixel"))               // (w.r.t. original):
      {
      if (!foundfirstpixel)
          {
        foundfirstpixel = true;
        resfile >> word >> word >> tmppixlo ;
        DEBUG << "string: \"First_pixel\",              \t\tvalue: "
              << tmppixlo;
        DEBUG.print();
          }
      else
        WARNING.print("String: \"First_pixel:\" found again (ignored).");
      }
    else if (!strcmp(word,"Last_pixel"))                // (w.r.t. original):
      {
      if (!foundlastpixel)
        {
        foundlastpixel = true;
        resfile >> word >> word >> tmppixhi ;
        DEBUG << "string: \"Last_pixel\",               \t\tvalue: "
              << tmppixhi;
        DEBUG.print();
        }
      else
        WARNING.print("String: \"Last_pixel:\" found again (ignored).");
      }
    // ______ Check if everything has been found, or too much lines read ______
    if (foundfilename  && foundfileformat &&
        foundfirstline && foundlastline && foundfirstpixel && foundlastpixel &&
        foundmlL       && foundmlP) break; 
    } // while file

  if (!(foundfilename  && foundfileformat &&
      foundfirstline && foundlastline && foundfirstpixel && foundlastpixel &&
        foundmlL       && foundmlP))
    { 
    char str[EIGHTY];
    if (!foundfilename)
      strcpy(str,"Data_output_file:");
    else if (!foundfileformat)
      strcpy(str,"Data_output_format:");
    else if (!foundfirstline)
      strcpy(str,"First_line");
    else if (!foundlastline)
      strcpy(str,"Last_line");
    else if (!foundfirstpixel)
      strcpy(str,"First_pixel");
    else if (!foundlastpixel)
      strcpy(str,"Last_pixel");
    else if (!foundmlL)
      strcpy(str,"Multilookfactor_azimuth_direction:");
    else if (!foundmlP)
      strcpy(str,"Multilookfactor_range_direction:");
    ERROR << "Missing info: " << str
          << " file: " << file << ".";
    PRINT_ERROR(ERROR.get_str())
    throw(file_error);
    }

  // ______ Make changes to image parameters _____
  int32 osfactL = int32(1./tmpmultilookL+.5); 
  int32 osfactP = int32(1./tmpmultilookP+.5); 
WARNING.print("I assume abw and rbw should also be adapted?");
WARNING.print("Better use the above function, not copy of code???");
WARNING.print("is SARPROCESSOR defined here?");
WARNING.print("Bert Kampes, 20-Apr-2005");
  prf                     *= osfactL;
  rsr2x                   *= osfactP;
  currentwindow.linelo    = (tmplinelo-1)*osfactL+1;
  currentwindow.linehi    = tmplinehi*osfactL;
  currentwindow.pixlo     = (tmppixlo-1)*osfactP+1;
  currentwindow.pixhi     = tmppixhi*osfactP;
  originalwindow.linehi   *= osfactL;
  originalwindow.pixhi    *= osfactP;


  INFO << "Updated the following parameters: ";
  INFO.print();
  INFO << "First_line (w.r.t. original_image):       " << currentwindow.linelo;
  INFO.print();
  INFO << "Last_line (w.r.t. original_image):        " << currentwindow.linehi;
  INFO.print();
  INFO << "First_pixel (w.r.t. original_image):      " << currentwindow.pixlo;
  INFO.print();
  INFO << "Last_pixel (w.r.t. original_image):       " << currentwindow.pixhi;
  INFO.print();
  INFO << "Number_of_lines_original:                 " << originalwindow.linehi;
  INFO.print();
  INFO << "Number_of_pixels_original:                " << originalwindow.pixhi;
  INFO.print();
  INFO << "Range_sampling_rate (leaderfile, MHz):    " << rsr2x/2.0;
  INFO.print();
  INFO << "Pulse_Repetition_Frequency (actual, Hz):  " << prf;
  INFO.print();


  // ______ Check filesize with format/dimensions (BK 08-Mar-2001) ______
  //ifstream tmpfile(file, ios::in | ios::nocreate);
  ifstream tmpfile(file, ios::in);
  if (tmpfile) 
    {
    tmpfile.seekg(0,ios::end); // internal filesize, normal one exists if not exists
    uint filesizetrue  = tmpfile.tellg();
    // not ok, error in bk_assert: uint filesizetrue  = filesize(file); 
    int32 bytesperelem = 4;
    if (formatflag==FORMATCI2) bytesperelem=4;
    if (formatflag==FORMATCR4) bytesperelem=8;
    if (formatflag==FORMATR4) bytesperelem=4;
    if (formatflag==FORMATI2) bytesperelem=2;
    if (formatflag==FORMATI2_BIGENDIAN) bytesperelem=2;
    if (formatflag==FORMATR8) bytesperelem=8;
    if (formatflag==FORMATHGT) bytesperelem=8;
    int32 filesizecomp = currentwindow.lines()*currentwindow.pixels()*bytesperelem;
    DEBUG << "Checking format/dimensions file=" << file;
    DEBUG.print();
    if (filesizecomp != filesizetrue)
      {
      WARNING << "Fileformat or dimensions seem wrong"
           << "; bytesperpix=" << bytesperelem
           << "; #l=" << currentwindow.lines()
           << "; #p=" << currentwindow.pixels()
           << "; size=" << filesizetrue
           << "; size computed=" << filesizecomp;
      WARNING.print();
      }
    else
      {
      DEBUG.print("Fileformat and dimensions checked ok.");
      }
    tmpfile.close();
    } // if stream ok
  else
    {
    WARNING << "File: " << file
         << " does not seem to exist (may not be a problem).";
    WARNING.print();
    }


  // ______Tidy up______
  resfile.close();
#ifdef __DEBUG
  DEBUG.print("Finished updateslcimage");
  DEBUG.print("content of struct:");
  showdata();
#endif
  } // END updateslcimageML

//____RaffaeleNutricato END MODIFICATION SECTION 1

---