Esempio n. 1
0
static void make_links(void)

{
  int                     unit_ptr, mainUnit_Ptr;
  FlintType               weight;
  
  
  
  weight = 1.0;
  
  for ((mainUnit_Ptr) = krui_getFirstUnit();
       (mainUnit_Ptr) <= krui_getNoOfUnits(); (mainUnit_Ptr)++)
    
    /* main loop  self connections too  */
    
    for ((unit_ptr) =  krui_getFirstUnit();
	 (unit_ptr) <= krui_getNoOfUnits(); (unit_ptr)++) { 
      
      
      /* inner loop */
      /*if (NOT (unit_ptr == mainUnit_Ptr)) {  not the same entry !! */
      
      krui_setCurrentUnit(mainUnit_Ptr);
      if (NOT krui_isConnected(unit_ptr)) {
	krui_createLink(unit_ptr, weight);
	krui_setLinkWeight(weight); 
	
      }
    }
}
Esempio n. 2
0
int snns_getNoOfUnits(stEval *args, stEval *result, void *instance) {
  int unitQuantity;

  unitQuantity = krui_getNoOfUnits();
  STINT(result) = unitQuantity;
  return EC_OK;
}
Esempio n. 3
0
static void create_net_PROC(void)

{
 int create=1;

 BN_ERROR = 0;

 if(krui_getNoOfUnits() != 0) {
   if(! ui_confirmYes("Create will erase current network. Create?")) {
     create = 0;
   }
 }
 
 if(create && (PLANE_length != 0)) {

   krui_deleteNet();

   calculate_first_snns_unit_no_of_plane();
   create_snns_unit(); 
   make_links();
   krui_setLearnFunc("BPTT");
   krui_setUpdateFunc("Hopfield_Synchronous");
   krui_setInitialisationFunc("ClippHebb");
   ui_NumberOfLearnParamsChanged();
   ui_NumberOfUpdateParamsChanged();
   ui_NumberOfInitParamsChanged();
   bn_basics_refresh();
 }/* if */ 
}
Esempio n. 4
0
static inline void delUnit(IPackage&p,IConnection*c)
{
        uint32 subnet,unit,max;
        uint16 numunits;
        p>>subnet>>numunits;
        if(numunits<1)return;
        int uarr[numunits],num=0,i;
        max=krui_getNoOfUnits();
        for(i=0;i<numunits;i++){
                p>>unit;
                if(unit<=max&&unit!=0)
                        uarr[num++]=unit;
        }
        if(num==0)return;
        int err=krui_deleteUnitList(num,uarr);
        //create deletion package
        IPackage op("set");
        op<<QString("delete unit")<<subnet<<(uint16)num;
        for(i=0;i<num;i++)op<<(uint32)(uarr[i]);
        c->send(op);
        //send workaround packages
        for(i=0;i<num;i++)sendSNNS(c,"delete unit",uarr[i]-i);
}
Esempio n. 5
0
int ui_file_loadNet (Widget w, XtPointer button, caddr_t call_data)

{
    char     filename[4+MAX_NAME_LENGTH+MAX_NAME_LENGTH];
    char     string[MAX_NAME_LENGTH+MAX_NAME_LENGTH + 80]; 
             /* filename plus some text */
    Bool     performLoad = TRUE;
    char     *temp;
    int      ret_val = 0;

    /* check now for errors and react ! */
    if (strlen(ui_filenameNET) == 0) { 
	ui_confirmOk("No file specified");
	return (-1);
    }

    /* a filename is given */

    if (ui_filenameNET[0] == '/')
	sprintf(filename, "%s%s", ui_filenameNET, 
		ui_getExtension(UI_FILE_NET));
    else
	sprintf(filename, "%s/%s%s", ui_pathname, ui_filenameNET, 
		ui_getExtension(UI_FILE_NET));

    if (NOT ui_fileExist(filename, 0)) {
	ui_confirmOk("No such network file exists!");
	return(-1);
    }

    /* a file exists */
    
    if  (krui_getNoOfUnits() != 0) {
	if (NOT ui_confirmYes("Load will erase current network. Load?"))
	    performLoad = FALSE;
    } 

    if (INVERS_CREATED) {
       XtDestroyWidget(ui_InvRootWidget);
       INVERS_CREATED = 0;
    }
   
    if (performLoad) {
	sprintf(string,"Loading network: %s ...", filename);
	ui_printMessage(string);
	if(ui_controlIsCreated)ui_xSetLabel(ui_controlMessageWidget, "");
        d3_clear_xyTranslationTable ();
	ui_checkError(krui_loadNet(filename, &temp));
	if (ui_kernelError < 0){
	    ui_confirmOk("Error during loading the network!");
	} else {
	    ui_printMessage("Network loaded.");  
	    /* message to text window */
	    sprintf(string,"\n\n\nNetwork loaded from file:\n   %s\n",
		    filename);
	    ui_tw_printMessage(string);

	    /* try to load a configuration file with the same name */
            if (ui_loadCorrespondingCfg) {
                ui_loadCorrespondingCfg = TRUE;
	        sprintf(filename, "%s/%s%s", ui_pathname, ui_filenameNET, 
		        ui_getExtension(UI_FILE_CFG));
	        if (ui_fileExist(filename, 0) AND  
		    ui_confirmYes("Load corresponding configuration file")) {
		    ui_file_doLoadConfiguration(filename);
		    ret_val = 1;
	        }
	    }
	}

       /* initialization for graph */
        if(o_open){
          o_CurveNo += ((o_CurveLengths[o_CurveNo] != 0) && 
			(o_CurveNo < MAX_CURVE_NO-2)) ? (2) : (0);
          o_InitCurve();
          o_LearnStepCount = 0;
        }

	/* reset gui */
	ui_sel_resetList();       /* reset selections */
	ui_net_completeRefresh(ui_currentDisplay, UI_GLOBAL); /* show net */
	ui_printMessage("");
	ui_stat_displayStatus(ui_gridPosMouse);
	strcpy(ui_filenameSLNET, ui_filenameNET);
	ui_file_updateShellLabels();
	ui_info_makeUnitInfoPanelConsistent();
	ui_NumberOfLearnParamsChanged();
	ui_NumberOfUpdateParamsChanged();
	ui_NumberOfInitParamsChanged();
    }    
    
    return (ret_val);
}
Esempio n. 6
0
int snns_process(stEval *args, stEval *result, void *instance) {
  stEvalListHead *head = STLIST(&args[0]);
  float *params = (float*)STLIST(&args[1]);
  int numParams = STINT(&args[2]);
  FlintTypeParam *array_ptr;
  double *returnarray_ptr;
  double *iterator;
  int quant;
  int i;
  int n;
  int *n_ptr;
  krui_err errCode;
  char *errMsg;
  stEvalListHead *result_head = STLIST(result); 
  array_ptr = list_toArray(head);
  iterator = array_ptr;
  quant = krui_getNoOfUnits();
  
  i = 1;
  n = 0;
  
  for(i=1;i <= quant; i++){
	if(krui_getUnitTType(i)==INPUT){
		krui_setUnitActivation(i, *iterator);
		iterator++;
		n++;
	}
  }
  
  krui_updateNet(params, numParams);
  
 free(array_ptr);   //at the moment no space is allocated in list_toArray so commenting out this will result in a delay of the seg fault.
  
  i=0;
  n=0;
  
 
  for(i=1;i <= quant; i++){
	if(krui_getUnitTType(i)==OUTPUT){
		n++;
	}
  }

  returnarray_ptr = slMalloc(sizeof(double)*n);
  iterator = returnarray_ptr;
  i=1;
  
  
  for(i=1;i <= quant; i++){
	  if(krui_getUnitTType(i)==OUTPUT){
		  *iterator = krui_getUnitOutput(i);
		  //		  printf("Got output of %d\n", (*iterator));
		  *(iterator++);
	  }
  }
  
  
  result->values.listValue = array_toList(returnarray_ptr, n);
  result->type = AT_LIST;
  
  free(returnarray_ptr); 

  return EC_OK;

}	    
Esempio n. 7
0
static inline void modifUnit(IPackage&p,IConnection*c)
{
        uint32 subnet;
        uint16 numunits;
        int err;
        SUnit unit,ounit;
        IPackage op("set");
        op<<QString("modify unit");
        op<<subnet<<numunits;
        char buf[256];
        for(int i=0;i<numunits;i++){
                getUnit(unit,p);
                ounit=unit;
                //check for existance
                if(!(unit.mask&UNUM)){
                      int num=krui_createDefaultUnit();
                      if(num<0){
                              ounit.errcode="Unable to create unit.";
                              setUnit(ounit,op);
                              continue;
                      }
                      unit.id=ounit.id=num;
                }
                if(unit.id==0||unit.id>krui_getNoOfUnits()){
                        ounit.mask=UERR|UNUM;
                        ounit.errcode="Unit doesn't exist.";
                        setUnit(ounit,op);
                        continue;
                }
                //prototype
                if(unit.mask&UPROTO){
                        err=krui_setUnitFType(unit.id,CHR(buf,unit.prototype));
                        if(err){
                                ounit.prototype=krui_getUnitFTypeName(unit.id);
                                ounit.mask|=UERR;
                                ounit.errcode=krui_error(err);
                        }
                }
                //position
                if(unit.mask&UPOS){
                        PosType pos;
                        pos.x=unit.xpos;
                        pos.y=unit.ypos;
                        pos.z=unit.zpos;
                        krui_setUnitPosition(unit.id,&pos);
                        krui_getUnitPosition(unit.id,&pos);
                        ounit.xpos=pos.x;
                        ounit.ypos=pos.y;
                        ounit.zpos=pos.z;
                }
                //bias
                if(unit.mask&UBIAS){
                        krui_setUnitBias(unit.id,unit.bias);
                }
                //i_activation
                if(unit.mask&UIACT){
                        krui_setUnitInitialActivation(unit.id,unit.iact);
                }
                //activation
                if(unit.mask&UACT){
                        err=krui_setUnitActivation(unit.id,unit.act);
                        if(err){
                                ounit.act=krui_getUnitActivation(unit.id);
                                ounit.mask|=UERR;
                                ounit.errcode=krui_error(err);
                        }
                }
                //actfunc
                if(unit.mask&UACTF){
                        err=krui_setUnitActFunc(unit.id,CHR(buf,unit.actfunc));
                        if(err){
                                ounit.mask|=UERR;
                                ounit.errcode=krui_error(err);
                                ounit.actfunc=krui_getUnitActFuncName(unit.id);
                        }
                }
                //outfunc
                if(unit.mask&UOUTF){
                        err=krui_setUnitOutFunc(unit.id,CHR(buf,unit.outfunc));
                        if(err){
                                ounit.mask|=UERR;
                                ounit.errcode=krui_error(err);
                                ounit.outfunc=krui_getUnitOutFuncName(unit.id);
                        }
                }
                //name
                if(unit.mask&UNAME){
                        err=krui_setUnitName(unit.id,CHR(buf,unit.name));
                        if(err){
                                ounit.mask|=UERR;
                                ounit.errcode=krui_error(err);
                                ounit.name=krui_getUnitName(unit.id);
                        }
                }
                //store
                setUnit(ounit,op);
        }
        c->send(op);
}
/*****************************************************************************
  FUNCTION : ui_map_grid

  PURPOSE  : draws a grid over the MAP squares and the axis
  NOTES    : type == 1 for color display; == 0 for B/W
  RETURNS  : 
  UPDATE   : 20.05.1994
******************************************************************************/
static void 
ui_map_grid(int type)
{
    char x_String[40], y_String[40];
    int  x_steps,y_steps;
    int  n = 0;
    float x_no,y_no,x_foo=0,y_foo=0;
    int actual_sizeX,actual_sizeY;
    XPoint p1,p2,p3,p4;
    static char dash[]={6,6,6};

    /* do nothing, if no network defined */
    if(type == 0){
	if( krui_getNoOfUnits() == 0 || 
	   (MAP_BW_squaresizeX == 0) || (MAP_BW_squaresizeY == 0) )return;
    }else{ 
	if( krui_getNoOfUnits() == 0 || 
	   (MAP_squaresizeX == 0) || (MAP_squaresizeY == 0) )return;
    }

    /* set the square size */
    if(type == 0){
	actual_sizeX = MAP_BW_squaresizeX;
	actual_sizeY = MAP_BW_squaresizeY;
    }else{ 
	actual_sizeX = MAP_squaresizeX;
	actual_sizeY = MAP_squaresizeY;
    }
  
    /* set output grid of units */
    dash[0] = dash[1] = (int)(actual_sizeX*0.5 +0.5);
    XSetDashes(ui_display,MAP_GRAPH_gc[20*type],
	       (int)(actual_sizeX*0.5 +0.5)+20*type,dash,2);
    XSetLineAttributes(ui_display,MAP_GRAPH_gc[20*type],0,LineOnOffDash,
		       CapButt,JoinMiter);

    x_steps = (int)((MAP_xMax - MAP_xMin)/MAP_scaleX);
    y_steps = (int)((MAP_yMax - MAP_yMin)/MAP_scaleY);
    x_no = MAP_xMin;
    y_no = MAP_yMin;

    while(n <= 10){
	sprintf(x_String,"%1.1f",x_no);
	sprintf(y_String,"%1.1f",y_no);
	p1.x = (int)(x_foo)+20;
	p1.y = 10;
	p2.x = (x_steps)*actual_sizeX+30;
	p2.y = (int)(y_foo)+20;
	p3.x = 0; 
	p3.y = p2.y;
	p4.x = p1.x;
	p4.y = (y_steps)*actual_sizeY+20;

	XDrawString(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		    p1.x,p1.y,x_String,(int)strlen(x_String));
	XDrawString(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		    p2.x,p2.y,y_String,(int)strlen(y_String));
	XDrawString(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		    p3.x,p3.y,y_String,(int)strlen(y_String));
	XDrawString(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		    p4.x,p4.y+20,x_String,(int)strlen(x_String));
	XDrawLine(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		  p1.x,p1.y,p4.x,p4.y);
	XDrawLine(ui_display,MAP_GRAPH_win,MAP_GRAPH_gc[20*type],
		  p2.x,p2.y,p3.x+10,p3.y);
	n ++; 
	x_foo = (type==0)?x_foo+(float)(x_steps*MAP_BW_squaresizeX)/10.0:
	                  x_foo+(float)(x_steps*MAP_squaresizeX)/10.0;
	y_foo = (type==0)?y_foo+(float)(y_steps*MAP_BW_squaresizeY)/10.0:
	                  y_foo+(float)(y_steps*MAP_squaresizeY)/10.0;
	x_no += (MAP_xMax-MAP_xMin)/10.0;
	y_no += (MAP_yMax-MAP_yMin)/10.0;
    }
    XSetLineAttributes(ui_display,MAP_GRAPH_gc[20*type],0,
		       LineSolid,CapButt,JoinMiter);
}
/*****************************************************************************
  FUNCTION : ui_map_geometry

  PURPOSE  : compute the geometry of the displays and the size of the squares
  NOTES    :
  RETURNS  : 
  UPDATE   : 22.09.1994
******************************************************************************/
static void ui_map_geometry(int zoom_fact)
{
    int  maxstepsX,maxstepsY;
    int  n;
    XtWidgetGeometry geo_info, geo_data;
    XtWidgetGeometry disp_info, disp_data;
    XtWidgetGeometry view_info, view_data;
    XtGeometryResult geo_result;


    /* do nothing, if no network defined */

    if( krui_getNoOfUnits() == 0)
	return;
    maxstepsX = (int) (MAP_xMax-MAP_xMin)/MAP_scaleX;
    maxstepsY = (int) (MAP_yMax-MAP_yMin)/MAP_scaleY;


    /* set the necessary xlib environment variables */

    if(ui_col_monochromeMode){ 
	/* this is a  B&W terminal */
	MAP_GRAPH_gc[0]  = XCreateGC(ui_display,MAP_GRAPH_win,0,0); 
    } else { 
	/* this is a color terminal */
	for(n=0;n<=20;n++)
	    MAP_GRAPH_gc[n] = XCreateGC(ui_display,MAP_GRAPH_win,0,0); 
    
	/* set the foreground and background colors */
	for(n=0; n<10;n++){
	    XSetForeground(ui_display,MAP_GRAPH_gc[n],
			   (uint) ui_col_rangePixels[(int)(n*1.7)]); 
	    XSetBackground(ui_display,MAP_GRAPH_gc[n], 
			   WhitePixel(ui_display,MAP_GRAPH_screen));
	    XSetForeground(ui_display,MAP_GRAPH_gc[10+n],
			   (uint)  ui_col_rangePixels[(int)(15+n*1.7)]); 
	    XSetBackground(ui_display,MAP_GRAPH_gc[10+n],
			   WhitePixel(ui_display,MAP_GRAPH_screen));
	}
    }


    /* get widget geometry */

    geo_result = XtQueryGeometry(MAP_GRAPH_mainwidget,&geo_data,&geo_info);
  
    if(geo_result != XtGeometryYes){
	geo_info.height = 400;
	geo_info.width  = 400;
    }
    if(zoom_fact != 0){
	XtResizeWidget(MAP_GRAPH_mainwidget,geo_info.width,
		       geo_info.height,geo_info.border_width);
    }


    /* adjust squaresize */

    if(ui_col_monochromeMode){	/* this is a  B&W terminal */
	MAP_BW_squaresizeX = MAP_BW_squaresizeX + zoom_fact;
	MAP_BW_squaresizeY = MAP_BW_squaresizeY + zoom_fact;
	if(MAP_BW_squaresizeX == 0)MAP_BW_squaresizeX = 1;
	if(MAP_BW_squaresizeY == 0)MAP_BW_squaresizeY = 1;
	MAP_windowsizeX = MAP_BW_squaresizeX*maxstepsX+40;
	MAP_windowsizeY = MAP_BW_squaresizeY*maxstepsY+40;
    }else{			/* this is a color terminal */
	MAP_squaresizeX = MAP_squaresizeX + zoom_fact;
	MAP_squaresizeY = MAP_squaresizeY + zoom_fact;
	if(MAP_squaresizeX == 0)MAP_squaresizeX = 1;
	if(MAP_squaresizeY == 0)MAP_squaresizeY = 1;
	MAP_windowsizeX = MAP_squaresizeX*maxstepsX+62;
	MAP_windowsizeY = MAP_squaresizeY*maxstepsY+62;
    }
  

    /* Resize all involved windows so that they fit the data and the screen */

    XtResizeWidget(MAP_GRAPH_displaywidget,MAP_windowsizeX+62,
		   MAP_windowsizeY+62,0);
    MAP_viewsizeX = MAP_squaresizeX * maxstepsX;
    MAP_viewsizeY = MAP_squaresizeY * maxstepsY;
    geo_result = XtQueryGeometry(MAP_GRAPH_displaywidget,
				 &disp_data,&disp_info);
    geo_result = XtQueryGeometry(view,&view_data,&view_info);
    if(view_info.width > disp_info.width)
	XtResizeWidget(view,disp_info.width,
		       disp_info.height,view_info.border_width);
    else
	if(disp_info.width < geo_info.width)
	    XtResizeWidget(view,disp_info.width,
			   disp_info.height,view_info.border_width);
	else
	    XtResizeWidget(view,geo_info.width,
			   geo_info.height,view_info.border_width);

}
Esempio n. 10
0
/*****************************************************************************
  FUNCTION : ui_displMap

  PURPOSE  : Main program to display the MAPs of the network
  NOTES    : Initializes widgets and switches for color or b&w terminal
  RETURNS  : 
  UPDATE   : 22.09.94
******************************************************************************/
void ui_displMap(Widget w, caddr_t call_data)
{
    Widget donebutton,setbutton,framewidget,zoomin,zoomout;
    int maxstepX,maxstepY;
    Arg		   args[25];   
    Cardinal	   n = 0;
    char           buf[40];
  
    /* do nothing, if no network is defined */
    if( (krui_getNoOfUnits()) == 0){
	ui_confirmOk("No network loaded !");
	return;
    }
  

    /* If a MAP window already exists, just put it on top */

    if(MAP_WINDOW_created == 1){
	XRaiseWindow (XtDisplay (MAP_GRAPH_mainwidget), 
		      XtWindow (MAP_GRAPH_mainwidget));
	return;
    }
  

    /* Create all necessary widgets */

    n = 0;
    sprintf(buf," SNNS Unit Projection\n");
    MAP_GRAPH_mainwidget = 
	XtCreatePopupShell(buf,topLevelShellWidgetClass,ui_toplevel,args,n);
    n = 0;
    framewidget = XtCreateManagedWidget("form",formWidgetClass,
					MAP_GRAPH_mainwidget,args,n);
    donebutton  = ui_xCreateButtonItem("done", framewidget, NULL, NULL);

    zoomin = ui_xCreateButtonItem("zoomin",framewidget,NULL,donebutton);
    setbutton = ui_xCreateButtonItem("setup",framewidget,zoomin,NULL);
    zoomout = ui_xCreateButtonItem("zoomout",framewidget,zoomin,donebutton);
    n = 0;
    XtSetArg(args[n], XtNx, 0);n++;
    XtSetArg(args[n], XtNy, 0);n++;
    XtSetArg(args[n], XtNwidth, 210); n++;
    XtSetArg(args[n], XtNheight, 25); n++;
    XtSetArg(args[n], XtNinternalHeight, 1); n++;
    XtSetArg(args[n], XtNinternalWidth , 1); n++;
    XtSetArg(args[n], XtNborderWidth,  0); n++;
    XtSetArg(args[n], XtNhorizDistance, 30);      n++;
    XtSetArg(args[n], XtNfromHoriz, setbutton);      n++;
    XtSetArg(args[n], XtNfromVert, NULL); n++;
    XtSetArg(args[n], XtNleft  , XtChainLeft);  n++;
    XtSetArg(args[n], XtNright , XtChainLeft); n++;
    XtSetArg(args[n], XtNtop   , XtChainTop);   n++;
    XtSetArg(args[n], XtNbottom, XtChainTop);n++;
    scale = XtCreateManagedWidget("Label",formWidgetClass,framewidget,args,n);
  
    n = 0;
    XtSetArg(args[n], XtNx, 0);n++;
    XtSetArg(args[n], XtNy, 0);n++;
    XtSetArg(args[n], XtNborderWidth,  1); n++;
    XtSetArg(args[n], XtNwidth,  MAP_windowsizeX+62); n++;
    XtSetArg(args[n], XtNheight, MAP_windowsizeY+62); n++;
    XtSetArg(args[n], XtNallowHoriz, TRUE);n++;
    XtSetArg(args[n], XtNallowVert, TRUE);n++;
    XtSetArg(args[n], XtNforceBars, TRUE);n++;
    XtSetArg(args[n], XtNfromHoriz, NULL);      n++;
    XtSetArg(args[n], XtNfromVert, zoomin); n++;
    XtSetArg(args[n], XtNvertDistance, 10); n++;
    XtSetArg(args[n], XtNleft  , XtChainLeft);  n++;
    XtSetArg(args[n], XtNright , XtChainRight); n++;
    XtSetArg(args[n], XtNtop   , XtChainTop);   n++;
    XtSetArg(args[n], XtNbottom, XtChainBottom);n++;
    view = XtCreateManagedWidget("view",viewportWidgetClass,framewidget,args,n);
    MAP_GRAPH_displaywidget =
	ui_createMyScreen("screen",view,MAP_windowsizeX,MAP_windowsizeY,
			  NULL,scale);
    MAP_WINDOW_created = 1;
  
  
    /* define the routines to be called for widget events */

    XtAddCallback(donebutton, XtNcallback,
		  (XtCallbackProc)ui_map_close,MAP_GRAPH_mainwidget);
    XtAddCallback(setbutton, XtNcallback,(XtCallbackProc)ui_map_setup,NULL);
    XtAddCallback(zoomin, XtNcallback,(XtCallbackProc)ui_map_zoom_in,NULL);
    XtAddCallback(zoomout, XtNcallback,(XtCallbackProc)ui_map_zoom_out,NULL);
    XtAddEventHandler(MAP_GRAPH_displaywidget, 
		      StructureNotifyMask | ExposureMask, GraphicsExpose,
		      (XtEventHandler) ui_map_event,ui_display);
    XtAddEventHandler(framewidget,KeyPressMask,FALSE,
		      (XtEventHandler)ui_key_control,(Cardinal *) 0);
  

    /* set the maximum size of each square and the size of the whole window */
    maxstepX = (int)((float)(MAP_xMax - MAP_xMin)/ MAP_scaleX);
    maxstepY = (int)((float)(MAP_yMax - MAP_yMin)/ MAP_scaleY);

    if(ui_col_monochromeMode){
	/* B&W terminal => variable square size needed */
	MAP_squaresizeX = (maxstepX > MAP_viewsizeX/MAP_BW_squaresizeX)? 
                           MAP_BW_squaresizeX: 
  	                   (int)((float)MAP_viewsizeX/(float)maxstepX);
	MAP_windowsizeX = MAP_squaresizeX*maxstepX+40;
	MAP_squaresizeY = (maxstepY > MAP_viewsizeY/MAP_BW_squaresizeY)? 
                           MAP_BW_squaresizeY: 
  	                   (int)((float)MAP_viewsizeY/(float)maxstepY);
	MAP_windowsizeX = MAP_squaresizeX*maxstepX+40;
    }else{
	/* color terminal => fixed square size */
	MAP_squaresizeX = 
	    ( maxstepX > MAP_viewsizeX/5)?5:(int)(MAP_viewsizeX/maxstepX);
	MAP_squaresizeY = 
	    ( maxstepY > MAP_viewsizeY/5)?5:(int)(MAP_viewsizeY/maxstepY);
	MAP_windowsizeX = MAP_squaresizeX*maxstepX+40;
	MAP_windowsizeY = MAP_squaresizeY*maxstepY+40;
    }
  
    /* Realize the window */
    XtPopup(MAP_GRAPH_mainwidget, XtGrabNone);
  
    MAP_GRAPH_screen = DefaultScreen(ui_display);
    MAP_GRAPH_win    = XtWindow(MAP_GRAPH_displaywidget);
}