lineprofile.C

Go to the documentation of this file.

/* Gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 * 
 * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
 *
 * Authors: Percy Zahl <zahl@users.sf.net>
 * additional features: Andreas Klust <klust@users.sf.net>
 * WWW Home: http://gxsm.sf.net
 *
 * This 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.
 *
 * This program 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.
 */

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */

#include "lineprofile.h"
#include "mem2d.h"
#include "glbvars.h"

LineProfile1D::LineProfile1D(){
        masterscan=NULL;
        scan1d=NULL;
        private_scan=TRUE;
}

LineProfile1D::LineProfile1D(int n, UnitObj *ux, UnitObj *uy, double xmin, double xmax){
        masterscan=NULL;
        scan1d=NULL;
        private_scan=TRUE;
        scan1d = new Scan(n, 0, -1, NULL, ZD_DOUBLE);
        
        scan1d->data.s.ny=1;
        scan1d->data.s.nx=n;

        scan1d->data.s.rx=xmax-xmin;
        scan1d->data.s.ry=0.;
        scan1d->data.s.rz=0.;
        scan1d->data.s.dl=scan1d->data.s.rx;

        scan1d->data.s.dx=scan1d->data.s.rx/(n-1);
        scan1d->data.s.dy=1.;
        scan1d->data.s.dz=1.;

        scan1d->data.s.x0=xmin;
        scan1d->data.s.y0=0.;
        scan1d->data.s.alpha=0.;

        UnitObj Unity(" "," ","g","arb. units");
        scan1d->data.SetXUnit (ux);
        scan1d->data.SetYUnit (&Unity);
        scan1d->data.SetZUnit (uy);

        scan1d->create();
        scan1d->mem2d->data->MkXLookup(xmin, xmax);
}

LineProfile1D::~LineProfile1D(){
  //  XSMDEBUG("LineProfile1D::~LineProfile1D");
  if(scan1d && private_scan)
    delete scan1d;
}

// Lesen und schreiben von spa4 .d1d Daten

int LineProfile1D::load(gchar *fname){
        XSM_DEBUG (DBG_L3, "LineProfile1D::load - file to new scan: " << fname);
        std::ifstream f;

        if (fname == NULL) return 1;
        
        f.open(fname, std::ios::in);
        if(!f.good()){
                //    fl_show_alert(ERR_SORRY, ERR_FILEREAD,fname,1);
                return 1;
        }

        XSM_DEBUG (DBG_L3, "LineProfile1D::load - file check OK");

        private_scan=TRUE;

        XSM_DEBUG (DBG_L3, "LineProfile1D::load - new Scan");
        scan1d = new Scan(0, 0, -1, NULL, ZD_DOUBLE);
        
        scan1d->data.s.ny=1;
        scan1d->data.s.nx=0;

        scan1d->data.s.rx=1.;
        scan1d->data.s.ry=0.;
        scan1d->data.s.rz=0.;
        scan1d->data.s.dl=scan1d->data.s.rx;

        scan1d->data.s.dx=1.;
        scan1d->data.s.dy=1.;
        scan1d->data.s.dz=1.;

        scan1d->data.s.x0=0.;
        scan1d->data.s.y0=0.;
        scan1d->data.s.alpha=0.;

        UnitObj Unity(" "," ","g","arb. units");
        scan1d->data.SetXUnit (&Unity);
        scan1d->data.SetYUnit (&Unity);
        scan1d->data.SetZUnit (&Unity);

        XSM_DEBUG (DBG_L3, "LineProfile1D::load - reading asc Header");
        gchar l[1024];
        while (f.good()){
                f.getline(l, 1024);
                XSM_DEBUG(DBG_L2, l );
                if (strncmp (l, "# Len   = ", 10) == 0){
                        scan1d->data.s.rx=atof(l+10); 
                        scan1d->data.s.dl=scan1d->data.s.rx;
                        continue;
                }
                if (strncmp (l, "# dX    = ", 10) == 0){
                        scan1d->data.s.dx=atof(l+10); 
                        continue;
                }
                if (strncmp (l, "# dY    = ", 10) == 0){
                        scan1d->data.s.dy=atof(l+10); 
                        continue;
                }
                if (strncmp (l, "# dZ    = ", 10) == 0){
                        scan1d->data.s.dz=1.; // reading world data now!!
                        continue;
                }
                if (strncmp (l, "# X0    = ", 10) == 0){
                        scan1d->data.s.x0=atof(l+10); 
                        continue;
                }
                if (strncmp (l, "# Y0    = ", 10) == 0){
                        scan1d->data.s.y0=atof(l+10); 
                        continue;
                }
                if (strncmp (l, "# Anz   = ", 10) == 0){
                        scan1d->data.s.nx=atoi(l+10); 
                        continue;
                }
                if (strncmp (l, "# NSets = ", 10) == 0){
                        scan1d->data.s.ny=atoi(l+10); 
                        continue;
                }
                if (strncmp (l, "# Xunit = ", 10) == 0){
                        gchar *u = g_strdup(l+10);
                        gchar *ua=NULL;
                        gchar *ul=NULL;
                        f.getline(l, 1024); // expecting label in next line!
                        if (strncmp (l, "# Xalias= ", 10) == 0){
                                ua = g_strdup(l+10);
                                f.getline(l, 1024); // expecting label in next line!
                                if (strncmp (l, "# Xlabel= ", 10) == 0)
                                        ul = g_strdup(l+10);
                                UnitObj *uobj=NULL;
                                if (ua)
                                        uobj = gapp->xsm->MakeUnit (ua, ul?ul:ua);
                                else
                                        uobj = gapp->xsm->MakeUnit (u, ul?ul:u);

                                scan1d->data.SetXUnit (uobj);
                                delete uobj;
                                        
                                if (u) g_free(u);
                                if (ua) g_free(ua);
                                if (ul) g_free(ul);
                                continue;
                        }
                }
                if (strncmp (l, "# Yunit = ", 10) == 0){
                        gchar *u = g_strdup(l+10);
                        gchar *ua=NULL;
                        gchar *ul=NULL;
                        f.getline(l, 1024); // expecting label in next line!
                        if (strncmp (l, "# Yalias= ", 10) == 0){
                                ua = g_strdup(l+10);
                                f.getline(l, 1024); // expecting label in next line!
                                if (strncmp (l, "# Ylabel= ", 10) == 0)
                                        ul = g_strdup(l+10);
                                UnitObj *uobj=NULL;
                                if (ua)
                                        uobj = gapp->xsm->MakeUnit (ua, ul?ul:ua);
                                else
                                        uobj = gapp->xsm->MakeUnit (u, ul?ul:u);

                                scan1d->data.SetZUnit (uobj);
                                delete uobj;
                                        
                                if (u) g_free(u);
                                if (ua) g_free(ua);
                                if (ul) g_free(ul);
                                continue;
                        }
                }
                if (strncmp (l, "# Title = ", 10) == 0){
                        scan1d->data.ui.SetTitle(l+10); 
                        continue;
                }
                if (strncmp (l, "# Format= ", 10) == 0){
                        break;
                }
                if (strncmp (l, "# Fromat= ", 10) == 0){ // bugfix
                        break;
                }
        }
        XSM_DEBUG (DBG_L3, "LineProfile1D::load - new Scan->create()");
        XSM_DEBUG (DBG_L3, "LineProfile1D::load NX: "<<scan1d->data.s.nx); 
        XSM_DEBUG (DBG_L3, "LineProfile1D::load NY: "<<scan1d->data.s.ny); 
        scan1d->create();

        XSM_DEBUG (DBG_L3, "LineProfile1D::load - reading data");
        for(int i=0; i<scan1d->data.s.nx && f.good(); ++i){
                double x=0., y=0.;
                f.getline (l, 1024);
                gchar **record = g_strsplit(l, " ", 100);

                gchar **token = record;
                for (int j=-1; *token; ++token){
                        if (! strcmp (*token, "InUnits:")){
                                ++j;
                                continue;
                        }
                        if (j==0){
                                x = atof (*token);
                                scan1d->mem2d->data->SetXLookup (i, x);
                                XSM_DEBUG(DBG_L2, i << " " << x );
                                ++j;
                                continue;
                        }
                        if (j>0){
                                y = atof (*token);
                                if (j <= scan1d->mem2d->GetNy ())
                                        scan1d->mem2d->PutDataPkt (y, i, j-1);
                                ++j;
                                continue;
                        }
                }
                g_strfreev (record);
        }
    
        f.close();
        XSM_DEBUG (DBG_L3, "LineProfile1D::load - Done.");
        return 0;
}

int LineProfile1D::save(gchar *fname){
  std::ofstream f;
  int   i,j;
  time_t t;
  time(&t); 
  f.open(fname, std::ios::out | std::ios::trunc);
  if(!f.good()){
    //    fl_show_alert(ERR_SORRY, ERR_FILEWRITE,fname,1);
    return 1;
  }
  f << "# ASC LineProfile Data" << std::endl
    << "# Date: " << ctime(&t)
    << "# FileName: " << fname << std::endl
    << "# Len   = " << scan1d->data.s.rx << "A" << std::endl
    << "# tStart= " << scan1d->data.s.tStart << "s" << std::endl
    << "# tEnd  = " << scan1d->data.s.tEnd << "s" << std::endl
    << "# phi   = " << scan1d->data.s.alpha << "degree" << std::endl
    << "# dX    = " << scan1d->data.s.dx << "A" << std::endl
    << "# dY    = " << scan1d->data.s.dy << "A" << std::endl
    << "# dZ    = " << scan1d->data.s.dz << "A" << std::endl
    << "# Xo    = " << scan1d->data.s.x0 << "A" << std::endl
    << "# Yo    = " << scan1d->data.s.y0 << "A" << std::endl
    << "# Anz   = " << scan1d->data.s.nx << std::endl
    << "# NSets = " << scan1d->data.s.ny << std::endl
    << "# Xunit = " << (scan1d->data.Xunit->Symbol()? scan1d->data.Xunit->Symbol():"N/A") << std::endl
    << "# Xalias= " << (scan1d->data.Xunit->Alias()? scan1d->data.Xunit->Alias():"N/A") << std::endl
    << "# Xlabel= " << scan1d->data.Xunit->Label() << std::endl
    << "# Yunit = " << (scan1d->data.Zunit->Symbol()? scan1d->data.Zunit->Symbol():"N/A")  << std::endl
    << "# Yalias= " << (scan1d->data.Zunit->Alias()? scan1d->data.Zunit->Alias():"N/A") << std::endl
    << "# Ylabel= " << scan1d->data.Zunit -> Label() << std::endl
    << "# Title = " << scan1d->data.ui.title << std::endl
    << "# Format= X[index*LineLen/Nx] Z[DA]... InUnit: X[Xunit] Z[Zunit]..." << std::endl
    ;

  for(i=0; i<scan1d->mem2d->GetNx(); i++){
    f << i*scan1d->data.s.dl/(double)scan1d->mem2d->GetNx();
    for(j=0; j<scan1d->mem2d->GetNy(); j++)
      f << " " << (double)scan1d->mem2d->GetDataPkt(i,j);

    f << " InUnits: " 
      << ( scan1d->data.Xunit ? scan1d->data.Xunit : scan1d->data.Xunit) -> Base2Usr(scan1d->mem2d->data->GetXLookup(i));
    for(j=0; j<scan1d->mem2d->GetNy(); j++)
      f << " " << scan1d->data.Zunit->Base2Usr(scan1d->mem2d->GetDataPkt(i,j)*scan1d->data.s.dz);

    f << std::endl;
  }
  
  f.close();

  return 0;
}

int LineProfile1D::SetData(Scan *sc, int line){
  //  XSMDEBUG("LineProfile1D::SetData");

  if(line == -2){
    scan1d = sc;
    private_scan=FALSE;
    return 0;
  }

  if(! scan1d){
    if(scan1d && private_scan)
        delete scan1d;
    private_scan=TRUE;
    scan1d = new Scan(sc);
  }

  scan1d->CpyDataSet (sc->data);
  scan1d->data.CpUnits (sc->data);
  scan1d->data.s.ny=1;
  scan1d->create();
  if(line < 0){
          if( sc->RedLineActive ){
                  scan1d->mem2d->GetDataLineFrom(&sc->Pkt2dScanLine[0], &sc->Pkt2dScanLine[1], 
                                                 sc->mem2d, &scan1d->data, 
                                                 (GETLINEORGMODE)xsmres.LineProfileOrgMode);
          }
          else{
                  switch (sc->get_data ()){
                  case MPOINT:
                          if (sc->PktVal == 1)
                                  scan1d->mem2d->GetLayerDataLineFrom (&sc->Pkt2d[0],
                                                                       sc->mem2d, &scan1d->data);
                          break;
                  case MCIRC:
                          if (sc->PktVal == 2)
                                  scan1d->mem2d->GetArcDataLineFrom (&sc->Pkt2d[0], &sc->Pkt2d[1],
                                                                  sc->mem2d, &scan1d->data);
                          break;
                  default: 
                          if (sc->PktVal == 2)
                                  scan1d->mem2d->GetDataLineFrom(&sc->Pkt2d[0], &sc->Pkt2d[1], 
                                                                 sc->mem2d, &scan1d->data, 
                                                                 (GETLINEORGMODE)xsmres.LineProfileOrgMode);
                          break;
                  }
          }
  }
  else
    scan1d->mem2d->CopyFrom(sc->mem2d, 0,line, 0,0, scan1d->mem2d->GetNx()); 

  return 0;
}


double LineProfile1D::GetPoint(int n) {
        if (scan1d) return scan1d->mem2d->GetDataPkt (n,0); 
        else return 0.; 
}
void LineProfile1D::SetPoint(int n, double y) { if (scan1d) scan1d->mem2d->PutDataPkt (y, n,0); }
void LineProfile1D::SetPoint(int n, double x, double y) { 
        if (scan1d) { 
                scan1d->mem2d->PutDataPkt (y, n,0);
                scan1d->mem2d->data->SetXLookup (n, x);   
        } 
}
void LineProfile1D::AddPoint(int n, double a) { if (scan1d) scan1d->mem2d->data->Zadd (a, n,0); }
void LineProfile1D::MulPoint(int n, double f) { if (scan1d) scan1d->mem2d->data->Zmul (f, n,0); }


// END

---