WSxM_io.C

Go to the documentation of this file.

/* Gnome gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 *
 * Gxsm Plugin Name: WSxM_io.C
 * ========================================
 * 
 * Copyright (C) 2001 The Free Software Foundation
 *
 * Authors: Thorsten Wagner <thorsten.wagner@uni-essen.de> 
 *
 * 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.
 */

/* Please do not change the Begin/End lines of this comment section!
 * this is a LaTeX style section used for auto generation of the PlugIn Manual 
 * Chapter. Add a complete PlugIn documentation inbetween the Begin/End marks!
 * All "% PlugInXXX" commentary tags are mandatory
 * All "% OptPlugInXXX" tags are optional
 * --------------------------------------------------------------------------------
% BeginPlugInDocuSection
% PlugInDocuCaption: Import/export for WSxM Nanotec Electronica SPM data
% PlugInName: WSxM_io
% PlugInAuthor: Thorsten Wagner
% PlugInAuthorEmail: stm@users.sf.net
% PlugInMenuPath: File/Im,Export/WXsM

% PlugInDescription
Data import/export of the WSxM data format (version 2) used by Nanotec
Electronica.

% PlugInUsage
Call it from \GxsmMenu{File/Im,Export/WXsM}. Also a normal open or
drag- and drop action from gmc, nautilus or Netscape (URL) will
automatic import WSxM files.

% OptPlugInRefs
\GxsmWebLink{www.nanotec.es}

%% OptPlugInKnownBugs
%Are there known bugs? List! How to work around if not fixed?
The import algorithm is not complete yet. You will get the image, but the scan data are only fake.

% OptPlugInNotes
DnD and URL drops are not tested.

%% OptPlugInHints
%Any tips and tricks?

% EndPlugInDocuSection
 * -------------------------------------------------------------------------------- 
 */

#include <gtk/gtk.h>
// #include <linux/coff.h>
#include "config.h"
#include "gxsm/plugin.h"
#include "gxsm/dataio.h"
#include "gxsm/action_id.h"
#include "gxsm/glbvars.h"
#include "plug-ins/hard/sranger_hwi.h"
#include "WSxM_header.h"                // File distributet with WSxM to make header of data file
#include <netcdf.hh>                    // used to read additional data from original file

#define WSXM_MAXCHARS 1000
#define IS_PICO_AMP 100      // Check whether saving as pico is more suitable

extern DSPControl *DSPControlClass;
using namespace std;

// Plugin Prototypes
static void WSxM_im_export_init (void);
static void WSxM_im_export_query (void);
static void WSxM_im_export_about (void);
static void WSxM_im_export_configure (void);
static void WSxM_im_export_cleanup (void);

static void WSxM_im_export_filecheck_load_callback (gpointer data );
static void WSxM_im_export_filecheck_save_callback (gpointer data );

static void WSxM_im_export_import_callback (GtkWidget *w, void *data);
static void WSxM_im_export_export_callback (GtkWidget *w, void *data);

// Fill in the GxsmPlugin Description here
GxsmPlugin WSxM_im_export_pi = {
  NULL,                   // filled in and used by Gxsm, don't touch !
  NULL,                   // filled in and used by Gxsm, don't touch !
  0,                      // filled in and used by Gxsm, don't touch !
  NULL,                   // The Gxsm-App Class Ref.pointer (called "gapp" in Gxsm) is 
                          // filled in here by Gxsm on Plugin load, 
                          // just after init() is called !!!
  "WSxM-ImExport",        // Plugins Name, CodeStly is like: Name-M1S|M2S-BG|F1D|F2D|ST|TR|Misc
  NULL,                   // Plugin's Category - used to autodecide on Pluginloading or ignoring -- NULL: always
  "Im/Export of the WSxM data format (version 2).",     // Description, is shown by PluginViewer (Plugin: listplugin, Tools->Plugin Details)
  "Thorsten Wagner",      // Author(s)/* Gnome gxsm - Gnome X Scanning Microscopy
  N_("_File/_Import/,_File/_Export/"), // sep. im/export menuentry path by comma!
  N_("WSxM,WSxM"), // menu entry (same for both)
  N_("WSxM import,WSxM export"), // short help for menu entry
  N_("WSxM data file import and export filter.\n WSxM is a powerful data manipulation program for spm data. \n Visit for more details www.nanotec.es!"),
  NULL,          // error msg, plugin may put error status msg here later
  NULL,          // Plugin Status, managed by Gxsm, plugin may manipulate it too
  WSxM_im_export_init,  
  WSxM_im_export_query,  
  // about-function, can be "NULL"
  // can be called by "Plugin Details"
  WSxM_im_export_about,
  // configure-function, can be "NULL"
  // can be called by "Plugin Details"
  WSxM_im_export_configure,
  // run-function, can be "NULL", if non-Zero and no query defined, 
  // it is called on menupath->"plugin"
  NULL,
  // cleanup-function, can be "NULL"
  // called if present at plugin removeal
  WSxM_im_export_cleanup
};

// Text used in Aboutbox, please update!!
static const char *about_text = N_("Gxsm file import/export plugin for WSxM files\n\n"
                                   "This plugin writes in WSxM datafiles."
        );

static const char *file_mask = "*.top";

// Symbol "get_gxsm_plugin_info" is resolved by dlsym from Gxsm, used to get Plugin's info!! 
// Essential Plugin Function!!
GxsmPlugin *get_gxsm_plugin_info ( void ){ 
  WSxM_im_export_pi.description = g_strdup_printf(N_("Gxsm WSxM import/export plugin %s"), VERSION);
  return &WSxM_im_export_pi; 
}

// Query Function, installs Plugin's in File/Import and Export Menupaths!
// ----------------------------------------------------------------------
// Import Menupath is "File/Import/WSxM import"
// Export Menupath is "File/Export/WSxM import"
// ----------------------------------------------------------------------
// !!!! make sure the "WSxM_im_export_cleanup()" function (see below) !!!!
// !!!! removes the correct menuentries !!!!

static void WSxM_im_export_query(void)
{
        gchar **path  = g_strsplit (WSxM_im_export_pi.menupath, ",", 2);
        gchar **entry = g_strsplit (WSxM_im_export_pi.menuentry, ",", 2);
        gchar **help  = g_strsplit (WSxM_im_export_pi.help, ",", 2);

        static GnomeUIInfo menuinfo_i[] = { 
                { GNOME_APP_UI_ITEM, NULL, NULL,
                  NULL, NULL,
                  NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_OPEN,
                  0, GDK_CONTROL_MASK, NULL },
                GNOMEUIINFO_END
        };
        menuinfo_i[0].label  = entry[0];
        menuinfo_i[0].hint   = help[0];
        menuinfo_i[0].moreinfo  = (gpointer) WSxM_im_export_import_callback; 
        menuinfo_i[0].user_data = WSxM_im_export_pi.name;

        gnome_app_insert_menus (
                GNOME_APP(WSxM_im_export_pi.app->getApp()), 
                path[0], 
                menuinfo_i
                );
        

        static GnomeUIInfo menuinfo_e[] = { 
                { GNOME_APP_UI_ITEM, NULL, NULL,
                  NULL, NULL,
                  NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_SAVE,
                  0, GDK_CONTROL_MASK, NULL },
                GNOMEUIINFO_END
        };
        menuinfo_e[0].label  = entry[1];
        menuinfo_e[0].hint   = help[1];
        menuinfo_e[0].moreinfo  = (gpointer) WSxM_im_export_export_callback; 
        menuinfo_e[0].user_data = WSxM_im_export_pi.name;

        gnome_app_insert_menus (
                GNOME_APP(WSxM_im_export_pi.app->getApp()), 
                path[1],
                menuinfo_e
                );

        if(WSxM_im_export_pi.status) g_free(WSxM_im_export_pi.status); 
        WSxM_im_export_pi.status = g_strconcat (
                N_("Plugin query has attached "),
                WSxM_im_export_pi.name, 
                N_(": File IO Filters are ready to use."),
                NULL);
        
        // clean up
        g_strfreev (path);
        g_strfreev (entry);
        g_strfreev (help);


        if(WSxM_im_export_pi.status) g_free(WSxM_im_export_pi.status); 
        WSxM_im_export_pi.status = g_strconcat (
                N_("Plugin query has attached "),
                WSxM_im_export_pi.name, 
                N_(": File IO Filters are ready to use"),
                NULL);
        
// register this plugins filecheck functions with Gxsm now!
// This allows Gxsm to check files from DnD, open, 
// and cmdline sources against all known formats automatically - no explicit im/export is necessary.
        WSxM_im_export_pi.app->ConnectPluginToLoadFileEvent (WSxM_im_export_filecheck_load_callback);
        WSxM_im_export_pi.app->ConnectPluginToSaveFileEvent (WSxM_im_export_filecheck_save_callback);
}


// 5.) Start here with the plugins code, vars def., etc.... here.
// ----------------------------------------------------------------------
//


// init-Function
static void WSxM_im_export_init(void)
{
  PI_DEBUG (DBG_L2, "WSxM Import/Export Plugin Init" );
}

// about-Function
static void WSxM_im_export_about(void)
{
  const gchar *authors[] = { WSxM_im_export_pi.authors, NULL};
  gtk_widget_show(gnome_about_new ( WSxM_im_export_pi.name,
                                    VERSION,
                                    N_("(C) 2001 the Free Software Foundation"),
                                    about_text,
                                    authors,
                                    NULL, NULL, NULL
                                    ));
}

// configure-Function
static void WSxM_im_export_configure(void)
{
  if(WSxM_im_export_pi.app)
    WSxM_im_export_pi.app->message("WSxM Import/Export Plugin Configuration");
}

// cleanup-Function, make sure the Menustrings are matching those above!!!
static void WSxM_im_export_cleanup(void)
{
        gchar **path  = g_strsplit (WSxM_im_export_pi.menupath, ",", 2);
        gchar **entry = g_strsplit (WSxM_im_export_pi.menuentry, ",", 2);

        gchar *tmp = g_strconcat (path[0], entry[0], NULL);
        gnome_app_remove_menus (GNOME_APP (WSxM_im_export_pi.app->getApp()), tmp, 1);
        g_free (tmp);

        tmp = g_strconcat (path[1], entry[1], NULL);
        gnome_app_remove_menus (GNOME_APP (WSxM_im_export_pi.app->getApp()), tmp, 1);
        g_free (tmp);

        g_strfreev (path);
        g_strfreev (entry);

        PI_DEBUG (DBG_L2, "Plugin Cleanup done.");
}


        /* --------------------------------------------------------------------------------
                        make a new derivate of the base class "Dataio"
                        definition of all used function for im- and export
        --------------------------------------------------------------------------------*/

class WSxM_ImExportFile : public Dataio{
 public:
  WSxM_ImExportFile(Scan *s, const char *n) : Dataio(s,n){ };
  virtual FIO_STATUS Read();
  virtual FIO_STATUS Write();
 private:
  FIO_STATUS WSxMRead(const char *fname);
  void WriteInLowEndian (const void *buffer, FILE *stream);
  void SetUnit(gchar* sValue, gchar* sUnit, double dValae, double dFactor=1.0);
  void ReplaceChar(char *string, char oldpiece=',', char newpiece='.');
  void SeparateLine(char *sInput, char *sOutput, char cSeparator=10);
};

// d2d import :=)
FIO_STATUS WSxM_ImExportFile::Read(){
        FIO_STATUS ret;
        gchar *fname=NULL;

        fname = (gchar*)name;

        // name should have at least 4 chars: ".ext"
        if (fname == NULL || strlen(fname) < 4)
                return  FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
 
        // check for file exists and is OK !
        // else open File Dlg
        ifstream f;
        f.open(fname, ios::in);
        if(!f.good()){
                PI_DEBUG (DBG_L2, "Error: Can't open file!" );
                return status=FIO_OPEN_ERR;
        }
        f.close();

        // Check all known File Types:
        
        // WSxM ".top" type?
        if ((ret=WSxMRead (fname)) !=  FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                return ret;

        return  FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
}


  /*----------------------------------------------------------------------
       import WSxM file format
  ----------------------------------------------------------------------*/

FIO_STATUS WSxM_ImExportFile::WSxMRead(const char *fname){
        // Am I resposible for that file, is it a "top" format ?
        if (strncmp(fname+strlen(fname)-4,".top",4))
                return FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;
        
        // feel free to do a more sophisticated file type check...
        PI_DEBUG (DBG_L2, "It's a WSxM File!" );
        // initialize variables first
        // file name
        char *szSourceFileName = (gchar *)fname;
        // file pointer
        FILE *pSourceFile = NULL;
        // header
        WSxM_HEADER header;
        
        // parameter for opening binary data
        // set 1 for UNIX and 0 otherwise  
        int bUnixEnv = 1;  
        // the header is ASCII. So opening the header in text mode
        pSourceFile = fopen (szSourceFileName, "rt");
        if (pSourceFile==NULL){
                return FIO_OPEN_ERR;
                }
        // initializing Header for read
        HeaderInit (&header);
        HeaderRead (&header,pSourceFile);

        // close file and open it again in binary mode
        pSourceFile = fopen (szSourceFileName,"rb");
        if (pSourceFile == NULL){
                return FIO_OPEN_ERR;
                }
                
        /* Set the position of file pointer after the image header */
        fseek (pSourceFile, HeaderGetSize(&header), SEEK_SET);
        
        int iCol, iRow, iNumCols, iNumRows;
        short buffer;
        char szComments[100] = "";

        iNumCols = (int) HeaderGetAsNumber (&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_NUM_COLUMNS);
        iNumRows = (int) HeaderGetAsNumber (&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_NUM_ROWS);
 
        // Lets allocate some memory for the scan data.The data of the type short
        scan->mem2d->Resize (
                scan->data.s.nx = iNumCols,
                scan->data.s.ny = iNumRows,
                ZD_SHORT
                );
  
        // this is mandatory.
        scan->data.s.ntimes  = 1;
        scan->data.s.nvalues = 1;
  
        /* Reads a point from the source file and writes it to the memory */
        for (iCol=0; iCol<iNumCols; iCol++)
        {
                for (iRow=0; iRow<iNumRows; iRow++)
                {
                        fread (&buffer, sizeof (short), 1, pSourceFile);
                        scan->mem2d->PutDataPkt (
                                (double)buffer,
                                iRow, iCol);
                                }
        }
        printf("Data has been read succesfully!");
        // put some usefull values in the ui structure
        if(getlogin()){
                scan->data.ui.SetUser (getlogin());
        }
        else{
                scan->data.ui.SetUser ("unkonwn user");
        }
        time_t t; // Scan - set timestamp 
        time(&t);
        gchar *tmp;
        tmp = g_strconcat ((ctime(&t)), "(Imported)", NULL);
        scan->data.ui.SetDateOfScan (tmp);
        g_free (tmp);
        scan->data.ui.SetName (fname);
        scan->data.ui.SetOriginalName (fname);
        scan->data.ui.SetType ("WSxM Type: SHORT ");
        tmp = g_strconcat (scan->data.ui.comment,
                           "Imported by gxsm WSxM import plugin from:\n",
                           fname,
                           NULL);
        scan->data.ui.SetComment (tmp);
        g_free (tmp);

        // initialize scan structure -- this is a minimum example
        scan->data.s.dx = 1;
        scan->data.s.dy = 1;
        scan->data.s.dz = 1;
        scan->data.s.rx = scan->data.s.nx;
        scan->data.s.ry = scan->data.s.ny;
        scan->data.s.x0 = 0;
        scan->data.s.y0 = 0;
        scan->data.s.alpha = 0;
        scan->mem2d->data->MkYLookup(scan->data.s.y0, scan->data.s.y0+scan->data.s.ry);
        scan->mem2d->data->MkXLookup(scan->data.s.x0-scan->data.s.rx/2., scan->data.s.x0+scan->data.s.rx/2.);

        // be nice and reset this to some defined state
        scan->data.display.cpshigh       = 1e3;
        scan->data.display.cpslow        = 1.;
        scan->data.display.cnttime       = 1.;

        // set the default view parameters
        scan->data.display.bright = 32.;
        scan->data.display.contrast = 1.0;
        
        /* Header destruction */
        HeaderDestroy (&header);
        /* Close the files */
        fclose (pSourceFile);
        // WSxM read done.
        return FIO_OK; 
}


  /*----------------------------------------------------------------------
       export WSxM file format
  ----------------------------------------------------------------------*/

FIO_STATUS WSxM_ImExportFile::Write(){
        const gchar *fname;

        if(strlen(name)>0)
                fname = (const char*)name;
        else
                fname = gapp->file_dialog("File Export: WSxM type"," ","*.top","","WSxM write");
        if (fname == NULL) return FIO_NO_NAME;

        // check if we like to handle this
        if (strncmp(fname+strlen(fname)-4,".top",4))
                return FIO_NOT_RESPONSIBLE_FOR_THAT_FILE;

        // need to write scan size?
        // nx = scan->mem2d->GetNx(), ny = scan->mem2d->GetNy()

        // need some data like X scan range?
        // scan->data.s.rx, .ry
        // scan->data.s.dx, .dy, .dz
        // scan->data.s.x0, .y0
        // scan->data.s.alpha, ... see Gxsm/src/xsmtypes.h for a complete structure listing!

                
  // File pointer
  FILE *pDestinationFile = NULL;
  // set destination for write 
  gchar *sDestinationFileName = (gchar *)fname;
  
  // Header 
  WSxM_HEADER header;
  // parameter for writing binary data
  // set 1 for UNIX and 0 otherwise  
  int bUnixEnv = 1;  
  // the header is ASCII. So opening the header in text mode
  pDestinationFile = fopen (sDestinationFileName, "wt");
  if (pDestinationFile==NULL){
    return FIO_OPEN_ERR;
  }

  // header must be initialised
  HeaderInit (&header);


  /*----------------------------------------------------------------------
       functions to build up the header
  ----------------------------------------------------------------------*/

  // for correct data export we need a reflection at the center
  // double val=0.;
  double **arrImageData; // bufferarray for image data
  arrImageData = (double**) calloc(scan->mem2d->GetNy(), sizeof(double*));
        for (int j=0; j < scan->mem2d->GetNy(); ++j){
        arrImageData[j]=(double *) calloc (scan->mem2d->GetNx(), sizeof(double));
                for (int i=0; i < scan->mem2d->GetNx(); ++i){
                        // like to check the current view mode? 
                        // Here is how to do this:
                        // val = (double)scan->mem2d->GetDataVMode(i,j);
                        // but feel free to just ignore and take the original value:
                        // val = scan->mem2d->GetDataPkt(i,j);
                        arrImageData[j][i]=scan->mem2d->GetDataPkt(scan->data.s.nx-1-i,scan->data.s.ny-1-j);    
                }
        }
        
  // find max and min of the data
  double iMax=arrImageData[0][0], iMin=arrImageData[0][0];
  for (int iCol=0; iCol<scan->data.s.ny; iCol++){
    for (int iRow=0; iRow<scan->data.s.nx; iRow++){
      if (arrImageData[iCol][iRow]>iMax){
                iMax=arrImageData[iCol][iRow];
      }
      if (arrImageData[iCol][iRow]<iMin){
                iMin=arrImageData[iCol][iRow];
      }
    }
  }

  // buffer variable
  char szValue[WSXM_MAXCHARS];          // Needed to handle/convert different values
  double buffer_double;
  unsigned int buffer_uint;
  
  /*----------------------------------------------------------------------
       Header Sektion: General_Info
  ----------------------------------------------------------------------*/
  // define number of pixel
  sprintf (szValue, "%i", scan->data.s.nx);
  HeaderAddValue(&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_NUM_COLUMNS, szValue);
  sprintf (szValue, "%i", scan->data.s.ny);
  HeaderAddValue(&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_NUM_ROWS, szValue);
  HeaderAddValue(&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_ACQ_CHANNEL, "TOPO"); 
  HeaderAddValue(&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_HEAD_TYPE, xsmres.InstrumentType);
  // Z_Amplitude = ZMax - ZMin
  buffer_double=double(iMax-iMin);
  SetUnit(&szValue[0], scan->data.Zunit->Alias(), buffer_double*scan->data.s.dz);
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_GENERAL_INFO, IMAGE_HEADER_GENERAL_INFO_Z_AMPLITUDE, szValue);
  PI_DEBUG (DBG_L2, "WSxM header section General Info written");
 
  /*----------------------------------------------------------------------
       Header Sektion: Control
  ----------------------------------------------------------------------*/
        // define size (x/y amplitude)of the image  
        SetUnit (&szValue[0], scan->data.Xunit->Alias(), double(scan->data.s.rx));
        ReplaceChar (&szValue[0]);
        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_X_AMPLITUDE, szValue);
        SetUnit (&szValue[0], scan->data.Yunit->Alias(), double(scan->data.s.ry));
        ReplaceChar (&szValue[0]);
        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_Y_AMPLITUDE, szValue);
        // tunneling parameter
        /*----------------------------------------------------------------------
          Open actual nc-file again to get additional data
          ----------------------------------------------------------------------*/
        NcError ncerr(NcError::verbose_nonfatal);
        NcFile nc(scan->data.ui.name);
        if (! nc.is_valid()){// Data have not been saved as nc-file. Get data from user interface.
          std::cout<<"WSxM::Export: Not possible to open parent nc-file."<<std::endl;
          if (! strstr(xsmres.HardwareType, "Innovative_DSP:SPM")) {
                PI_DEBUG(DBG_L1, "Exporting from old style DSP Control window.");
                // using old style for pci32
                // Sorry for that, but an IUnit was not implemented yet, so using default unit nA
                SetUnit (&szValue[0], "nA", double(scan->data.s.Current));
                ReplaceChar (&szValue[0]);
                HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_SET_POINT, szValue);
                PI_DEBUG (DBG_L1, "Warning: Set current unit to default (nA).");
                PI_DEBUG (DBG_L1, "Is " << ((double)(scan->data.s.Current)) << " nA correct?");
                SetUnit (&szValue[0], scan->data.Vunit->Alias(), double(scan->data.s.Bias));
                ReplaceChar (&szValue[0]);
                HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_BIAS, szValue);
          }
          if (! strstr(xsmres.HardwareType, "Sranger")) { 
                // new style hardware interface used by the signal ranger board
                PI_DEBUG(DBG_L1, "Exporting from new HWI window.");
                SetUnit (&szValue[0], "V", double(DSPControlClass->bias));
                ReplaceChar (&szValue[0]);
                HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_BIAS, szValue);
                if (IS_AFM_CTRL) { 
                        // AFM uses voltage set point
                        SetUnit (&szValue[0], "V", double(DSPControlClass->voltage_set_point));
                        ReplaceChar (&szValue[0]);
                        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_SET_POINT, szValue);
                }
                else { 
                        // SPM uses current set point
                        SetUnit (&szValue[0], "nA", double(DSPControlClass->current_set_point));
                        ReplaceChar (&szValue[0]);
                        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_SET_POINT, szValue);
                }
          }
        }
        else {// Data have been saved as nc-file. Look up data in nc-file.
          PI_DEBUG (DBG_L1, "Parent nc-file "<<scan->data.ui.name<<" opened");
          buffer_double=0;
          //Read out old parameter, if new one is available overwrite
          //Find correct value for set point
          if(nc.get_var("dsp_itunnel")) {
            buffer_double = nc.get_var("dsp_itunnel")->values()->as_double(0);
            SetUnit (&szValue[0], "nA", double(buffer_double));
            PI_DEBUG (DBG_L1, "Use old dsp_itunnel: "<<buffer_double <<"nA");
            PI_DEBUG (DBG_L1, "Warning: Set current unit to default (nA). Is " << buffer_double << " nA correct?");
          }
          if(nc.get_var("sranger_hwi_current_set_point")) {
            buffer_double = nc.get_var("sranger_hwi_current_set_point")->values()->as_double(0);
            SetUnit (&szValue[0], "nA", double(buffer_double));
            PI_DEBUG (DBG_L1, "Overwrite with sranger_hwi_current_set_point: "<<buffer_double<<"nA");
          }
          if(nc.get_var("sranger_hwi_voltage_set_point")) {
            buffer_double = nc.get_var("sranger_hwi_voltage_set_point")->values()->as_double(0);
            SetUnit (&szValue[0], "V", double(buffer_double));
            PI_DEBUG (DBG_L1, "Overwrite with sranger_hwi_voltage_set_point: "<<buffer_double<<"V");
            }
          ReplaceChar (&szValue[0]);
          HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_SET_POINT, szValue);
          
          //Find correct value for tunneling bias
          if(nc.get_var("dsp_utunnel")) {
            buffer_double = nc.get_var("dsp_utunnel")->values()->as_double(0);
            SetUnit (&szValue[0], "nA", double(buffer_double));
            PI_DEBUG (DBG_L1, "Use old dsp_utunnel: "<<buffer_double<< "V");
          }
          if(nc.get_var("sranger_hwi_bias")) {
            buffer_double = nc.get_var("sranger_hwi_bias")->values()->as_double(0);
            SetUnit (&szValue[0], "V", double(buffer_double));
            PI_DEBUG (DBG_L1, "Overwrite with sranger_hwi_bias: "<<buffer_double<< "V");
          }
          ReplaceChar (&szValue[0]);
          HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_BIAS, szValue);

          //Write scan direction
          if(nc.get_var("spm_scancontrol")) {
            strncpy(&szValue[0], nc.get_var("spm_scancontrol")->values()->as_string(0),8);
            PI_DEBUG (DBG_L1, "Found attribute scan direction: "<< szValue);
            ReplaceChar (&szValue[0]);
            HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_SCAN_DIRECTION, szValue);
          }

        }
        
        // X,Y Offset
        SetUnit (&szValue[0], scan->data.Xunit->Alias(), double(scan->data.s.x0));
        ReplaceChar (&szValue[0]);
        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_X_OFFSET, szValue);
        SetUnit (&szValue[0], scan->data.Yunit->Alias(), double(scan->data.s.y0));
        ReplaceChar (&szValue[0]);
        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_Y_OFFSET, szValue);
        // Z Gain
        sprintf (szValue, "1.0");
        HeaderAddValue(&header, IMAGE_HEADER_CONTROL, IMAGE_HEADER_CONTROL_Z_GAIN,szValue);
        //Rotation
        SetUnit (szValue,"Deg",double(scan->data.s.alpha));
        ReplaceChar(szValue); 
        HeaderAddValue(&header,IMAGE_HEADER_CONTROL,IMAGE_HEADER_CONTROL_ROTATION,szValue);
        PI_DEBUG (DBG_L2, "WSxM header section Control written"); 
  
  /*----------------------------------------------------------------------
       Header Sektion: Misc_Info
  ----------------------------------------------------------------------*/
  // set file format version
  HeaderAddValue(&header, IMAGE_HEADER_MISC_INFO, IMAGE_HEADER_MISC_INFO_VERSION, IMAGE_HEADER_VERSION);
  // write comments to header
  buffer_uint=0;
  strcpy(szValue,"");                          // clear variables
  unsigned int max_uint=WSXM_MAXCHARS;         // buffer variable to take trace of the max number chars in string
  char buffer_string[WSXM_MAXCHARS];           // buffer for string operation
  while (buffer_uint+1<strlen(scan->data.ui.comment)&&buffer_uint+1<max_uint)
  {
        strcpy(buffer_string,"");
        if (scan->data.ui.comment[buffer_uint]==10)              // check if there is an empty line
          {// empty line
            buffer_uint++;
            PI_DEBUG(DBG_L2,"WSXM::write(): Blank line in comment detected and deleted!");
          }
        else
          {// no empty line
            SeparateLine(&scan->data.ui.comment[buffer_uint],&buffer_string[0],10);
            max_uint-=2;
            if (strlen(szValue)+strlen(buffer_string)+2>max_uint)                  // make sure that there is segmentation fault
              {// comment is longer than WSXM_MAXCHARS
                PI_DEBUG (DBG_L2, "WSXM::write(): Warnig: Comments are too long! They will be cut.");
                if (((signed int)(max_uint-strlen(szValue)-2))>0)
                  {
                    strncat(&szValue[0], &buffer_string[0], max_uint-strlen(szValue)-2);
                    strcat(&szValue[0],"\r\n");
                  }
                ++buffer_uint+=strlen(&buffer_string[0]);               // add one because of the '\n'
                PI_DEBUG (DBG_L2, buffer_string);
              }
            else 
              {// length of comment is okey
                strcat(&szValue[0],&buffer_string[0]);
                strcat(&szValue[0],"\r\n");
                ++buffer_uint+=strlen(&buffer_string[0]);               // add one because of the '\n'
              }
          }
  }
  ReplaceChar (szValue,':',' ');
  HeaderAddValue(&header, IMAGE_HEADER_MISC_INFO, IMAGE_HEADER_MISC_INFO_COMMENTS, szValue);
  // set ZMin, ZMax
  SetUnit(&szValue[0], scan->data.Zunit->Alias(), double(iMax)*scan->data.s.dz);
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_MISC_INFO, IMAGE_HEADER_MISC_INFO_MAXIMUM, szValue);
  SetUnit(&szValue[0], scan->data.Zunit->Alias(), double(iMin)*scan->data.s.dz);
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_MISC_INFO, IMAGE_HEADER_MISC_INFO_MINIMUM, szValue);
  PI_DEBUG (DBG_L2, "WSxM header section Misc Info written");

  /*----------------------------------------------------------------------
       Header Sektion: Heads
  ----------------------------------------------------------------------*/
  // informationen for callibration
  sprintf(szValue,"%g %c/V",xsmres.XPiezoAV,197);
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_HEADS, IMAGE_HEADER_HEADS_X_CALIBRATION, szValue);
  sprintf(szValue,"%g %c/V",xsmres.YPiezoAV,197);
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_HEADS, IMAGE_HEADER_HEADS_Y_CALIBRATION, szValue);
  sprintf(szValue,"%g %c/V",xsmres.ZPiezoAV,197); 
  ReplaceChar (&szValue[0]);
  HeaderAddValue(&header, IMAGE_HEADER_HEADS, IMAGE_HEADER_HEADS_Z_CALIBRATION, szValue); 
  PI_DEBUG (DBG_L2, "WSxM header section Heads written");
  
  /*----------------------------------------------------------------------
       save file to disk
  ----------------------------------------------------------------------*/
  // writing the header in ASCII mode
  HeaderWrite(&header, pDestinationFile);
  HeaderDestroy (&header);
  PI_DEBUG (DBG_L2, "WSxM header written succesfully");
  // close file and open it again in binary mode
  fclose(pDestinationFile);
  pDestinationFile=fopen(sDestinationFileName, "ab");
  if (pDestinationFile==NULL){
    return FIO_OPEN_ERR;
  }
  short buffer;
  for (int j=0; j < scan->mem2d->GetNy(); ++j){
        for (int i=0; i < scan->mem2d->GetNx(); ++i){
                buffer = (short) arrImageData[j][i]; 
                if (bUnixEnv){
                // Write in low endian
                // Convert data in low endian format. Plugin should run on unix systems.
                WriteInLowEndian (&buffer,pDestinationFile);
        }
                else {
                        // No data conversion. Plugin should run on a PC.
                                fwrite(&buffer,sizeof(short),1,pDestinationFile);       
                }
    }
  }
  PI_DEBUG (DBG_L2, "WSxM body written succesful");
  // closing file finaly
  fclose(pDestinationFile);
  return FIO_OK; 
}


  /*----------------------------------------------------------------------
       WriteInLowEndian: Write binary data in PC style (Windows compatible)
  ----------------------------------------------------------------------*/

void WSxM_ImExportFile::WriteInLowEndian(const void *buffer, FILE *stream)
{
  fwrite (&((char*)buffer)[0],sizeof (char),1,stream);
  fwrite (&((char*)buffer)[1],sizeof (char),1,stream);
  // PI_DEBUG (DBG_L2, "Write in low endian style");
        
}

  /*----------------------------------------------------------------------
       SetUnit: Adds Unit to String
  ----------------------------------------------------------------------*/
void WSxM_ImExportFile::SetUnit(gchar* sValue, gchar* sUnit, double dValue, double dFactor)
{// Global unit table declared in xsm.C
  UnitsTable *UnitPtr = XsmUnitsTable;                                               
  gchar prec_str[WSXM_MAXCHARS];
  gchar *finalUnit;
  dValue=dValue*dFactor; // Use dFactor for scalling
  // Checking for the correct unit of the tunneling current, because WSxM only acceptes 2 decimals
  if(!strcmp(sUnit,"nA"))
    {
      if(((int)(dValue * IS_PICO_AMP)) == 0)
        {// better use pA
          finalUnit = g_strdup("pA");
        }
      else
        {// use standard unit
          finalUnit = g_strdup(sUnit);
        }       
    }
  else
         finalUnit = g_strdup(sUnit);           
   
        
  // handling the Arc Unit
  if(!strcmp(finalUnit,"Deg"))
    {
        snprintf(sValue,WSXM_MAXCHARS,"%g %s",dValue / UnitPtr->fac,"°");   
        g_free(finalUnit);
        return;
    }
  
  //check if a global unit alias exists
  for(;UnitPtr->alias;UnitPtr++)                                                                                
        if(!strcmp(finalUnit,UnitPtr->alias))
          break;
 
  g_free(finalUnit);
  if(!UnitPtr->alias)
    {// Default: digital units
      snprintf(sValue,WSXM_MAXCHARS,"%g", dValue);
      PI_DEBUG(DBG_L2,"Data will be saved in digital units");
    }
  else
    {// substituting A with 197
      if(!strcmp(UnitPtr->alias,"AA"))
        {// angstrom need an extra handling
          snprintf(prec_str,WSXM_MAXCHARS,"%%%s %%c",UnitPtr->prec2);
          snprintf(sValue,WSXM_MAXCHARS,prec_str,dValue / UnitPtr->fac,197);  
          return;
        }
      else {
        snprintf(prec_str,WSXM_MAXCHARS,"%%%s %%s",UnitPtr->prec2);
        snprintf(sValue,WSXM_MAXCHARS,prec_str,dValue / UnitPtr->fac, UnitPtr->s);      
      }
    }
}

  /*----------------------------------------------------------------------
       ReplaceChar: Replaces A Char Within A String
       Default: Replacing ',' by '.'
  ----------------------------------------------------------------------*/
void WSxM_ImExportFile::ReplaceChar(char *string, char oldpiece, char newpiece)
{
   for (;*string;string++)
    {
      if (*string==oldpiece) *string=newpiece;
    }
}

 /*----------------------------------------------------------------------
       SeparateLine: Separates Lines vom sInput to sOutput
       Default Separator is '\n'
  ----------------------------------------------------------------------*/

void WSxM_ImExportFile::SeparateLine(char *sInput, char *sOutput, char cSeparator)
{
        for (;*sInput;sInput++)
    {
      if (*sInput==cSeparator) {
        break;
        }
      else {
        strncat(sOutput,sInput,1);
        }
    }
}

// Plugin's Notify Cb's, registered to be called on file load/save to check file
// return via filepointer, it is set to Zero or passed as Zero if file has been processed!
// That's all fine, you should just change the Text Stings below...


static void WSxM_im_export_filecheck_load_callback (gpointer data ){
        gchar **fn = (gchar**)data;
        if (*fn){
                PI_DEBUG (DBG_L2, "Check File: WSxM_im_export_filecheck_load_callback called with >"
                     << *fn << "<" );

                Scan *dst = gapp->xsm->GetActiveScan();
                if(!dst){ 
                        gapp->xsm->ActivateFreeChannel();
                        dst = gapp->xsm->GetActiveScan();
                }
                WSxM_ImExportFile fileobj (dst, *fn);

                FIO_STATUS ret = fileobj.Read(); 
                if (ret != FIO_OK){ 
                        // I'am responsible! (But failed)
                        if (ret != FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                                *fn=NULL;
                        // no more data: remove allocated and unused scan now, force!
                        gapp->xsm->SetMode(-1, ID_CH_M_OFF, TRUE); 
                        PI_DEBUG (DBG_L2, "Read Error " << ((int)ret) << "!!!!!!!!" );
                }else{
                        // got it!
                        *fn=NULL;

                        // Now update gxsm main window data fields
                        gapp->xsm->ActiveScan->GetDataSet(gapp->xsm->data);
                        gapp->spm_update_all();
                        dst->draw();
                }
        }else{
                PI_DEBUG (DBG_L2, "WSxM_im_export_filecheck_load: Skipping" );
        }
}

static void WSxM_im_export_filecheck_save_callback (gpointer data ){
        gchar **fn = (gchar**)data;
        if (*fn){
                Scan *src;
                PI_DEBUG (DBG_L2, "Check File: WSxM_im_export_filecheck_save_callback called with >"
                     << *fn << "<" );

                WSxM_ImExportFile fileobj (src = gapp->xsm->GetActiveScan(), *fn);

                FIO_STATUS ret;
                ret = fileobj.Write(); 

                if(ret != FIO_OK){
                        // I'am responsible! (But failed)
                        if (ret != FIO_NOT_RESPONSIBLE_FOR_THAT_FILE)
                                *fn=NULL;
                        PI_DEBUG (DBG_L2, "Write Error " << ((int)ret) << "!!!!!!!!" );
                }else{
                        // write done!
                        *fn=NULL;
                }
        }else{
                PI_DEBUG (DBG_L2, "WSxM_im_export_filecheck_save: Skipping >" << *fn << "<" );
        }
}

// Menu Call Back Function

static void WSxM_im_export_import_callback(GtkWidget *w, void *data){
        gchar **help = g_strsplit (WSxM_im_export_pi.help, ",", 2);
        gchar *dlgid = g_strconcat (WSxM_im_export_pi.name, "-import", NULL);
        gchar *fn = gapp->file_dialog (help[0], NULL, file_mask, NULL, dlgid);
        g_strfreev (help); 
        g_free (dlgid);
        WSxM_im_export_filecheck_load_callback (&fn );
}

static void WSxM_im_export_export_callback(GtkWidget *w, void *data){
        gchar **help = g_strsplit (WSxM_im_export_pi.help, ",", 2);
        gchar *dlgid = g_strconcat (WSxM_im_export_pi.name, "-export", NULL);
        gchar *fn = gapp->file_dialog(help[1], NULL, file_mask, NULL, dlgid);
        g_strfreev (help); 
        g_free (dlgid);
        WSxM_im_export_filecheck_save_callback (&fn );
}

---