baseinfo.C

Go to the documentation of this file.

/* Gnome gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 *
 * Quick nine points Gxsm Plugin GUIDE by PZ:
 * ------------------------------------------------------------
 * 1.) Make a copy of this "intarea.C" to "your_plugins_name.C"!
 * 2.) Replace all "intarea" by "your_plugins_name" 
 *     --> please do a search and replace starting here NOW!! (Emacs doese preserve caps!)
 * 3.) Decide: One or Two Source Math: see line 54
 * 4.) Fill in GxsmPlugin Structure, see below
 * 5.) Replace the "about_text" below a desired
 * 6.) * Optional: Start your Code/Vars definition below (if needed more than the run-fkt itself!), 
 *       Goto Line 155 ff. please, and see comment there!!
 * 7.) Fill in math code in intarea_run(), 
 *     have a look at the Data-Access methods infos at end
 * 8.) Add intarea.C to the Makefile.am in analogy to others
 * 9.) Make a "make; make install"
 * A.) Call Gxsm->Tools->reload Plugins, be happy!
 * ... That's it!
 * 
 * Gxsm Plugin Name: baseinfo.C
 * ========================================
 * 
 * Copyright (C) 1999 The Free Software Foundation
 *
 * Authors: Percy Zahl <zahl@fkp.uni-hannover.de>
 * additional features: Andreas Klust <klust@fkp.uni-hannover.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: Statistic base info
% PlugInName: baseinfo
% PlugInAuthor: Stefan Schr\"oder
% PlugInAuthorEmail: stefan_fkp@users.sf.net
% PlugInMenuPath: Math/Statistics/Baseinfo

% PlugInDescription
This plugin calculates some basic statistical information about the
active scan or a selected rectangle within the active scan:

\begin{description}
  \item[Abs. $Z$ min:] Minimum $Z$-value and its coordinate
  \item[Abs. $Z$ max:] Maximum $Z$-value and its coordinate
  \item[$\boldmath \sum Z$:] Sum of all $Z$-values
  \item[$\boldmath \sum Z^2$:] Sum of all squared $Z$-values
  \item[Averaged $Z$:] Average of all $Z$-values:
  \[ \overline Z = \frac{1}{A} \sum_{x,y} Z(x,y) \mbox{ mit } A:= x\cdot y \]
  \item[RMS-roughness:] root mean square roughness:
  \begin{eqnarray*}
    \sigma^2 &=& \frac{1}{A} \int_A d\vec x \, [(Z(x,y) - \overline Z)^2] \\
             &=& \frac{1}{A} [\sum_{x,y} Z(x,y)^2 
                  - 2 \overline Z \sum_{x,y} Z(x,y) + \sum_{x,y} \overline Z^2]\\
             &=& \frac{1}{A} [\sum Z(x,y)^2 - 2 \overline Z \sum Z + \overline Z ^2 \sum 1]\\
             &=& \frac{1}{A} [\sum Z(x,y)^2 - 2 \overline Z \sum Z + \overline Z ^2 A]
  \end{eqnarray*}
\end{description}

% to translate/update:
%  Bei der Begutachtung von $\sigma$ ist auf ein gutmütiges Verhalten des
%  Mittelwertes zu achten.
%  Auf der Standardausgabe werden die ermittelten Werte ausgegeben, um
%  ein Markieren mit der Maus zu ermöglichen.
%  Der Pixelmode ist z.Z. nicht implementiert.


% PlugInUsage
Choose Baseinfo from the \GxsmMenu{Math/Statistics/Baseinfo} menu.

% OptPlugInSources
You need one active scan.

% OptPlugInObjects
If a rectangle is selected the calculated information applies to the
content of the rectangle. Otherwise, the whole scan is analyzed.

% OptPlugInDest
A dialog box appears, which contains the information in tabular form.
You can press 'Dump to Stdout' to print the information on the console.
Pressing 'Dump to comment' concatenates the calculated information to
the comment field of this scan in the main window.

% OptPlugInConfig
None.

% OptPlugInKnownBugs
During the calculation of rms-roughness or the sum overflows can occur
even in medium sized scans. You better choose a smaller region then.

% OptPlugInNotes
Calculated parameters are (with example values):
\begin{tabbing}
rms-roughness:  \= x \kill
Area: > (-35.0571 $\mu$m,-600.586 $\mu$m)-(-18.0728 $\mu$m,-656.711 $\mu$m)\\
Area size: >      18450 Int$^2$\\
Minimum: >        98 Int \\
Min Pos: >        (-27.942 $\mu$m,-600.815 $\mu$m)\\
Maximum: >        10438 Int\\
Max Pos: >        (-31.6143 $\mu$m,-628.763 $\mu$m)\\
Sum:     >        4.95591e+07 Int\\
Sum Sq:  >        1.86421e+09 Int\\
Average: >        2686.13 Int\\
rms-roughness:  >     nan Int
\end{tabbing}

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

#include <sstream>

#include <gtk/gtk.h>
#include "config.h"
#include "gxsm/plugin.h"


using namespace std;


// Plugin Prototypes
static void baseinfo_init( void );
static void baseinfo_about( void );
static void baseinfo_configure( void );
static void baseinfo_cleanup( void );

static gboolean baseinfo_run( Scan *Src );

// Fill in the GxsmPlugin Description here
GxsmPlugin baseinfo_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 !!!
  // ----------------------------------------------------------------------
  // Plugins Name, CodeStly is like: Name-M1S[ND]|M2S-BG|F1D|F2D|ST|TR|Misc
  "Baseinfo-M1SND-ST",
  NULL,
  // Description, is shown by PluginViewer (Plugin: listplugin, Tools->Plugin Details)
  "Basic statistic information",
  // Author(s)
  "Stefan Schroeder",
  // Menupath to position where it is appendet to
  "_Math/_Statistics/",
  // Menuentry
  N_("Baseinfo"),
  // help text shown on menu
  N_("Basic statistic info."),
  // more info...
  "no more info",
  NULL,          // error msg, plugin may put error status msg here later
  NULL,          // Plugin Status, managed by Gxsm, plugin may manipulate it too
  // init-function pointer, can be "NULL", 
  // called if present at plugin load
  baseinfo_init,  
  // query-function pointer, can be "NULL", 
  // called if present after plugin init to let plugin manage it install itself
  NULL, // query should be "NULL" for Gxsm-Math-Plugin !!!
  // about-function, can be "NULL"
  // can be called by "Plugin Details"
  baseinfo_about,
  // configure-function, can be "NULL"
  // can be called by "Plugin Details"
  baseinfo_configure,
  // run-function, can be "NULL", if non-Zero and no query defined, 
  // it is called on menupath->"plugin"
  NULL, // run should be "NULL" for Gxsm-Math-Plugin !!!
  // cleanup-function, can be "NULL"
  // called if present at plugin removeal
  baseinfo_cleanup
};

// special math Plugin-Strucure, use
GxsmMathOneSrcNoDestPlugin baseinfo_m1s_pi = {
  baseinfo_run
};

// Text used in Aboutbox, please update!!a
static const char *about_text = N_("Gxsm Plugin\n\n"
                                   "Basic statistic information.");

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

// Symbol "get_gxsm_math_one[_no_dest]|two_src_plugin_info" is resolved by dlsym from Gxsm, 
// used to find out which Math Type the Plugin is!! 
// Essential Plugin Function!!

GxsmMathOneSrcNoDestPlugin *get_gxsm_math_one_src_no_dest_plugin_info( void ) {
  return &baseinfo_m1s_pi; 
}

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

/* Holds the String for dumping on STDOUT */
ostringstream info;


/* callback fuer delete_event*/
gint delete_event( GtkWidget *widget, GdkEvent  *event, gpointer   data )
{
                return(MATH_OK); 
}


// init-Function
static void baseinfo_init(void)
{
  PI_DEBUG (DBG_L2, "baseinfo Plugin Init");
}

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

// configure-Function
static void baseinfo_configure(void)
{
  if(baseinfo_pi.app)
    baseinfo_pi.app->message("Baseinfo Plugin Configuration");
}

// cleanup-Function
static void baseinfo_cleanup(void)
{
  PI_DEBUG (DBG_L2, "Baseinfo Plugin Cleanup");
}

int ok_button_callback( GtkWidget *widget, gpointer data)
{
  printf("OK pressed. \n");
  return 0;
}

void dump_button_callback( GtkWidget *widget, gpointer data)
{
  cout << info << endl;
}

void comment_button_callback( GtkWidget *widget, gpointer data)
{
  // Add info to comment-field.
  gapp->xsm->data.ui.comment = g_strconcat( gapp->xsm->data.ui.comment, (const gchar*)info.str().c_str(), NULL);
  // Update textfield on screen.
  gapp->spm_update_all();
}


// run-Function
static gboolean baseinfo_run(Scan *Src)
{
  int line, col, minline, mincol, maxline, maxcol;
  double akt, minimum, maximum, summe;
  double sumsquare;
  int left, right, top, bottom;
  double rms;
  double unitleft, unitright, unittop, unitbottom;
  double unitmincol, unitminline, unitmaxcol, unitmaxline; 
  double area, average;
  MOUSERECT msr;
  MkMausSelect(Src->Pkt2d, &msr, Src->mem2d->GetNx(), Src->mem2d->GetNy());

  if( msr.xSize  < 1 || msr.ySize < 1){
    left   = 0; 
    right  = Src->mem2d->GetNx();
    top    = 0;
    bottom = Src->mem2d->GetNy();
    area   = right * bottom;
  }
  else{
    left   = msr.xLeft;
    right  = msr.xRight;
    top    = msr.yTop;
    bottom = msr.yBottom;
    area   = msr.Area;
  }

  summe = 0.;
  sumsquare = 0.;
  minimum = maximum = Src->mem2d->GetDataPkt (0, 0);
 
  minline = maxline = top;
  mincol = maxcol = left;

  for(col = left; col < right; col++){
    for(line = top; line < bottom; line++){
      akt = Src->mem2d->GetDataPkt(col, line);
      summe += akt;
      sumsquare += akt*akt;

      if (akt > maximum) {
        maximum = akt;
        maxline = line; maxcol = col;
      }
      if (akt < minimum){
        minimum = akt;
        minline = line; mincol = col;
      }
    }
  }

  average = summe / area;
  rms = ( sumsquare - 2*average*summe + average*average*area );
  rms = rms/area;
  rms = sqrt(rms);

  // convert pixelvalues to Unitvalues (but without Unitlabel)
  unitleft = Src->mem2d->data->GetXLookup(left);
  unitright= Src->mem2d->data->GetXLookup(right-1);
  unittop  = Src->mem2d->data->GetYLookup(top);
  unitbottom = Src->mem2d->data->GetYLookup(bottom-1);

  unitmincol =Src->mem2d->data->GetXLookup(mincol);
  unitminline=Src->mem2d->data->GetYLookup(minline);
  unitmaxcol =Src->mem2d->data->GetXLookup(maxcol);
  unitmaxline=Src->mem2d->data->GetYLookup(maxline);

  GtkWidget *mywin;
  GtkWidget *clist;
  GtkWidget *button1, *button2, *button3;
  GtkWidget *vbox;
  GtkWidget *hbox;

  mywin = gtk_dialog_new();
  vbox  = gtk_vbox_new(FALSE, 0);
  hbox  = gtk_hbox_new(FALSE, 0);
  gtk_container_add (GTK_CONTAINER (mywin), vbox);

  gchar *tab_titel[3] = {"Information", "DA Values", "Unitvalues"}; 
  clist = gtk_clist_new_with_titles( 3, tab_titel);

  // OK Button
  button1 = gtk_button_new_with_label ("OK");
  gtk_box_pack_start (GTK_BOX(hbox), button1, TRUE, TRUE, 10);
  gtk_signal_connect (GTK_OBJECT (button1), "clicked",
                      GTK_SIGNAL_FUNC (ok_button_callback), NULL);
  gtk_widget_show (button1);

  // Dump to stdout Button
  button2 = gtk_button_new_with_label ("Dump to Stdout");
  gtk_box_pack_start (GTK_BOX(hbox), button2, FALSE, TRUE, 10);
  gtk_signal_connect (GTK_OBJECT (button2), "clicked",
                      GTK_SIGNAL_FUNC (dump_button_callback), NULL);
  gtk_widget_show (button2);

  // Dump to comment Button
  button3 = gtk_button_new_with_label ("Dump to Comment");
  gtk_box_pack_start (GTK_BOX(hbox), button3, FALSE, TRUE, 10);
  gtk_signal_connect (GTK_OBJECT (button3), "clicked",
                      GTK_SIGNAL_FUNC (comment_button_callback), NULL);
  gtk_widget_show (button3);

  gtk_clist_set_column_width (GTK_CLIST(clist), 0, 200);
  gtk_clist_set_column_width (GTK_CLIST(clist), 1, 150);
  gtk_clist_set_column_width (GTK_CLIST(clist), 2, 400);
  
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (mywin)->vbox), // Korrekt
                       clist, TRUE, TRUE, 10);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (mywin)->vbox), // Korrekt
                       hbox, FALSE, TRUE, 10);

  gtk_widget_show (hbox);
  gtk_widget_show (clist);
  gtk_widget_show (vbox);
  gtk_widget_show (mywin);

  gtk_clist_clear((GtkCList *) clist);
  gchar dummy0[64], dummy1[64], dummy2[64]; // Is 64 enough or dynamically?
  gchar *dummy_texte[] = {dummy0, dummy1, dummy2};

        //Area was
  sprintf(dummy0, N_("Area was: "));
  sprintf(dummy1, "(%i,%i)-(%i,%i)",left,top,right-1,bottom-1);
  sprintf(dummy2, "(%s,%s)-(%s,%s)",    Src->data.Xunit->UsrString(unitleft),
                                        Src->data.Yunit->UsrString(unittop),
                                        Src->data.Xunit->UsrString(unitright),
                                        Src->data.Yunit->UsrString(unitbottom));
  gtk_clist_append((GtkCList *) clist, dummy_texte);

        //Area
  sprintf(dummy0, N_("Area: "));
  sprintf(dummy1, "%f", area);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrStringSqr(area));
  gtk_clist_append((GtkCList *) clist, dummy_texte);

        //Minimum
  sprintf(dummy0, N_("Minimum: "));
  sprintf(dummy1, "%g", minimum);
  sprintf(dummy2, Src->data.Zunit->UsrString(Src->mem2d->GetDataPkt(mincol,minline)*(Src->data.s.dz)));
  gtk_clist_append((GtkCList *) clist, dummy_texte);


  // Minimum-pos
  sprintf(dummy0, N_("Minimum-Pos: "));
  sprintf(dummy1, "(%i,%i)", mincol, minline);
  sprintf(dummy2, "(%s,%s)", Src->data.Xunit->UsrString(unitmincol), Src->data.Yunit->UsrString(unitminline));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //Maximum
  sprintf(dummy0, N_("Maximum: "));
  sprintf(dummy1, "%g", maximum);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrString(Src->mem2d->GetDataPkt(maxcol,maxline)*(Src->data.s.dz)));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //Maximum-pos
  sprintf(dummy0, N_("Maximum-Pos: "));
  sprintf(dummy1, "(%i,%i)", maxcol, maxline);
  sprintf(dummy2, "(%s,%s)", Src->data.Xunit->UsrString(unitmaxcol), Src->data.Yunit->UsrString(unitmaxline));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //sum
  sprintf(dummy0, N_("Sum: "));
  sprintf(dummy1, "%g", summe);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrString(summe));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //sumsq
  sprintf(dummy0, N_("Sum Squares: "));
  sprintf(dummy1, "%g", sumsquare);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrString(sumsquare));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //ave
  sprintf(dummy0, N_("Average: "));
  sprintf(dummy1, "%f", average);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrString(average));
  gtk_clist_append((GtkCList *) clist, dummy_texte);
        //rms
  sprintf(dummy0, N_("rms-roughness: "));
  sprintf(dummy1, "%f", rms);
  sprintf(dummy2, "%s", Src->data.Zunit->UsrString(rms));
  gtk_clist_append((GtkCList *) clist, dummy_texte);

  info << N_("Area was: \t") 
   << "\t(" << left << "," << top << ")-(" << right-1 << "," << bottom-1 << ")"    << "\t(" << Src->data.Xunit->UsrString(unitleft) << "," << Src->data.Yunit->UsrString(unittop)<<")-("<<  
             Src->data.Xunit->UsrString(unitright) << "," << Src->data.Yunit->UsrString(unitbottom) << ")" << endl
   << N_("Area size: \t") << area << "px^2,  \t" << Src->data.Zunit->UsrStringSqr(area)<< endl

   << N_("Minimum: \t") << minimum << "px  \t" <<Src->data.Zunit->UsrString(minimum) <<endl
   << N_("Min Pos: \t") << "(" << mincol << "," << minline << ")" << "\t(" << Src->data.Xunit->UsrString(unitmincol) << "," << Src->data.Yunit->UsrString(unitminline)<<")" << endl
   << N_("Maximum: \t") << maximum << "px  \t" << Src->data.Zunit->UsrString(maximum) <<endl
   << N_("Max Pos: \t") << "(" << maxcol    << "," << maxline << ")"  << "\t(" << Src->data.Xunit->UsrString(unitmaxcol) << "," << Src->data.Yunit->UsrString(unitmaxline)<<")" << endl

   << N_("Sum: \t\t")   << summe            << "px  \t"    << Src->data.Zunit->UsrString(summe) <<endl
   << N_("Sum Sq: \t")  << sumsquare        << "px^2 \t" << Src->data.Zunit->UsrString(sumsquare) <<endl
   << N_("Average: \t") << average          << "px \t"   << Src->data.Zunit->UsrString(average) <<endl 
   << N_("rms-roughness: \t") << rms        << "\t"       << Src->data.Zunit->UsrString(rms)  <<endl
   << ends;

        //  g_free(tab_titel);
        //  g_free(dummy0); g_free(dummy1); g_free(dummy2);
  return MATH_OK;
}

---