---

emcplot3d.cc

Go to the documentation of this file.

//
// This code was created by Jeff Molofee '99
// (ported to Linux/GLUT by Richard Campbell '99)
//
// If you've found this code useful, please let me know.
//
// Visit Jeff at www.demonews.com/hosted/nehe
// (email Richard Campbell at ulmont@bellsouth.net)
//
#include <GL/glut.h>    // Header File For The GLUT Library
#include <GL/gl.h>      // Header File For The OpenGL32 Library
#include <GL/glu.h>     // Header File For The GLu32 Library
#include <GL/glx.h>     // Header File For The GLu32 Library
#include <stdio.h>      // Header file for standard file i/o.
#include <stdlib.h>     // Header file for malloc/free.
#include <unistd.h>     // needed to sleep.
#include <math.h>
#include <string.h>

#include "rcs.hh"
#include "emc.hh"
#include "canon.hh"
#include "interpl.hh"
#include "rs274ngc.hh"

#ifdef NEW_INTERPRETER
#include "rs274ngc_return.hh"
#endif


PM_ROTATION_VECTOR view_rv;

/* note that the message must be a string with a %s in it */
#define DRIVER_ERROR(message,item) if(1)    \
   {fprintf(stderr, message, item);         \
    fprintf(stderr, "\n");                  \
    return RS274NGC_ERROR; }                \
   else


static RCS_STAT_CHANNEL * emcStatusBuffer = 0;
static RCS_CMD_CHANNEL * emcCommandBuffer = 0;
static RCS_LINKED_LIST *livePlotList = 0;
static RCS_LINKED_LIST *staticPlotList = 0;
static EmcPose last_pose;
static int timer_count=0;
static int showProgrammedPlot = 1;
static int show_stewart_platform = 0;

struct Point2D
{
  double x,y;
};

struct StewartSpecs {
public:
  double plate_height;
  Point2D plate_points[6];
  double mount_height;
  Point2D mount_points[6];
  double strut_diameter;
  double top_mount_diameter;
  double posts_diameter;
};


static int refresh_count=5;
static double scale=1.0;
static int timer_period=10;
static int redraw_needed=1;


static StewartSpecs stewart_platform_specs;

void ReadStewartSpecs(const char *filename)
{
  stewart_platform_specs.plate_height = 1.0;
  for(int i = 0; i< 3; i++)
    {
      stewart_platform_specs.plate_points[2*i].x = 2.0*cos(2.0*PM_PI/3.0*i - PM_PI/30.0);
      stewart_platform_specs.plate_points[2*i].y = 2.0*sin(2.0*PM_PI/3.0*i - PM_PI/30.0);
      stewart_platform_specs.plate_points[2*i+1].x = 2.0*cos(2.0*PM_PI/3.0*i + PM_PI/30.0);
      stewart_platform_specs.plate_points[2*i+1].y = 2.0*sin(2.*PM_PI/3.0*i + PM_PI/30.0);
    }
  stewart_platform_specs.mount_height = 1.0;
  for(int i = 0; i< 3; i++)
    {
      stewart_platform_specs.mount_points[2*i+1].x = 10.0*cos(2.0*PM_PI/3.0*i +PM_PI/3.0);
      stewart_platform_specs.mount_points[2*i+1].y = 10.0*sin(2.0*PM_PI/3.0*i +PM_PI/3.0);
      stewart_platform_specs.mount_points[(2*i+2)%6].x = 10.0*cos(2.0*PM_PI/3.0*i+ PM_PI/3.0);
      stewart_platform_specs.mount_points[(2*i+2)%6].y = 10.0*sin(2.0*PM_PI/3.0*i+ PM_PI/3.0);
    }




}



#if 0
extern FILE* _interpreter_fp=NULL;
extern char  _interpreter_linetext[256];
// static char  _interpreter_blocktext[256];

// NML channels
static RCS_CMD_CHANNEL * emcCommandBuffer = 0;
static NML * emcErrorBuffer = 0;

// NML command channel data pointer
static RCS_CMD_MSG * emcCommand = 0;
#endif

// global EMC status
EMC_STAT * emcStatus = 0;


/* ascii code for the escape key */
#define ESCAPE 27

/* The number of our GLUT window */
int window;

/* storage for one texture  */
GLuint texture[1];

GLuint plot;             // storage for the display list
GLuint lplot=0;              // storage for the 2nd display list
GLuint plot_rotframes;             // storage for the display list
GLuint lplot_rotframes=0;              // storage for the 2nd display list
GLuint xloop;            // loop for x axis.
GLuint yloop;            // loop for y axis.

GLfloat xrot=-45.0;            // rotates cube on the x axis.
GLfloat yrot=-45.0;            // rotates cube on the y axis.
GLfloat zrot=-45.0;            // rotates cube on the z axis.

GLfloat xtran;            // translates cube on the x axis.
GLfloat ytran;            // translates cube on the y axis.
GLfloat ztran;            // translates cube on the z axis.

int show_plot_rotation_frames = 0;
int showLivePlot = 1;


/* Image type - contains height, width, and data */
struct Image {
    unsigned long sizeX;
    unsigned long sizeY;
    char *data;
};
typedef struct Image Image;

const char *Filename = NULL;

GLuint base;            // base display list for the font set.
GLfloat cnt1;           // 1st counter used to move text & for coloring.
GLfloat cnt2;           // 2nd counter used to move text & for coloring.

GLvoid BuildFont(GLvoid)
{
    Display *dpy;
    XFontStruct *fontInfo;  // storage for our font.

    base = glGenLists(96);                      // storage for 96 characters.

    // load the font.  what fonts any of you have is going
    // to be system dependent, but on my system they are
    // in /usr/X11R6/lib/X11/fonts/*, with fonts.alias and
    // fonts.dir explaining what fonts the .pcf.gz files
    // are.  in any case, one of these 2 fonts should be
    // on your system...or you won't see any text.

    // get the current display.  This opens a second
    // connection to the display in the DISPLAY environment
    // value, and will be around only long enough to load
    // the font.
    dpy = XOpenDisplay(NULL); // default to DISPLAY env.

    fontInfo = XLoadQueryFont(dpy, "-adobe-helvetica-medium-r-normal--18-*-*-*-p-*-iso8859-1");
    if (fontInfo == NULL) {
        fontInfo = XLoadQueryFont(dpy, "fixed");
        if (fontInfo == NULL) {
            printf("no X font available?\n");
        }
    }

    // after loading this font info, this would probably be the time
    // to rotate, scale, or otherwise twink your fonts.

    // start at character 32 (space), get 96 characters (a few characters past z), and
    // store them starting at base.
    glXUseXFont(fontInfo->fid, 32, 96, base);

    // free that font's info now that we've got the
    // display lists.
    XFreeFont(dpy, fontInfo);

    // close down the 2nd display connection.
    XCloseDisplay(dpy);
}

GLvoid KillFont(GLvoid)                         // delete the font.
{
    glDeleteLists(base, 96);                    // delete all 96 characters.
}

GLvoid glPrint(char *text)                      // custom gl print routine.
{
    if (text == NULL) {                         // if there's no text, do nothing.
        return;
    }

    glPushAttrib(GL_LIST_BIT);                  // alert that we're about to offset the display lists with glListBase
    glListBase(base - 32);                      // sets the base character to 32.

    glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); // draws the display list text.
    glPopAttrib();                              // undoes the glPushAttrib(GL_LIST_BIT);
}

/*********************************************************************/

/* interpret_from_file

Returned Value: (RS274NGC_OK or RS274NGC_ERROR)
  If the end of the file has been reached without an m2 or m30
  having been read, this returns ENDFILE.
  Otherwise, if any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. rs274ngc_init returns RS274NGC_ERROR.
   2. read_tool_file returns RS274NGC_ERROR.
   3. read_setup_file returns RS274NGC_ERROR.
   4. rs274ngc_open returns RS274NGC_ERROR.
   5. rs274ngc_read returns RS274NGC_ERROR and no_stop is off.
   6. rs274ngc_execute returns RS274NGC_ERROR and no_stop is off.
   7. fgets is called and returns NULL.

Side Effects:
   An NC-program file is opened, interpreted, and closed.

Called By:
   main

This emulates the way the EMC system uses the interpreter.

When this function starts, it prompts the user for the name of a
tool file and then the name of a setup file.  The user may enter a
file name followed by a carriage return or just enter a carriage
return after both prompts. If a file name is entered, the file will be
used. If not, default tool or setup information will be used.

If the no_stop argument is OFF, this returns if an error is found.

If the no_stop argument is ON, an error does not stop interpretation.
However, since the file will have been closed, it has to be reopened
and reread up to the next unread line.

An alternate method of getting back to the right place in a file
would be to use fgetpos and fsetpos.

*/

int interpret_from_file( /* ARGUMENT VALUES                   */
 const char * filename,        /* string: name of the rs274kt file  */
 int no_stop)            /* switch which is ON or OFF         */
{
  int status;
  int reads;
  //  char trash[INTERP_TEXT_SIZE];
  int program_status;

  program_status SET_TO RS274NGC_OK;
  if (rs274ngc_init() ISNT RS274NGC_OK)
    {
      printf("rs274ngc_init failed.\n");
      return -1;
    }
  if (rs274ngc_open(filename) ISNT RS274NGC_OK)
    {
      printf("rs274ngc_open(%s) failed.\n",filename);
      return -1;
    }
  for(reads SET_TO 0; ; reads++)
    {
      interp_list.set_line_number(reads);
      status SET_TO rs274ngc_read();
      if (status IS RS274NGC_ENDFILE)
        return RS274NGC_ENDFILE;
      if (status ISNT RS274NGC_OK)
        {
          printf("rs274ngc_read failed.\n");
          return -1;
#if 0
        /* should not be RS274NGC_EXIT or RS274NGC_ERROR */
          // fprintf(stderr, "%s\n", _interpreter_linetext);
          if (no_stop IS OFF)
            return RS274NGC_ERROR;
          else
            {
              program_status SET_TO RS274NGC_ERROR;
              rs274ngc_open(filename);       /* will have been closed    */
              for(k SET_TO -1; k < reads; k++) /* read up to where we were */
                {
                  // read_ok SET_TO
                  // fgets(trash, INTERP_TEXT_SIZE, _interpreter_fp);
                  if (read_ok IS NULL)
                    return RS274NGC_ERROR;
                }
              continue;
            }
#endif
        }
      status SET_TO rs274ngc_execute(NULL);
      if (status ISNT RS274NGC_OK)
        {
          printf("rs274ngc_execute failed.\n");
          return -1;
#if 0
          //fprintf(stderr, "%s\n", _interpreter_linetext);
          if (no_stop IS OFF)
            return RS274NGC_ERROR;
          else
            {
              program_status SET_TO RS274NGC_ERROR;
              rs274ngc_open(filename); /* will have been closed */
              for(k SET_TO -1; k < reads; k++) /* read up to where we were */
                {
                  // read_ok SET_TO
                  //  fgets(trash, INTERP_TEXT_SIZE, _interpreter_fp);
                  if (read_ok IS NULL)
                    return RS274NGC_ERROR;
                }
              continue;
            }
#endif
        }
      else if (status IS RS274NGC_EXIT)
        return program_status;
    }
}

#define VECTOR_MAG(x,y,z) (sqrt( (x)*(x) + (y)*(y) + (z)*(z)))

double last_x,last_y, last_z;

void DoCircularMove(EMC_TRAJ_CIRCULAR_MOVE *cir_move_cmd)
{
  int simple = 0;
  int axis = 0;
#if 0
  printf("DoCircularMove :\n");
  printf(" \t end = %f %f %f\n", cir_move_cmd->end.tran.x,
         cir_move_cmd->end.tran.y,cir_move_cmd->end.tran.z);
  printf(" \t normal = %f %f %f\n", cir_move_cmd->normal.x,
         cir_move_cmd->normal.y,cir_move_cmd->normal.z);
  printf(" \t center = %f %f %f\n", cir_move_cmd->center.x,
         cir_move_cmd->center.y,cir_move_cmd->center.z);
  printf(" \t turn = %d\n",cir_move_cmd->turn);
  printf(" \t last = %f %f %f\n", last_x, last_y, last_z);
#endif
  double axis_diff;
  if(cir_move_cmd->normal.x == 0 && cir_move_cmd->normal.y == 0)
    {
      axis_diff = cir_move_cmd->end.tran.z/emcStatus->motion.traj.linearUnits*scale - last_z;
      simple = 1;
      axis = 2;
    }
  else if(cir_move_cmd->normal.x == 0 && cir_move_cmd->normal.z == 0)
    {
      axis_diff = cir_move_cmd->end.tran.y/emcStatus->motion.traj.linearUnits*scale - last_y;
      simple = 1;
      axis = 1;
    }
  else if(cir_move_cmd->normal.y == 0 && cir_move_cmd->normal.z == 0)
    {
      axis_diff = cir_move_cmd->end.tran.x/emcStatus->motion.traj.linearUnits*scale - last_x;
      simple = 1;
      axis = 0;
    }
  if(simple)
    {
      double r = VECTOR_MAG(cir_move_cmd->end.tran.x - cir_move_cmd->center.x,
                            cir_move_cmd->end.tran.y - cir_move_cmd->center.y,
                            cir_move_cmd->end.tran.z - cir_move_cmd->center.z)/emcStatus->motion.traj.linearUnits*scale;
      double start_angle, sweep_angle;
      switch(axis)
        {
        case 0:
          start_angle = atan2( last_z/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.z,
                               last_y/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.y);
          sweep_angle = atan2( cir_move_cmd->end.tran.z-cir_move_cmd->center.z,
                               cir_move_cmd->end.tran.y-cir_move_cmd->center.y);
          break;

        case 1:
          start_angle = atan2( last_z/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.z,
                               last_x/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.x  );
          sweep_angle = atan2( cir_move_cmd->end.tran.z-cir_move_cmd->center.z,
                               cir_move_cmd->end.tran.x-cir_move_cmd->center.x);
          break;

        case 2:
          start_angle = atan2( last_y/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.y,
                               last_x/emcStatus->motion.traj.linearUnits*scale-cir_move_cmd->center.x);
          sweep_angle = atan2( cir_move_cmd->end.tran.y-cir_move_cmd->center.y,
                             cir_move_cmd->end.tran.x-cir_move_cmd->center.x);
          break;
        }
      double angle_increment = 0.01;
      double angle = start_angle;
      double angle_diff = fabs(angle - sweep_angle);
      angle_increment = (cir_move_cmd->turn < 0)?-0.01:+0.01;
      double axis_increment = fabs(angle_increment/angle_diff)*axis_diff;
      int i = 0;
      double x,y,z;
      x = last_x;
      y = last_y;
      z = last_z;
      for(;  i <  3 || angle_diff > 1.5*fabs(angle_increment); angle += angle_increment)
      {
        i++;
        //printf("angle_diff = %f\n",angle_diff);
        angle_diff = fabs(angle - sweep_angle);
        if(angle_diff > 2*PM_PI)
        {
          angle_diff -= 2*PM_PI;
        }
        switch(axis)
          {
          case 0:
            x += axis_increment;
            y = cir_move_cmd->center.y/emcStatus->motion.traj.linearUnits*scale + cos(angle)*r;
            z = cir_move_cmd->center.z/emcStatus->motion.traj.linearUnits*scale + sin(angle)*r;
            break;

          case 1:
            y += axis_increment;
            x = cir_move_cmd->center.x/emcStatus->motion.traj.linearUnits*scale + cos(angle)*r;
            z = cir_move_cmd->center.z/emcStatus->motion.traj.linearUnits*scale + sin(angle)*r;
            break;

          case 2:
            z += axis_increment;
            x = cir_move_cmd->center.x/emcStatus->motion.traj.linearUnits*scale + cos(angle)*r;
            y = cir_move_cmd->center.y/emcStatus->motion.traj.linearUnits*scale + sin(angle)*r;
            break;
          }
        //printf("angle=%f, vertex = %f %f %f\n",angle,x,y,z);
        glVertex3f(x,y,z);
      }
    }
  else
    {
      printf("Circular moves not aligned with an axis are not supported.\n");
    }
  glVertex3f(last_x = cir_move_cmd->end.tran.x/emcStatus->motion.traj.linearUnits*scale,
             last_y = cir_move_cmd->end.tran.y/emcStatus->motion.traj.linearUnits*scale,
             last_z = cir_move_cmd->end.tran.z/emcStatus->motion.traj.linearUnits*scale);
}


GLvoid RebuildLivePlot()
{
  GLuint lplot_temp;
  GLuint lplot_rotframes_temp;
  lplot_temp = lplot;
  lplot_rotframes_temp=lplot_rotframes_temp;
  lplot=0;
  lplot_rotframes=0;
  if(0 != lplot_temp)
    {
      glDeleteLists(lplot_temp,1);
      lplot_temp = 0;
    }
  if(0 != lplot_rotframes_temp)
    {
      glDeleteLists(lplot_rotframes_temp,1);
      lplot_rotframes_temp = 0;
    }
  lplot_temp = glGenLists(1);
  glNewList(lplot_temp, GL_COMPILE);

  glColor3f(0.0,0.0,1.0);
  glBegin(GL_LINE_STRIP);


  EmcPose *emcPose = (EmcPose *) livePlotList->get_head();
  while(NULL != emcPose)
    {
      glVertex3f(emcPose->tran.x/emcStatus->motion.traj.linearUnits*scale,
                 emcPose->tran.y/emcStatus->motion.traj.linearUnits*scale,
                 emcPose->tran.z/emcStatus->motion.traj.linearUnits*scale);
      emcPose = (EmcPose *) livePlotList->get_next();
    }
  glEnd();
  glEndList();


  lplot_rotframes_temp = glGenLists(1); 
  // generate storage for 1 lists, and return a pointer to the first.

  glNewList(lplot_rotframes_temp, GL_COMPILE);

  EmcPose last_p;
  EmcPose *p = (EmcPose *) livePlotList->get_head();
  while(p != NULL)
    {
      if(
         fabs(last_p.tran.x - p->tran.x) >= 0.01*emcStatus->motion.traj.linearUnits/scale ||
         fabs(last_p.tran.y - p->tran.y) >= 0.01*emcStatus->motion.traj.linearUnits/scale ||
         fabs(last_p.tran.z - p->tran.z) >= 0.01*emcStatus->motion.traj.linearUnits/scale ||
         fabs(last_p.a - p->a) >= 0.1 ||
         fabs(last_p.b - p->b) >= 0.1 ||
         fabs(last_p.c - p->c) >= 0.1 )
        {
          PM_RPY rpy(p->a*PM_PI/180.0,p->b*PM_PI/180.0,p->c*PM_PI/180.0);
          PM_ROTATION_VECTOR rv(rpy);
          glTranslatef(p->tran.x/emcStatus->motion.traj.linearUnits*scale,
                       p->tran.y/emcStatus->motion.traj.linearUnits*scale,
                       p->tran.z/emcStatus->motion.traj.linearUnits*scale);
          glRotatef(rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);
          
          // Axis Lines.
          glBegin(GL_LINES);
          glColor3f(0.4f,1.0f,0.4f);
          glVertex3f(0.6f,0.0f,0.0f);
          glVertex3f(0.0,0.0,0.0f);
          glColor3f(1.0f,0.4f,0.4f);
          glVertex3f(0.0,0.0,0.0);
          glVertex3f(0.0,0.6,0.0);
          glColor3f(0.4f,0.4f,1.0f);
          glVertex3f(0.0,0.0,0.0);
          glVertex3f(0.0,0.0,0.6);
          glEnd();

          glRotatef(-rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);
          glTranslatef(-p->tran.x/emcStatus->motion.traj.linearUnits*scale,
                   -p->tran.y/emcStatus->motion.traj.linearUnits*scale,
                   -p->tran.z/emcStatus->motion.traj.linearUnits*scale);
          last_p = *p;
        }
      p = (EmcPose *) livePlotList->get_next();
    }
  glEndList();

  lplot = lplot_temp;
  lplot_rotframes=lplot_rotframes_temp;
}


GLvoid BuildDataPlot()
{

  FILE *f=stdin;

  if(Filename != NULL)
    {
      if(Filename[0] != 0)
        {
          f = fopen(Filename,"r");
        }
    }
  char buf[256];

  if(NULL != staticPlotList)
    {
      delete staticPlotList;
      staticPlotList = NULL;
    }
  staticPlotList = new RCS_LINKED_LIST();

  while(!feof(f))
    {
      fgets(buf,256,f);
      double x,y,z,a,b,c;
      x = y = z = a = b = c = 0.0;
      if(sscanf(buf,"%lf %lf %lf %lf %lf %lf", &x,&y,&z,&a,&b,&c) < 3)
        {
          break;
        }
      EmcPose pose;
      pose.tran.x = x;
      pose.tran.y = y;
      pose.tran.z = z;
      pose.a = a;
      pose.b = b;
      pose.c = c;
      staticPlotList->store_at_tail(&pose,sizeof(EmcPose),1);
    }
  if(f != stdin)
    {
      fclose(f);
    }

  plot_rotframes = glGenLists(1);              // generate storage for 2 lists, and return a pointer to the first.

  glNewList(plot_rotframes, GL_COMPILE);

  EmcPose *p = (EmcPose *) staticPlotList->get_head();
  while(p != NULL)
    {
      PM_RPY rpy(p->a*PM_PI/180.0,p->b*PM_PI/180.0,p->c*PM_PI/180.0);
      PM_ROTATION_VECTOR rv(rpy);
      glTranslatef(p->tran.x/emcStatus->motion.traj.linearUnits*scale,
                   p->tran.y/emcStatus->motion.traj.linearUnits*scale,
                   p->tran.z/emcStatus->motion.traj.linearUnits*scale);
      glRotatef(rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);

      // Axis Lines.
      glBegin(GL_LINES);
      glColor3f(0.2f,1.0f,0.2f);
      glVertex3f(0.5f,0.0f,0.0f);
      glVertex3f(0.0,0.0,0.0f);
      glColor3f(1.0f,0.2f,0.2f);
      glVertex3f(0.0,0.0,0.0);
      glVertex3f(0.0,0.5,0.0);
      glColor3f(0.2f,0.2f,1.0f);
      glVertex3f(0.0,0.0,0.0);
      glVertex3f(0.0,0.0,0.5);
      glEnd();

      glRotatef(-rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);
      glTranslatef(-p->tran.x/emcStatus->motion.traj.linearUnits*scale,
                   -p->tran.y/emcStatus->motion.traj.linearUnits*scale,
                   -p->tran.z/emcStatus->motion.traj.linearUnits*scale);
      p = (EmcPose *) staticPlotList->get_next();
    }
  glEndList();

  plot = glGenLists(1);    
  // generate storage for 2 lists, and return a pointer to the first.

  glNewList(plot, GL_COMPILE);

  glColor3f(1.0,1.0,1.0f);
  glBegin(GL_LINE_STRIP);

  p = (EmcPose *) staticPlotList->get_head();
  while(p != NULL)
    {
      glVertex3f(p->tran.x/emcStatus->motion.traj.linearUnits*scale,
                 p->tran.y/emcStatus->motion.traj.linearUnits*scale,
                 p->tran.z/emcStatus->motion.traj.linearUnits*scale);
      p = (EmcPose *) staticPlotList->get_next();
    }
  glEnd();
  glEndList();
}




// build the display list.
GLvoid BuildList()
{
  NMLmsg *cmd;
  //  GLUquadric* quad = gluNewQuadric();

   if(NULL == Filename)
     {
       BuildDataPlot();
       return;
     }

   if(NULL != strstr(Filename,".data"))
   {
     BuildDataPlot();
     return;
   }

  
  if(NULL != Filename)
    {
      if(!strncmp(Filename, "NULL",4) || 
         !strncmp(Filename,"null",4))
        {
          Filename = NULL;
          return;
        }
    }

  if(NULL == Filename)
    {
      return;
    }

   plot = glGenLists(1);              // generate storage for 2 lists, and return a pointer to the first.

   interpret_from_file(Filename, 1);

   glNewList(plot, GL_COMPILE);       // store this list at location cube, and compile it once.

    last_x=0.0;
    last_y=0.0;
    last_z=0.0;

    glColor3f(1.0f,1.0f,1.0f);
    glBegin(GL_LINE_STRIP);
    while( (cmd = interp_list.get()) > 0)
      {
        printf("%d : %s : (%s)\n",interp_list.get_line_number(),
               emcSymbolLookup(cmd->type),(emcCommandBuffer!=0?emcCommandBuffer->msg2str(cmd):" ")); 
        switch(cmd->type)
          {
          case EMC_TRAJ_LINEAR_MOVE_TYPE:
            {
              EMC_TRAJ_LINEAR_MOVE *lin_move_cmd = (EMC_TRAJ_LINEAR_MOVE *) cmd;
              glVertex3f(last_x = lin_move_cmd->end.tran.x/emcStatus->motion.traj.linearUnits*scale,
                         last_y = lin_move_cmd->end.tran.y/emcStatus->motion.traj.linearUnits*scale,
                         last_z = lin_move_cmd->end.tran.z/emcStatus->motion.traj.linearUnits*scale);
            }
            break;

          case EMC_TRAJ_CIRCULAR_MOVE_TYPE:
            {
              EMC_TRAJ_CIRCULAR_MOVE *cir_move_cmd = (EMC_TRAJ_CIRCULAR_MOVE *) cmd;
              DoCircularMove(cir_move_cmd);
            }
            break;

          case EMC_TRAJ_SET_VELOCITY_TYPE:
          case EMC_TRAJ_SET_ACCELERATION_TYPE:
            break;


          default:
            //printf("Unrecognized cmd->type = %d\n",cmd->type);
            break;
          }
      }
    glEnd();
    glEndList();


    
    interpret_from_file(Filename, 1);

   plot_rotframes = glGenLists(1);
   
   glNewList(plot_rotframes, GL_COMPILE);       // store this list at location cube, and compile it once.

    last_x=0.0;
    last_y=0.0;
    last_z=0.0;

    
    while( (cmd = interp_list.get()) > 0)
      {
        printf("%d : %s : (%s)\n",interp_list.get_line_number(),
               emcSymbolLookup(cmd->type),(emcCommandBuffer!=0?emcCommandBuffer->msg2str(cmd):" ")); 
        switch(cmd->type)
          {
          case EMC_TRAJ_LINEAR_MOVE_TYPE:
            {
              EMC_TRAJ_LINEAR_MOVE *lin_move_cmd = (EMC_TRAJ_LINEAR_MOVE *) cmd;
              PM_RPY rpy(lin_move_cmd->end.a*PM_PI/180.0,lin_move_cmd->end.b*PM_PI/180.0,lin_move_cmd->end.c*PM_PI/180.0);
              PM_ROTATION_VECTOR rv(rpy);
              glTranslatef(lin_move_cmd->end.tran.x/emcStatus->motion.traj.linearUnits*scale,
                           lin_move_cmd->end.tran.y/emcStatus->motion.traj.linearUnits*scale,
                           lin_move_cmd->end.tran.z/emcStatus->motion.traj.linearUnits*scale);
              glRotatef(rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);
                  
              // Axis Lines.
              glBegin(GL_LINES);
              glColor3f(0.2f,1.0f,0.2f);
              glVertex3f(0.5f,0.0f,0.0f);
              glVertex3f(0.0,0.0,0.0f);
              glColor3f(1.0f,0.2f,0.2f);
              glVertex3f(0.0,0.0,0.0);
              glVertex3f(0.0,0.5,0.0);
              glColor3f(0.2f,0.2f,1.0f);
              glVertex3f(0.0,0.0,0.0);
              glVertex3f(0.0,0.0,0.5);
              glEnd();
                  
              glRotatef(-rv.s*180.0/PM_PI,rv.x,rv.y,rv.z);
              glTranslatef(-lin_move_cmd->end.tran.x/emcStatus->motion.traj.linearUnits*scale,
                           -lin_move_cmd->end.tran.y/emcStatus->motion.traj.linearUnits*scale,
                           -lin_move_cmd->end.tran.z/emcStatus->motion.traj.linearUnits*scale);
            }
            break;


          case EMC_TRAJ_SET_VELOCITY_TYPE:
          case EMC_TRAJ_SET_ACCELERATION_TYPE:
            break;


          default:
            //printf("Unrecognized cmd->type = %d\n",cmd->type);
            break;
          }
      }
    glEnd();
    glEndList();
}

#if 0


// quick and dirty bitmap loader...for 24 bit bitmaps with 1 plane only.
// See http://www.dcs.ed.ac.uk/~mxr/gfx/2d/BMP.txt for more info.
int ImageLoad(char *filename, Image *image) {
    FILE *file;
    unsigned long size;                 // size of the image in bytes.
    unsigned long i;                    // standard counter.
    unsigned short int planes;          // number of planes in image (must be 1)
    unsigned short int bpp;             // number of bits per pixel (must be 24)
    char temp;                          // temporary color storage for bgr-rgb conversion.

    // make sure the file is there.
    if ((file = fopen(filename, "rb"))==NULL)
    {
        printf("File Not Found : %s\n",filename);
        return 0;
    }

    // seek through the bmp header, up to the width/height:
    fseek(file, 18, SEEK_CUR);

    // read the width
    if ((i = fread(&image->sizeX, 4, 1, file)) != 1) {
        printf("Error reading width from %s.\n", filename);
        return 0;
    }
    printf("Width of %s: %lu\n", filename, image->sizeX);

    // read the height
    if ((i = fread(&image->sizeY, 4, 1, file)) != 1) {
        printf("Error reading height from %s.\n", filename);
        return 0;
    }
    printf("Height of %s: %lu\n", filename, image->sizeY);

    // calculate the size (assuming 24 bits or 3 bytes per pixel).
    size = image->sizeX * image->sizeY * 3;

    // read the planes
    if ((fread(&planes, 2, 1, file)) != 1) {
        printf("Error reading planes from %s.\n", filename);
        return 0;
    }
    if (planes != 1) {
        printf("Planes from %s is not 1: %u\n", filename, planes);
        return 0;
    }

    // read the bpp
    if ((i = fread(&bpp, 2, 1, file)) != 1) {
        printf("Error reading bpp from %s.\n", filename);
        return 0;
    }
    if (bpp != 24) {
        printf("Bpp from %s is not 24: %u\n", filename, bpp);
        return 0;
    }

    // seek past the rest of the bitmap header.
    fseek(file, 24, SEEK_CUR);

    // read the data.
    image->data = (char *) malloc(size);
    if (image->data == NULL) {
        printf("Error allocating memory for color-corrected image data");
        return 0;
    }

    if ((i = fread(image->data, size, 1, file)) != 1) {
        printf("Error reading image data from %s.\n", filename);
        return 0;
    }

    for (i=0;i<size;i+=3) { // reverse all of the colors. (bgr -> rgb)
        temp = image->data[i];
        image->data[i] = image->data[i+2];
        image->data[i+2] = temp;
    }

    // we're done.
    return 1;
}

// Load Bitmaps And Convert To Textures
void LoadGLTextures() {
    // Load Texture
    Image *image1;

    // allocate space for texture
    image1 = (Image *) malloc(sizeof(Image));
    if (image1 == NULL) {
        printf("Error allocating space for image");
        exit(0);
    }

    if (!ImageLoad("Data/lesson12/cube.bmp", image1)) {
        exit(1);
    }

    // Create Texture
    glGenTextures(1, &texture[0]);
    glBindTexture(GL_TEXTURE_2D, texture[0]);   // 2d texture (x and y size)

    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // scale linearly when image bigger than texture
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST); // scale linearly (use mipmaps) when image smaller than texture

    // 2d texture, 3 components (red, green, blue), x size from image, y size from image,
    // rgb color data, unsigned byte data, and finally the data itself.
    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image1->sizeX, image1->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image1->data);
};
#endif

GLUquadric *quad = 0;

/* A general OpenGL initialization function.  Sets all of the initial parameters. */
void InitGL(int Width, int Height)
{
  PM_RPY rpy_zero(-PM_PI/4.0,-PM_PI/4.0,-PM_PI/4.0);
  PM_ROTATION_VECTOR rv_zero(rpy_zero);
  view_rv = rv_zero;
#if 0
    LoadGLTextures();                           // Load The Texture(s)
#endif
    quad = gluNewQuadric();
    BuildList();                                // set up our display lists.
    glEnable(GL_TEXTURE_2D);                    // Enable Texture Mapping

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);       // Clear The Background Color To Blue
    glClearDepth(1.0);                          // Enables Clearing Of The Depth Buffer
    glDepthFunc(GL_LESS);                       // The Type Of Depth Test To Do
    glEnable(GL_DEPTH_TEST);                    // Enables Depth Testing
    glShadeModel(GL_SMOOTH);                    // Enables Smooth Color Shading

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();                           // Reset The Projection Matrix

    gluPerspective(30.0f,(GLfloat)Width/(GLfloat)Height,0.1f,1000.0f);  // Calculate The Aspect Ratio Of The Window

    glMatrixMode(GL_MODELVIEW);

    //glEnable(GL_LIGHT0);
    //glEnable(GL_LIGHTING);
    glEnable(GL_COLOR_MATERIAL);
    BuildFont();
}

/* The function called when our window is resized (which shouldn't happen, because we're fullscreen) */
void ReSizeGLScene(int Width, int Height)
{
    if (Height==0)                              // Prevent A Divide By Zero If The Window Is Too Small
        Height=1;

    glViewport(0, 0, Width, Height);            // Reset The Current Viewport And Perspective Transformation

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    gluPerspective(30.0f,(GLfloat)Width/(GLfloat)Height,0.1f,1000.0f);
    glMatrixMode(GL_MODELVIEW);
}

/* The main drawing function. */
void DrawGLScene()
{
  if(!redraw_needed)
    {
      return;
    }
  redraw_needed=0;


    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         // Clear The Screen And The Depth Buffer

    //    glBindTexture(GL_TEXTURE_2D, texture[0]);
    //printf(" %f %f %f  %f %f %f\n", xtran, ytran, ztran,xrot,yrot,zrot);

    glLoadIdentity();

    char buf[256];
    glTranslatef(0.0,0.0,-30.0);
    PM_QUATERNION view_quat(view_rv);
    PM_RPY view_rpy(view_quat);
  // Position The Text On The Screen
    glColor3f(1.0,0.0,0.0);
    glRasterPos2f(-7.0,7.0);
    sprintf(buf,"View Offset -- (X=%2.2f,Y=%2.2f,Z=%2.2f, Roll=%2.2f, Pitch=%2.2f, Yaw=%2.2f)",
            xtran,ytran,ztran-30,view_rpy.r*180.0/PM_PI,view_rpy.p*180.0/PM_PI,view_rpy.y*180.0/PM_PI);
    glPrint(buf);
    glRasterPos2f(-7.0,6.5);
    sprintf(buf,"EMC Position -- (X=%2.2f,Y=%2.2f,Z=%2.2f, A=%2.2f, B=%2.2f, C=%2.2f)",
            last_pose.tran.x,last_pose.tran.y,last_pose.tran.z,
            last_pose.a, last_pose.b, last_pose.c);
    glPrint(buf);
    if(NULL != Filename)
      {
        glRasterPos2f(-7.0,6.0);
        sprintf(buf,"Program File: %s",Filename);
        glPrint(buf);
      }

    PM_RPY rpy(xrot*PM_PI/180.0, yrot*PM_PI/180.0, zrot*PM_PI/180);
    PM_ROTATION_VECTOR rv(rpy);
    glTranslatef(xtran,ytran,ztran);

    //glRotatef(zrot,0.0,0.0,1.0);
    //glRotatef(yrot,0.0,1.0,0.0);
    //glRotatef(xrot,1.0,0.0,0.0);

#if 0
        glBegin(GL_LINES);
        glColor3f(1.0,0.0,1.0);
        glVertex3f(0.0,0.0,0.0);
        glVertex3f(2*rv.x,2*rv.y,2*rv.z);
        glEnd();
        glColor3f(0.0,1.0,1.0);
        gluCylinder(quad, 0.01f, rv.s, 1.1f,100, 10);
#endif


        glRotatef(view_rv.s*180/PM_PI,view_rv.x,view_rv.y,view_rv.z);

    // Axis Lines.
    glBegin(GL_LINES);
    glColor3f(0.2f,1.0f,0.2f);
    glVertex3f(10.0f,0.0f,0.0f);
    glVertex3f(0.0,0.0,0.0f);
    glColor3f(1.0f,0.2f,0.2f);
    glVertex3f(0.0,0.0,0.0);
    glVertex3f(0.0,10.0,0.0);
    glColor3f(0.2f,0.2f,1.0f);
    glVertex3f(0.0,0.0,0.0);
    glVertex3f(0.0,0.0,10.0);
    glEnd();


    //glColor3fv(boxcol[yloop-1]);
    if(lplot != 0 && showLivePlot)
      {
        glCallList(lplot);
        if(show_plot_rotation_frames&2)
          {
            glCallList(lplot_rotframes);
          }
      }
    if(showProgrammedPlot && plot)
      {
        glCallList(plot);
        if(show_plot_rotation_frames&1)
          {
            glCallList(plot_rotframes);
          }
      }


    PM_RPY rpy2(last_pose.a*PM_PI/180.0,last_pose.b*PM_PI/180.0,last_pose.c*PM_PI/180.0);
    PM_ROTATION_VECTOR rv2(rpy2);
    glTranslatef(last_pose.tran.x/emcStatus->motion.traj.linearUnits*scale,
                 last_pose.tran.y/emcStatus->motion.traj.linearUnits*scale,
                 last_pose.tran.z/emcStatus->motion.traj.linearUnits*scale);
    glRotatef(rv2.s*180.0/PM_PI,rv2.x,rv2.y,rv2.z);

    if(1)
    {
      // Axis Lines.
      glBegin(GL_LINES);
      glColor3f(0.4f,1.0f,0.4f);
      glVertex3f(0.6f,0.0f,0.0f);
      glVertex3f(0.0,0.0,0.0f);
      glColor3f(1.0f,0.4f,0.4f);
      glVertex3f(0.0,0.0,0.0);
      glVertex3f(0.0,0.6,0.0);
      glColor3f(0.4f,0.4f,1.0f);
      glVertex3f(0.0,0.0,0.0);
      glVertex3f(0.0,0.0,0.6);
      glEnd();
      
      glColor3f(0.5,0.5,0.5);
      gluCylinder(quad, 
                  0.01f,
                  0.05f, 
                  1.1,
                  100, 
                  10);
    }
    glRotatef(-rv2.s*180.0/PM_PI,rv2.x,rv2.y,rv2.z);
    glTranslatef(-last_pose.tran.x/emcStatus->motion.traj.linearUnits*scale,
                 -last_pose.tran.y/emcStatus->motion.traj.linearUnits*scale,
                 -last_pose.tran.z/emcStatus->motion.traj.linearUnits*scale);

    if(show_stewart_platform)
      {
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glColor4f(1.0,0.0,0.0,0.75);
        glBegin(GL_POLYGON);
        for(int i = 0; i < 6; i++)
          {
            glVertex3f(stewart_platform_specs.plate_points[i].x,
                       stewart_platform_specs.plate_points[i].y,
                       1.0);
          }
        glEnd();
        glDisable(GL_BLEND);
        glTranslatef(-last_pose.tran.x,-last_pose.tran.y,-last_pose.tran.z);
        glColor4f(0.0,1.0,1.0,1.0);
        glBegin(GL_LINES);
        for(int i = 0; i < 6; i++)
          {
            glVertex3f(stewart_platform_specs.plate_points[i].x+last_pose.tran.x,
                       stewart_platform_specs.plate_points[i].y+last_pose.tran.y,
                       1.0+last_pose.tran.z);
            glVertex3f(stewart_platform_specs.mount_points[i].x,
                       stewart_platform_specs.mount_points[i].y,
                       10.0);
          }
        glEnd();
      }

 // since this is double buffered, swap the buffers to display what just got drawn.
    glutSwapBuffers();
}

/* The function called whenever a key is pressed. */
void keyPressed(unsigned char key, int x, int y)
{
    /* If escape is pressed, kill everything. */
    if (key == ESCAPE)
    {
        /* shut down our window */
        glutDestroyWindow(window);

      /* exit the program...normal termination. */
        exit(0);
    }
    else if(key == ' ')
      {
        PM_RPY rpytemp(-PM_PI/4.0,-PM_PI/4.0,-PM_PI/4.0);
        PM_ROTATION_VECTOR rvtemp(rpytemp);
        view_rv = rvtemp;
        xtran = 0.0;
        ytran = 0.0;
        ztran = 0.0;
        xrot = -45.0;
        yrot = -45.0;
        zrot = -45.0;
      }
    else if(key == 'x' || key == 'X')
      {
        PM_RPY rpytemp(-PM_PI/2.0,-PM_PI/2.0,0.0);
        PM_ROTATION_VECTOR rvtemp(rpytemp);
        view_rv = rvtemp;
      }
    else if(key == 'y' || key == 'Y')
      {
        PM_RPY rpytemp(-PM_PI/2.0,0.0,0.0);
        PM_ROTATION_VECTOR rvtemp(rpytemp);
        view_rv = rvtemp;
      }
    else if(key == 'z' || key == 'Z')
      {
        PM_RPY rpytemp(0.0,0.0,0.0);
        PM_ROTATION_VECTOR rvtemp(rpytemp);
        view_rv = rvtemp;
      }
    else if(key == 'k' || key == 'K')
      {
        PM_RPY rpytemp(-PM_PI/4.0,-PM_PI/4.0,-PM_PI/4.0);
        PM_ROTATION_VECTOR rvtemp(rpytemp);
        view_rv = rvtemp;
      }
    else if(key == 'c' || key == 'C')
      {
        if(NULL != livePlotList)
          {
            delete livePlotList;
            livePlotList = new RCS_LINKED_LIST;
          }
        RebuildLivePlot();
      }
    else if(key == 'p' || key == 'P')
      {
        showProgrammedPlot = !showProgrammedPlot;
      }
    else if(key == 's' || key == 'S')
      {
        show_stewart_platform = !show_stewart_platform;
      }
    else if(key == 'r' || key == 'R')
      {
        show_plot_rotation_frames++;
        show_plot_rotation_frames %=4;
      }
    else if(key == 'l' || key == 'L')
      {
        showLivePlot = !showLivePlot;
      }
    redraw_needed=1;
    glutPostRedisplay();
}

/* The function called whenever a normal key is pressed. */
void specialKeyPressed(int key, int x, int y)
{
  int modifiers;

  modifiers = glutGetModifiers();
  if(modifiers & GLUT_ACTIVE_SHIFT)
    {
      PM_QUATERNION view_quat(view_rv);
      switch (key) {
      case GLUT_KEY_UP:
        {
          PM_ROTATION_VECTOR rv_up(2.0*PM_PI/180,0.0,1.0,0.0);
          PM_QUATERNION quat_up(rv_up);
          view_rv = view_quat *quat_up;
        }
        break;

      case GLUT_KEY_DOWN:
        {
          PM_ROTATION_VECTOR rv_down(-2.0*PM_PI/180,0.0,1.0,0.0);
          PM_QUATERNION quat_down(rv_down);
          view_rv = view_quat *quat_down;
        }
        break;

      case GLUT_KEY_LEFT:
        {
          PM_ROTATION_VECTOR rv_left(-2.0*PM_PI/180,1.0,0.0,0.0);
          PM_QUATERNION quat_left(rv_left);
          view_rv = view_quat *quat_left;
        }
        break;

      case GLUT_KEY_RIGHT:
        {
          PM_ROTATION_VECTOR rv_right(2.0*PM_PI/180,1.0,0.0,0.0);
          PM_QUATERNION quat_right(rv_right);
          view_rv = view_quat *quat_right;
        }
        break;

      case GLUT_KEY_PAGE_UP:
        {
          PM_ROTATION_VECTOR rv_zup(2.0*PM_PI/180,0.0,0.0,1.0);
          PM_QUATERNION quat_zup(rv_zup);
          view_rv = view_quat *quat_zup;
        }
        break;

      case GLUT_KEY_PAGE_DOWN:
        {
          PM_ROTATION_VECTOR rv_zdown(-2.0*PM_PI/180,0.0,0.0,1.0);
          PM_QUATERNION quat_zdown(rv_zdown);
          view_rv = view_quat *quat_zdown;
        }
        break;

      default:
        printf ("Special key %d pressed. No action there yet.\n", key);
        break;
      }
      /*  printf("view_rv : %f %f %f %f\n",
          view_rv.s, view_rv.x, view_rv.y,view_rv.z); */
   }
  else
    {
      switch (key) {
      case GLUT_KEY_UP:
        ytran += 0.2f;
        break;

      case GLUT_KEY_DOWN:
        ytran -= 0.2f;
        break;

      case GLUT_KEY_LEFT:
        xtran -= 0.2f;
        break;

      case GLUT_KEY_RIGHT:
        xtran += 0.2f;
        break;

      case GLUT_KEY_PAGE_UP:
        ztran -= 0.2f;
        break;

      case GLUT_KEY_PAGE_DOWN:
        ztran += 0.2f;
        break;

      default:
        printf ("Special key %d pressed. No action there yet.\n", key);
        break;
      }
    }
  redraw_needed=1;
  glutPostRedisplay();
}

static int wait_count = 0;

/* Draw timer */
void RedisplayTimerFunc(int val)
{
  if(val == 1)
    {
      if(0 != emcStatusBuffer && 0 != livePlotList)
        {
          if(emcStatusBuffer->peek() == EMC_STAT_TYPE)
            {
              emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
              if(last_pose.tran.x != emcStatus->motion.traj.actualPosition.tran.x ||
                 last_pose.tran.y != emcStatus->motion.traj.actualPosition.tran.y ||
                 last_pose.tran.z != emcStatus->motion.traj.actualPosition.tran.z ||
                  
                 last_pose.a != emcStatus->motion.traj.actualPosition.a ||                  
                 last_pose.b != emcStatus->motion.traj.actualPosition.b ||                  
                 last_pose.c != emcStatus->motion.traj.actualPosition.c  
                 )
                {


                  livePlotList->store_at_tail(&(emcStatus->motion.traj.actualPosition),

                                              sizeof(EmcPose),1);
                  timer_count++;
                  wait_count = 0;
                  if(timer_count%refresh_count == 0)
                    {
                      RebuildLivePlot();
                      redraw_needed=1;
                      glutPostRedisplay();
                      wait_count = 0;
                    }
                  last_pose = emcStatus->motion.traj.actualPosition;
                }
              else
                {
                  wait_count++;
                  if(wait_count > 2*refresh_count)
                    {
                      if(timer_count > 0)
                        {
                          RebuildLivePlot();
                        }
                      redraw_needed=1;
                      glutPostRedisplay();
                      timer_count = 0;
                      wait_count = 0;
                    }
                }
            }
          else
            {
              wait_count++;
              if(wait_count > 2*refresh_count)
                {
                  if(timer_count > 0)
                    {
                      RebuildLivePlot();
                    }
                  redraw_needed=1;
                  glutPostRedisplay();
                  timer_count = 0;
                  wait_count = 0;
                }
            }
          glutTimerFunc(50,&RedisplayTimerFunc,1);
        }
    }
}



static int iniLoad(const char *filename)
{
  INIFILE inifile;
  const char *inistring;
  char version[INIFILE_MAX_LINELEN];
  int saveInt;
  double saveDouble;

  // open it
  if (-1 == inifile.open(filename)) {
    return -1;
  }

  if (NULL != (inistring = inifile.find("DEBUG", "EMC"))) {
    // copy to global
    if (1 != sscanf(inistring, "%i", &EMC_DEBUG)) {
      EMC_DEBUG = 0;
    }
  }
  else {
    // not found, use default
    EMC_DEBUG = 0;
  }

  if (EMC_DEBUG & EMC_DEBUG_VERSIONS) {
    if (NULL != (inistring = inifile.find("VERSION", "EMC"))) {
      // print version
      sscanf(inistring, "$Revision: %s", version);
      rcs_print("Version:  %s\n", version);
    }
    else {
      // not found, not fatal
      rcs_print("Version:  (not found)\n");
    }

    if (NULL != (inistring = inifile.find("MACHINE", "EMC"))) {
      // print machine
      rcs_print("Machine:  %s\n", inistring);
    }
    else {
      // not found, not fatal
      rcs_print("Machine:  (not found)\n");
    }
  }

  if (NULL != (inistring = inifile.find("NML_FILE", "EMC"))) {
    // copy to global
    strcpy(EMC_NMLFILE, inistring);
  }
  else {
    // not found, use default
  }


  // close it
  inifile.close();

  return 0;
}




int main(int argc, char **argv)
{


  // process command line args
  emcGetArgs(argc, argv);

  // initialize globals
  emcInitGlobals();

  // get configuration information
  iniLoad(EMC_INIFILE);
  
  // load rs274ngc parameters.
  rs274ngc_ini_load(EMC_INIFILE);

  emcStatusBuffer
    = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "xemc", EMC_NMLFILE);
  if (! emcStatusBuffer->valid())
    {
      printf("emcStatusBuffer NOT valid.\n");
      printf("\n -- \tYou can ignore any errors above this line \n"
             "\t if all you want to do is view a tool path from \n"
             "\t an rs274ngc program, but plotting\n"
             "\t live EMC movement will not be possible.\n\n");
      emcStatus = new EMC_STAT();
      emcStatus->motion.traj.position.tran.x = 0.0;
      emcStatus->motion.traj.position.tran.y = 0.0;
      emcStatus->motion.traj.position.tran.z = 0.0;
      emcStatus->motion.traj.position.a = 0.0;
      emcStatus->motion.traj.position.b = 0.0;
      emcStatus->motion.traj.position.c = 0.0;
      emcStatus->motion.traj.queue =0;
      emcStatus->motion.traj.velocity=1.0;
      emcStatus->motion.traj.maxVelocity=1.0;
      emcStatus->motion.traj.linearUnits=0.03937007874016;
      emcStatus->motion.traj.angularUnits=1.0;
      emcStatus->io.tool.toolInSpindle=0;
      emcStatus->io.coolant.flood=0;
      emcStatus->io.tool.toolPrepped=0;
    }
  else
    {
      if(emcStatusBuffer->peek() == EMC_STAT_TYPE)
        {
          emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
        }
      livePlotList  = new RCS_LINKED_LIST();
    }
  emcCommandBuffer
    = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "xemc", EMC_NMLFILE);

  printf("\n********************************************************\n\n");
  printf("EMC 3-D Plotter\n");
  printf("\nKeyboard Controls:\n");
  printf("\tTranslate X:  \t<LEFT ARROW KEY>/<RIGHT ARROW KEY>\n");
  printf("\tTranslate Y:  \t<UP ARROW KEY>/<DOWN ARROW KEY>\n");
  printf("\tTranslate Z:  \t<PAGE UP KEY>/<PAGE DOWN KEY>\n");
  printf("\n");
  printf("\tRotate around X axis:  \t<SHIFT><LEFT ARROW KEY>/<SHIFT><RIGHT ARROW KEY>\n");
  printf("\tRotate around Y axis: \t<SHIFT><UP ARROW KEY>/<SHIFT><DOWN ARROW KEY>\n");
  printf("\tRotate around Z axis: \t<SHIFT><PAGE UP KEY>/<SHIFT><PAGE DOWN KEY>\n");
  printf("\n");
  printf("\tView from X perspective:          \tx\n");
  printf("\tView from Y perspective:          \ty\n");
  printf("\tView from Z perspective:          \tz\n");
  printf("\tView from 45 degree angle:        \tk\n");
  printf("\tReset view:                       \t<SPACE KEY>\n");
  printf("\tClear live plot(Blue):            \tc\n");
  printf("\tToggle display of programmed plot(White)     \tp\n");
  printf("\tToggle display of rotation frames            \tr\n");
  printf("\tToggle display of live plot(Blue)            \tl\n");
  printf("\tQuit:                             \t<ESC KEY>\n");
  printf("\n********************************************************\n\n");

    /* Initialize GLUT state - glut will take any command line arguments that pertain to it or
       X Windows - look at its documentation at http://reality.sgi.com/mjk/spec3/spec3.html */
    glutInit(&argc, argv);

    /* Select type of Display mode:
     Double buffer
     RGBA color
     Alpha components supported
     Depth buffer */
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);

    for(int i = 0; i < argc; i++)
      {
        if((!strcmp(argv[i],"-prog") || !strcmp(argv[i],"--prog"))
           && i < argc -1)
          {
            Filename = argv[++i];
          }
        if(!strcmp(argv[i],"-f")
           && i < argc -1)
          {
            Filename = argv[++i];
          }
        if((!strcmp(argv[i],"-r") || !strcmp(argv[i],"--refresh"))
           && i < argc -1)
          {
            refresh_count = strtol(argv[++i],0,0);
          }
        if((!strcmp(argv[i],"-s") || !strcmp(argv[i],"--scale"))
           && i < argc -1)
          {
            scale = strtod(argv[++i],0);
          }
        if(!strcmp(argv[i],"-t") || !strcmp(argv[i],"--timer")
           && i < argc -1)
          {
            timer_period = strtol(argv[++i],0,0);
          }
        if(!strcmp("--stewart",argv[i]))
          {
            show_stewart_platform = 1;
            if(argc > i+1)
              {
                printf("Showing stewart platform %s\n",argv[i+1]);
                ReadStewartSpecs(argv[++i]);
              }
            else
              {
                ReadStewartSpecs(NULL);
              }
          }
      }

    /* get a 640 x 480 window */
    glutInitWindowSize(640, 480);

    /* the window starts at the upper left corner of the screen */
    glutInitWindowPosition(0, 0);

    /* Open a window */
    window = glutCreateWindow("EMC 3-D Plotter");

    /* Register the function to do all our OpenGL drawing. */
    glutDisplayFunc(&DrawGLScene);

    /* Go fullscreen.  This is as soon as possible. */
    glutFullScreen();

    /* Even if there are no events, redraw our gl scene. */
    //glutIdleFunc(&DrawGLScene);

    /* Register the function called when our window is resized. */
    glutReshapeFunc(&ReSizeGLScene);

    /* Register the function called when the keyboard is pressed. */
    glutKeyboardFunc(&keyPressed);

    /* Register the function called when special keys (arrows, page down, etc) are pressed. */
    glutSpecialFunc(&specialKeyPressed);

    /* Initialize our window. */
    InitGL(640, 480);

    /* Start timer function to check EMC status every 50 milliseconds.*/
    if(0 != emcStatusBuffer)
      {
        glutTimerFunc(timer_period,&RedisplayTimerFunc,1);
      }

    /* Start Event Processing Engine */
    glutMainLoop();

    if(0 != emcStatusBuffer)
      {
        delete emcStatusBuffer;
        emcStatusBuffer=0;
      }
    if(0 != emcCommandBuffer)
      {
        delete emcCommandBuffer;
        emcCommandBuffer=0;
      }
    return 1;
}

---