PanView.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: PanView.C
 * ========================================
 * 
 * Copyright (C) 2003 The Free Software Foundation
 *
 * Authors: Kristan Temme <etptt@users.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.
 */

/* 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!
 * --------------------------------------------------------------------------------
% BeginPlugInDocuSection
% PlugInDocuCaption: Pan View

% PlugInName: PanView
% PlugInAuthor: Kristan Temme, Thorsten Wagner
% PlugInAuthorEmail: stm@users.sf.net
% PlugInMenuPath: Tools/Pan View 
% PlugInDescription
 This is a handy tool which shows you, where your current scan is in the
 range of the maximum scan. Especially it gives you an error message if you
 leave the scan area. It also shows the position of rotated scans.

 In addition the current realtime XY position of the tip plus it
 indicates the Z-position of the tip is visualized by the marker on
 the right edge of the window.

\begin{figure}[hbt]
\center { \fighalf{PanView}}
\caption{The PanView window.}
\label{fig:PanView}
\end{figure}


% PlugInUsage
 Open the PanView window via GXSM main menu \GxsmMenu{Windows/Pan View}.

% OptPlugInNotes
 The tip-position is close to realtime, but it is refreshed only
 several times per second and only if GXSM is idle. Thus the
 display/update may get stuck at times GXSM is very busy. Never the
 less the tip position is read back from the DSP and thus indicates
 the true position, regardless what in happening to GXSM of the DSP --
 so if anything goes wrong, you will see it here!

% OptPlugInHints
 For now the plug-in assumes a scan which is centered in the middle of the
 scan not in the middle of the topline (as default for the pci32).

% OptPlugInKnownBugs
 The plugin has a not yet resolved "cleanup" problem at unloading and
 will force GXSM to early exit, but only effects it on GXSM-exit. This
 will only occurr if the PanView Window was opened before exiting
 GXSM.

% EndPlugInDocuSection
 * -------------------------------------------------------------------------------- 
 */
#include "config.h"
#include "gxsm/plugin.h"
#include "glbvars.h"
#include "xsmtypes.h"

#include "PanView.h"

// Plugin Prototypes
static void PanView_init (void);
static void PanView_query (void);
static void PanView_about (void);
static void PanView_configure (void);
static void PanView_cleanup (void);

PanView *Pan_Window = NULL;
static void PanView_run(GtkWidget *w, void *data);
gboolean refresh_function(GtkWidget *w, GdkEvent *event, void *data);

gboolean PanView_valid = FALSE;

#define PRE_AREA 0

// #define PI_DEBUG(NN, TXT) std::cout << TXT << std::endl


//
// Gxsm plugin discription
//
GxsmPlugin PanView_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,                   // filled in just after init() is called !!!
        "Pan View",
        NULL,                      
        "Visualisation of the scan position",
        "Kristan Temme, Thorsten Wagner",
        N_("_Windows/"),
        N_("Pan View"),
        NULL,
        "No further info",
        NULL,          
        NULL,          
        PanView_init,  
        NULL,  
        PanView_about,
        PanView_configure,
        PanView_run,
        PanView_cleanup
};

//
//Text used in the About Box
//
static const char *about_text = N_("A little scanning reference");
                                   
        
//
// 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 ){ 
        PanView_pi.description = g_strdup_printf(N_("Gxsm pan view window %s"), VERSION);
        return &PanView_pi; 
}

//
// init-Function
//

static void PanView_init(void)
{
        PI_DEBUG(DBG_L2, "PanView Plugin Init" );
}

//
// about-Function
//
static void PanView_about(void)
{
        const gchar *authors[] = { PanView_pi.authors, NULL};
        gtk_widget_show(gnome_about_new ( PanView_pi.name,
                                          VERSION,
                                          N_("(C) 2003 the Free Software Foundation"),
                                          about_text,
                                          authors,
                                          NULL,NULL,NULL
                                ));
}
//
// configure-Function
//
static void PanView_configure(void)
{
        if(PanView_pi.app)
                PanView_pi.app->message("PanView Plugin Configuration");

        if (Pan_Window){
                if (Pan_Window->finish ()){
                        PanView_pi.app->message("PanView: Starting tip monitor");
                        Pan_Window->start_tip_monitor ();
                } else {
                        PanView_pi.app->message("PanView: Stopping tip monitor");
                        Pan_Window->stop_tip_monitor ();
                }
        }
}

//
// cleanup-Function, make sure the Menustrings are matching those above!!!
//
static void PanView_cleanup(void)
{
        PanView_valid = FALSE;

        PI_DEBUG(DBG_L2, "PanView_cleanup(void). Entering.\n");
        if (Pan_Window) {
                delete Pan_Window;
        }
        PI_DEBUG(DBG_L2, "PanView_cleanup(void). Exiting.\n");
}

static void PanView_refresh_callback (gpointer data){
        if (Pan_Window)
                Pan_Window -> refresh ();
}

static gint PanView_tip_refresh_callback (PanView *pv){

        if (!PanView_valid) return FALSE;

        if (pv){
                if (! pv -> finish ()){
                        pv -> tip_refresh ();
                        return TRUE;
                }
                pv -> finish (-999);
        }
        return FALSE;
}

//Gtk+ Signal Funktion
static void PanView_run(GtkWidget *w, void *data)
{
        if (!Pan_Window){
                Pan_Window = new PanView(PanView_pi.app->getApp());
                PanView_pi.app->ConnectPluginToSPMRangeEvent (PanView_refresh_callback);
        }

        Pan_Window->run();
        Pan_Window->start_tip_monitor ();

        PI_DEBUG(DBG_L2, "A new Pan Window was opened" );
}

PanView ::  PanView (GtkWidget *a) : GnomeAppService (a){
        int i,j;

        finish (FALSE);
        timer_id = 0;

        AppWidgetInit (N_("Pan View: scan area"));

        GtkWidget *box = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (box);
        gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0);

        // ========================================

        /*Set up the visual and colormap*/
        gtk_widget_push_visual(gdk_rgb_get_visual());
        gtk_widget_push_colormap(gdk_rgb_get_cmap());
        
        canvas = gnome_canvas_new_aa();
        
        /* Now pop the visual and colormap*/
        gtk_widget_pop_colormap();
        gtk_widget_pop_visual();
                
        gtk_widget_set_size_request (canvas, 2*WINDOW_SIZE+15, 2*WINDOW_SIZE+7);

        gtk_widget_show (canvas);
        gtk_container_add (GTK_CONTAINER (box), canvas);


        /* set up the system relevant Parameters */
        update_expanded_scan_limits ();

        /*gnome_canvas_set_pixels_per_unit( GNOME_CANVAS (canvas), PPU);*/      
        gnome_canvas_set_scroll_region( GNOME_CANVAS ( canvas ), TO_CANVAS_X(max_x), TO_CANVAS_Y(max_y),
                                        TO_CANVAS_X(min_x), TO_CANVAS_Y(min_y));
                         

        /*create a rectangle*/
        pan_area = gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), 
                                           gnome_canvas_rect_get_type(),
                                           "x1", TO_CANVAS_X(max_x),
                                           "x2", TO_CANVAS_X(min_x),
                                           "y1", TO_CANVAS_Y(max_y),
                                           "y2", TO_CANVAS_Y(min_y),
                                           "fill_color","white",
                                           "outline_color","red",
                                           "width_units", 1.5,
                                           NULL );
        
        pre_current_view = NULL;
        current_view = NULL;
        tip_marker = NULL;
        tip_marker_z = NULL;

        PanView_valid = TRUE;

        refresh ();
        tip_refresh ();
}

PanView::~PanView (){

        PanView_valid = FALSE;

        g_print ("PanView :: ~PanView ()\n");
        g_print ("PanView :: ~PanView () -- stop_tip_monitor \n");
        stop_tip_monitor ();
        g_print ("PanView :: ~PanView () -- OK.\n");
}

void PanView::run()
{
        show ();
}

void PanView::start_tip_monitor (){
        if (!timer_id){
                g_print ("PanView::start_tip_monitor \n");
                finish (FALSE);
                timer_id = gtk_timeout_add (150, (GtkFunction) PanView_tip_refresh_callback, this);
        }
}

void PanView::stop_tip_monitor (){
        if (timer_id){
                g_print ("PanView::stop_tip_monitor \n");
                finish (TRUE);
//              while (finish () != -999){
//                      g_print (".\n");
//                      usleep (20000);
//              }
                gtk_timeout_remove (timer_id);
                timer_id = 0;
        }
        tip_refresh ();
        g_print ("PanView::stop_tip_monitor OK.\n");
}

void PanView::update_expanded_scan_limits (){
        // This should give the maximum voltage after the HV-Amp

        max_x =    xsmres.AnalogVMaxOut*gapp->xsm->Inst->VX();
        min_x =   -xsmres.AnalogVMaxOut*gapp->xsm->Inst->VX();
        max_y =    xsmres.AnalogVMaxOut*gapp->xsm->Inst->VY();
        min_y =   -xsmres.AnalogVMaxOut*gapp->xsm->Inst->VY();
        max_z =    xsmres.AnalogVMaxOut*gapp->xsm->Inst->VZ();
        min_z =   -xsmres.AnalogVMaxOut*gapp->xsm->Inst->VZ();

        // expand if analog offset adding is used 
        // --> but that's not all, more to do:
        // ** check scan range if rotated
        if (gapp->xsm->Inst->OffsetMode() == OFM_ANALOG_OFFSET_ADDING){
                max_x =    xsmres.AnalogVMaxOut*gapp->xsm->Inst->VX0();
                min_x =   -xsmres.AnalogVMaxOut*gapp->xsm->Inst->VX0();
                max_y =    xsmres.AnalogVMaxOut*gapp->xsm->Inst->VY0();
                min_y =   -xsmres.AnalogVMaxOut*gapp->xsm->Inst->VY0();
        }
}

void PanView :: tip_refresh()
{
        // tip marker item
        GnomeCanvasPoints* tipmark_points = gnome_canvas_points_new (4);
        double rsz = max_x/15.;
        double asp = 1.67;
        double x,y,z;
        x=y=z=0.;

        if (!PanView_valid) return;

        if (IS_NOCARD){
                ;
        }
        else{
                // ** I'll fix this sub-routine to return the correct x/y/z volated including added offsets if used!
                gapp->xsm->hardware->RTQuery ("zxy", z, x, y); // get tip position in volts
        }

        // XY Scan&Offset position marker
        tipmark_points->coords[0] = TO_CANVAS_X (x-rsz/asp);
        tipmark_points->coords[1] = TO_CANVAS_Y (y+rsz);
        tipmark_points->coords[2] = TO_CANVAS_X (x+rsz/asp);
        tipmark_points->coords[3] = TO_CANVAS_Y (y-rsz);
        tipmark_points->coords[4] = TO_CANVAS_X (x-rsz/asp);
        tipmark_points->coords[5] = TO_CANVAS_Y (y-rsz);
        tipmark_points->coords[6] = TO_CANVAS_X (x+rsz/asp);
        tipmark_points->coords[7] = TO_CANVAS_Y (y+rsz);

        if (tip_marker)
                gnome_canvas_item_set (tip_marker, 
                                       "points", tipmark_points,
                                       "fill_color", finish () ? "red":"yellow",
                                       NULL);
        else
                tip_marker = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),  
                                                    gnome_canvas_polygon_get_type (),
                                                    "points", tipmark_points,
                                                    "outline_color", "blue",
                                                    "fill_color", finish () ? "red":"yellow",
                                                    "width_units", 0.5,
                                                    NULL);
                
        gnome_canvas_item_raise_to_top (tip_marker);

        // Z tip position marker
        rsz = 1./15.;
        asp = 1.67;
        tipmark_points->coords[0] = TO_CANVAS_NORMAL_X (1.+rsz);
        tipmark_points->coords[1] = TO_CANVAS_NORMAL_Y (z/max_z-rsz/asp);
        tipmark_points->coords[2] = TO_CANVAS_NORMAL_X (1.-rsz);
        tipmark_points->coords[3] = TO_CANVAS_NORMAL_Y (z/max_z+rsz/asp);
        tipmark_points->coords[4] = TO_CANVAS_NORMAL_X (1.-rsz);
        tipmark_points->coords[5] = TO_CANVAS_NORMAL_Y (z/max_z-rsz/asp);
        tipmark_points->coords[6] = TO_CANVAS_NORMAL_X (1.+rsz);
        tipmark_points->coords[7] = TO_CANVAS_NORMAL_Y (z/max_z+rsz/asp);


        if (tip_marker_z)
                gnome_canvas_item_set (tip_marker_z, 
                                       "points", tipmark_points,
                                       "fill_color", fabs(z/max_z) < 0.8 ? "green":"red",
                                       NULL);
        else
                tip_marker_z = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS (canvas)),  
                                                      gnome_canvas_polygon_get_type (),
                                                      "points", tipmark_points,
                                                      "outline_color", "green",
                                                      "fill_color", fabs(z/max_z) < 0.8 ? "green":"red",
                                                      "width_units", 0.5,
                                                      NULL);
        
        gnome_canvas_points_free (tipmark_points);
        gnome_canvas_item_raise_to_top (tip_marker_z);
}

void PanView :: refresh()
{
        static int prev_error = FALSE;
        int error = FALSE;
        double max_corn[4][2];
        double x_offset;
        double y_offset;
        double alpha;
                
        int     i,j; 

        if (!PanView_valid) return;

        /* update system parameters */
        update_expanded_scan_limits ();

        PI_DEBUG (DBG_L2, min_x<<"<X<"<<max_x );
        PI_DEBUG (DBG_L2, min_y<<"<Y<"<<max_y );

        /*fill in the corners of the scanning area*/
        if (IS_SPALEED_CTRL||xsmres.ScanOrgCenter){ // Origin is middle of scan
                point[0][0] = -0.5*gapp->xsm->data.s.nx*gapp->xsm->data.s.dx/xsmres.XPiezoAV;   
                point[0][1] = +0.5*gapp->xsm->data.s.ny*gapp->xsm->data.s.dy/xsmres.YPiezoAV;
                 
                point[1][0] = -1*point[0][0];        point[1][1] = +1*point[0][1];
                point[2][0] = -1*point[0][0];        point[2][1] = -1*point[0][1];
                point[3][0] = +1*point[0][0];        point[3][1] = -1*point[0][1];
        }
        else{                                       // Origin is center of top line
                point[0][0] =-0.5*gapp->xsm->data.s.nx*gapp->xsm->data.s.dx/xsmres.XPiezoAV;    point[0][1] = 0;
                point[1][0] = -1*point[0][0];        point[1][1] = 0;
                point[2][0] = -1*point[0][0];        point[2][1] = -gapp->xsm->data.s.ny*gapp->xsm->data.s.dy/xsmres.YPiezoAV;
                point[3][0] = +1*point[0][0];        point[3][1] = +1*point[2][1];
        }
        PI_DEBUG (DBG_L2, "Original coordinates: \t"<< 
                  point[0][0]<<","<<point[0][1]<<"\t"<<
                  point[1][0]<<","<<point[1][1]<<"\t"<<
                  point[2][0]<<","<<point[2][1]<<"\t"<<
                  point[3][0]<<","<<point[3][1] );

        /*read the parameters from the control*/
        y_offset = gapp->xsm->data.s.y0/xsmres.YPiezoAV;
        x_offset = gapp->xsm->data.s.x0/xsmres.XPiezoAV;
        alpha   = gapp->xsm->data.s.alpha;      

#if PRE_AREA
        /* this are the edges of the scan area plus the prescan */
        double w = 2*gapp->xsm->data.s.dx*gapp->xsm->data.hardpars.LS_nx_pre/xsmres.XPiezoAV;
        pre_point[0][0] = point[0][0]-w; pre_point[0][1] = point [0][1];
        pre_point[1][0] = point[1][0]+w; pre_point[1][1] = point [1][1];
        pre_point[2][0] = point[2][0]+w; pre_point[2][1] = point [2][1];
        pre_point[3][0] = point[3][0]-w; pre_point[3][1] = point [3][1];
#endif

        /*Apply the current offset and rotation to prescan area*/
        for(i=0;i<4;i++){
                transform(max_corn[i], point[i], -alpha, y_offset, x_offset);
#if PRE_AREA
                transform(max_corn[i],pre_point[i],-alpha,y_offset,x_offset);
#endif
        }
        
        /*check whether our scanning area (extended by the prescan) is within the limits*/      
        for(i=0; i < 4 && !error;i++){
                if(max_corn[i][0] >= max_x || max_corn[i][0] <= min_x)
                        error = TRUE;
                
                if(max_corn[i][1] >= max_y || max_corn[i][1] <= min_y)
                        error = TRUE;
                                        
        }
        
        if(max_corn[0][0] == corn_oo && max_corn[3][1] == corn_ii)
                error = FALSE;
        
        corn_oo = max_corn[0][0];
        corn_ii = max_corn[3][1];


#if PRE_AREA

        /*redraw the PanView prescan area */
        pre_scanarea_points = gnome_canvas_points_new (4);
        for(i=0,j=0;i < 4;i++){
                pre_scanarea_points->coords[j]   = TO_CANVAS_X(max_corn[i][0]);
                pre_scanarea_points->coords[j+1] = TO_CANVAS_Y(max_corn[i][1]);
                j+=2;
        }
        
        if (pre_current_view)
                gnome_canvas_item_set (pre_current_view, 
                                       "points", pre_scanarea_points, 
                                       "outline_color", "black", 
                                       "fill_color","white",
                                       NULL );
        else
                pre_current_view = gnome_canvas_item_new( gnome_canvas_root (GNOME_CANVAS (canvas)), 
                                                          gnome_canvas_polygon_get_type(),
                                                          "points", pre_scanarea_points,
                                                          "fill_color", "white",
                                                          "outline_color", "black",
                                                          "width_units", 1.5,
                                                          NULL );
        
        gnome_canvas_points_free (pre_scanarea_points);
#endif

        /*Apply the current offset and rotation to scan area*/
        for(i=0;i<4;i++)
                transform(max_corn[i],point[i],-alpha,y_offset,x_offset);       

        PI_DEBUG (DBG_L2, "Transformed coordinates: \t"<<
                  max_corn[0][0]<<","<<max_corn[0][1]<<"\t"<<
                  max_corn[1][0]<<","<<max_corn[1][1]<<"\t"<<
                  max_corn[2][0]<<","<<max_corn[2][1]<<"\t"<<
                  max_corn[3][0]<<","<<max_corn[3][1] );

        /*redraw the PanView scanning area*/ 
        GnomeCanvasPoints *scanarea_points = gnome_canvas_points_new (4);
        for(i=0,j=0;i < 4;i++){
                scanarea_points->coords[j]   = TO_CANVAS_X(max_corn[i][0]);
                scanarea_points->coords[j+1] = TO_CANVAS_Y(max_corn[i][1]);
                j+=2;
        }
        
        if (current_view)
                gnome_canvas_item_set(current_view, 
                                      "points", scanarea_points,
                                      "outline_color", (error)?"red":"black",
                                      "fill_color",(error)?"red":"black",
                                      NULL );
        else
                current_view = gnome_canvas_item_new( gnome_canvas_root (GNOME_CANVAS (canvas)), 
                                                      gnome_canvas_polygon_get_type(),
                                                      "points", scanarea_points,
                                                      "fill_color", "black",
                                                      "outline_color", "black",
                                                      "width_units", 1.5,
                                                      NULL);
        
        gnome_canvas_points_free (scanarea_points);

        if(error && !prev_error){
                prev_error = error;
                warning ("Scanning area is out of limits!");
                PI_DEBUG(DBG_L2, "Error: Scanning area is out of limits!" );
        }
        prev_error = error;
}

void PanView :: transform(double *dest, double *src, double rot, double y_off, double x_off)
{
        double D[2][2];
        int i,j;        
        
        D[0][0] =   cos(TO_RAD(rot));
        D[1][1] =   cos(TO_RAD(rot));
        D[0][1] =  -sin(TO_RAD(rot));
        D[1][0] =   sin(TO_RAD(rot));

        dest[0] = 0;
        dest[1] = 0;
        
        for(i=0; i<2 ; i++)                     
                for(j=0;j<2;j++)
                        dest[i] += D[i][j]*src[j];

        dest[0] += x_off;
        dest[1] += y_off;
        return;
}

// ENDE PAN VIEW CONTROL ///////////////

---