---

guiplanner.C

Go to the documentation of this file.

//----------------------------------------------------------------------
//               The Motion Strategy Library (MSL)
//----------------------------------------------------------------------
//
// Copyright (c) 1998-2000 Iowa State University and Steve LaValle.  
// All Rights Reserved.
// 
// Permission to use, copy, and distribute this software and its 
// documentation is hereby granted free of charge, provided that 
// (1) it is not a component of a commercial product, and 
// (2) this notice appears in all copies of the software and
//     related documentation. 
// 
// Iowa State University and the author make no representations
// about the suitability or fitness of this software for any purpose.  
// It is provided "as is" without express or implied warranty.
//----------------------------------------------------------------------

#include "guiplanner.h"


// *********************************************************************
// *********************************************************************
// CLASS:     MSLPlannerWindow
// 
// *********************************************************************
// *********************************************************************

// Map
FXDEFMAP(MSLPlannerWindow) MSLPlannerWindowMap[]={
  FXMAPFUNC(SEL_TIMEOUT,FXMainWindow::ID_LAST,MSLPlannerWindow::onCmdTimer),
  FXMAPFUNCS(SEL_COMMAND, 20, 300, MSLPlannerWindow::GeneralHandler)
};


// Object implementation
FXIMPLEMENT(MSLPlannerWindow,FXMainWindow,MSLPlannerWindowMap,ARRAYNUMBER(MSLPlannerWindowMap))
  
// Make some windows
MSLPlannerWindow::MSLPlannerWindow(GuiPlanner* gp):FXMainWindow(gp,"Motion Strategy Library",NULL,NULL,DECOR_ALL,20,20,500,260) {

  GP = gp;
  
  // Make the target connections
  Restart();

  // Menubar
  menubar=new FXMenubar(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X);
  plannermenu = new FXMenuPane(this);
    new FXMenuCommand(plannermenu,"RRT",NULL,this,201);
    new FXMenuCommand(plannermenu,"RRTGoalBias",NULL,this,202);
    new FXMenuCommand(plannermenu,"RRTCon",NULL,this,204);
    new FXMenuCommand(plannermenu,"RRTDual",NULL,this,205);
    new FXMenuCommand(plannermenu,"RRTExtExt",NULL,this,206);
    new FXMenuCommand(plannermenu,"RRTExtCon",NULL,this,210);
    new FXMenuCommand(plannermenu,"RRTConCon",NULL,this,211);
    new FXMenuCommand(plannermenu,"PRM",NULL,this,230);
    new FXMenuCommand(plannermenu,"FDP",NULL,this,240);
    new FXMenuCommand(plannermenu,"FDPStar",NULL,this,241);
    new FXMenuCommand(plannermenu,"FDPBestFirst",NULL,this,242);
    new FXMenuCommand(plannermenu,"FDPBi",NULL,this,243);
  new FXMenuTitle(menubar,"&Planner",NULL,plannermenu);

  loadmenu=new FXMenuPane(this);
    new FXMenuCommand(loadmenu,"Load Graph(s)",NULL,this,45,0);
    new FXMenuCommand(loadmenu,"Load Path",NULL,this,49,0);
    new FXMenuCommand(loadmenu,"Load Animation Frames",NULL,this,47,0);
  new FXMenuTitle(menubar,"&Load",NULL,loadmenu);

  savemenu=new FXMenuPane(this);
    new FXMenuCommand(savemenu,"Save Graph(s)",NULL,this,44,0);
    new FXMenuCommand(savemenu,"Save Path",NULL,this,48,0);
    new FXMenuCommand(savemenu,"Save Animation Frames",NULL,this,46,0);
  new FXMenuTitle(menubar,"&Save",NULL,savemenu);

  plotmenu=new FXMenuPane(this);
    new FXMenuCommand(plotmenu,"Draw 2D Graphs",NULL,this,31,0);
  new FXMenuTitle(menubar,"Plo&t",NULL,plotmenu);

  new FXHorizontalSeparator(this,LAYOUT_SIDE_TOP|SEPARATOR_GROOVE|LAYOUT_FILL_X);

  // Buttons
  buttonbar=new FXMenubar(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X);
  new FXButton(buttonbar,"&Construct",NULL,this,22,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(buttonbar,"P&lan",NULL,this,23,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(buttonbar,"C&lear",NULL,this,24,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(buttonbar,"&Quit",NULL,this,51,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);

  new FXHorizontalSeparator(this,LAYOUT_SIDE_TOP|SEPARATOR_GROOVE|LAYOUT_FILL_X);
  
  new FXLabel(this," Planner Controls                                    Animation Controls",
    NULL,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|JUSTIFY_LEFT);
    
  new FXHorizontalSeparator(this,LAYOUT_SIDE_TOP|SEPARATOR_GROOVE|LAYOUT_FILL_X);

  vcrbar=new FXMenubar(this,LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X);
  new FXLabel(vcrbar,"Movie Buttons",NULL,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|JUSTIFY_LEFT);
  new FXButton(vcrbar,"Stop",NULL,this,71,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Last",NULL,this,76,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Pause",NULL,this,72,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Next",NULL,this,77,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Slower",NULL,this,73,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Play",NULL,this,70,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Faster",NULL,this,74,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  new FXButton(vcrbar,"Reset",NULL,this,75,FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);

  // Arange nicely
  matrix=new FXMatrix(this,5,MATRIX_BY_COLUMNS|LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y);
  
  new FXLabel(matrix,"PlannerDeltaT",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  new FXTextField(matrix,10,&plannerdeltat_target,FXDataTarget::ID_VALUE,TEXTFIELD_REAL|JUSTIFY_RIGHT|LAYOUT_CENTER_Y|LAYOUT_CENTER_X|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_ROW);
  new FXFrame(matrix,LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW);
  new FXLabel(matrix,"AnimationTimeScale",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  FXSlider* fsl = new FXSlider(matrix,&animationtimescale_target,FXDataTarget::ID_VALUE,LAYOUT_CENTER_Y|LAYOUT_FILL_ROW|LAYOUT_FIX_WIDTH,0,0,100);
  fsl->setRange(1,100);

  new FXLabel(matrix,"NumNodes",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  new FXTextField(matrix,10,&numnodes_target,FXDataTarget::ID_VALUE,TEXTFIELD_INTEGER|JUSTIFY_RIGHT|LAYOUT_CENTER_Y|LAYOUT_CENTER_X|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_ROW);
  new FXFrame(matrix,LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW);
  new FXFrame(matrix,LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW);
  //new FXLabel(matrix,"AmbientLight",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  new FXTextField(matrix,10,&animationtimescale_target,FXDataTarget::ID_VALUE,TEXTFIELD_INTEGER|JUSTIFY_RIGHT|LAYOUT_CENTER_Y|LAYOUT_CENTER_X|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_ROW);
  //new FXSlider(matrix,&ambientlight_target,FXDataTarget::ID_VALUE,LAYOUT_CENTER_Y|LAYOUT_FILL_ROW|LAYOUT_FIX_WIDTH,0,0,100);

  new FXLabel(matrix,"DrawIndexX",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  new FXTextField(matrix,10,&drawindexx_target,FXDataTarget::ID_VALUE,TEXTFIELD_INTEGER|JUSTIFY_RIGHT|LAYOUT_CENTER_Y|LAYOUT_CENTER_X|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_ROW);
  //  new FXSpinner(matrix,5,&drawindexx_target,0,SPIN_CYCLIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_CENTER_Y|LAYOUT_FILL_ROW);
  new FXFrame(matrix,LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW);

  new FXToggleButton(matrix,"Bounding Box OFF","Bounding Box ON",NULL,NULL,this,83,LAYOUT_CENTER_Y|LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW|ICON_BEFORE_TEXT);
  new FXToggleButton(matrix,"Multiple Views OFF","Multiple Views ON",NULL,NULL,this,82,LAYOUT_CENTER_Y|LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW|ICON_BEFORE_TEXT);

  new FXLabel(matrix,"DrawIndexY",NULL,LAYOUT_CENTER_Y|LAYOUT_CENTER_X|JUSTIFY_RIGHT|LAYOUT_FILL_ROW);
  new FXTextField(matrix,10,&drawindexy_target,FXDataTarget::ID_VALUE,TEXTFIELD_INTEGER|JUSTIFY_RIGHT|LAYOUT_CENTER_Y|LAYOUT_CENTER_X|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_ROW);
  //new FXSpinner(matrix,5,&drawindexy_target,1,SPIN_CYCLIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_CENTER_Y|LAYOUT_FILL_ROW);
  new FXFrame(matrix,LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW);
  new FXToggleButton(matrix,"Attached Camera OFF","Attached Camera ON",NULL,NULL,this,81,LAYOUT_CENTER_Y|LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW|ICON_BEFORE_TEXT);
  new FXToggleButton(matrix,"Show Path OFF","Show Path ON",NULL,NULL,this,80,LAYOUT_CENTER_Y|LAYOUT_FILL_COLUMN|LAYOUT_FILL_ROW|ICON_BEFORE_TEXT);

  new FXHorizontalSeparator(this,LAYOUT_SIDE_TOP|SEPARATOR_GROOVE|LAYOUT_FILL_X);

  // Install an accelerator
  getAccelTable()->addAccel(fxparseaccel("Ctl-Q"),getApp(),MKUINT(-1,SEL_COMMAND));
  }


// Clean up
MSLPlannerWindow::~MSLPlannerWindow(){
  delete loadmenu;
  delete savemenu;
  delete plotmenu;
  delete plannermenu;
  }


// Timer  
long MSLPlannerWindow::onCmdTimer(FXObject*,FXSelector,void*) {
  
  // Reset timer for next time
  getApp()->addTimeout(80,this,FXMainWindow::ID_LAST);
  return 1;
}


  
// Start
void MSLPlannerWindow::create(){
  
  // Create windows
  FXMainWindow::create();
  
  // Kick off the timer
  getApp()->addTimeout(80,this,FXMainWindow::ID_LAST);

  // Show
  show(PLACEMENT_SCREEN);
}



void MSLPlannerWindow::Restart() {
  
  // Make the target connections
  plannerdeltat_target.connect(GP->Pl->PlannerDeltaT);
  numnodes_target.connect(GP->Pl->NumNodes);
  drawindexx_target.connect(GP->DrawIndexX);
  drawindexy_target.connect(GP->DrawIndexY);
  animationtimescale_target.connect(GP->R->AnimationTimeScale);
  ambientlight_target.connect(GP->R->AmbientLight);
}


// Timer  
long MSLPlannerWindow::GeneralHandler(FXObject*,FXSelector sel,void*) {
  int i = SELID(sel);
  //cout << "General Handler  -- selection " << i << "\n";

  GP->ButtonHandle(i);

  return 1;
}




// *********************************************************************
// *********************************************************************
// CLASS:     MSLPlotWindow
// 
// *********************************************************************
// *********************************************************************



// Message Map for the Plot Window class
FXDEFMAP(MSLPlotWindow) MSLPlotWindowMap[]={

  //________Message_Type_____________________ID____________Message_Handler_______
  FXMAPFUNC(SEL_PAINT,MSLPlotWindow::ID_CANVAS, MSLPlotWindow::onPaint),
  FXMAPFUNC(SEL_COMMAND,MSLPlotWindow::ID_PRINT, MSLPlotWindow::onCmdPrint),
};



// Macro for the PlotApp class hierarchy implementation
FXIMPLEMENT(MSLPlotWindow,FXDialogBox,MSLPlotWindowMap,ARRAYNUMBER(MSLPlotWindowMap))



// Construct a MSLPlotWindow
MSLPlotWindow::MSLPlotWindow(MSLPlannerWindow* owner):
  FXDialogBox(owner,"Plot Window",DECOR_ALL,0,0,500,500) {

  Owner = owner;
  GP = owner->GP;
  indexx = GP->DrawIndexX;
  indexy = GP->DrawIndexY;

  if ((indexx >= GP->Pl->P->StateDim)||(indexx < 0))
    indexx = 0;
  if ((indexy >= GP->Pl->P->StateDim)||(indexy < 0))
    indexy = 1;

  char* title = new char[80];
  sprintf(title,"Search Graph(s):   x[%d] vs. x[%d]",indexx,indexy);

  contents=new FXHorizontalFrame(this,LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,0,0,0,0, 0,0,0,0);
  
  // LEFT pane to contain the canvas
  canvasFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);
  
    // Label above the canvas               
  new FXLabel(canvasFrame,title,NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
  
    // Horizontal divider line
  new FXHorizontalSeparator(canvasFrame,SEPARATOR_GROOVE|LAYOUT_FILL_X);

    // Drawing canvas
  canvas=new FXCanvas(canvasFrame,this,ID_CANVAS,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT);

  // RIGHT pane for the buttons
  buttonFrame=new FXVerticalFrame(contents,FRAME_SUNKEN|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,10,10);

    // Label above the buttons  
    new FXLabel(buttonFrame,"Options",NULL,JUSTIFY_CENTER_X|LAYOUT_FILL_X);
    
    // Horizontal divider line
    new FXHorizontalSeparator(buttonFrame,SEPARATOR_RIDGE|LAYOUT_FILL_X);

    // Button to print
    new FXButton(buttonFrame,"&Print",NULL,this,ID_PRINT,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

    // Exit button
    new FXButton(buttonFrame,"&Exit",NULL,this,ID_HIDE,FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,0,0,0,0,10,10,5,5);

}
    
 

// Paint the canvas
long MSLPlotWindow::onPaint(FXObject*,FXSelector,void* ptr){
  FXEvent *ev=(FXEvent*)ptr;
  FXDCWindow dc(canvas,ev);
  dc.setForeground(canvas->getBackColor());
  dc.fillRectangle(ev->rect.x,ev->rect.y,ev->rect.w,ev->rect.h);
  drawPage(dc,canvas->getWidth(),canvas->getHeight());
  return 1;
}


long MSLPlotWindow::onCmdPrint(FXObject*,FXSelector,void*){
  FXPrintDialog dlg(this,"Print Graphics");
  FXPrinter printer;
  if(dlg.execute()){
    dlg.getPrinter(printer);
    FXTRACE((100,"Printer = %s\n",printer.name.text()));
    FXDCPrint pdc(getApp());
    if(!pdc.beginPrint(printer)) {
      FXMessageBox::error(this,MBOX_OK,"Printer Error","Unable to print");
      return 1;
    }
    pdc.beginPage(1);
    pdc.setLineWidth(1);
    drawPage(pdc,400,400,100,100);
    pdc.endPage();
    pdc.endPrint();
    }
  return 1;
}



// This is the WYSIWYG routine, it takes a DC and renders 
// into it; it does not know if the DC is a printer or screen.
void MSLPlotWindow::drawPage(FXDC& dc,FXint w,FXint h,
                             FXint tx = 0,FXint ty = 0) {
  list<MSLNode*> nlist;
  list<MSLNode*>::iterator ni;
  list<MSLEdge*> elist;
  list<MSLEdge*>::iterator ei;
  MSLVector x1,x2;
  double tranx,trany,scalex,scaley;
  int lw;

  //dc.setForeground(erasecolor);
  //dc.fillRectangle(0,0,w,h);

  //dc.setForeground(forecolor);
  //dc.setBackground(FXRGB(0,0,0));
  
  //dc.setLineStyle(lineStyle);
  //dc.setLineCap(capStyle);
  //dc.setLineJoin(joinStyle);
  //dc.setFunction(function);
  
  //dc.setStipple(stipple);
  //dc.setFillStyle(fillStyle);
  //dc.setLineWidth(lineWidthSpinner->getValue());
  lw = dc.getLineWidth();
  dc.setLineWidth(0);

  dc.setForeground(FXRGB(0,0,0));
  dc.drawRectangle(tx,ty,w,h);

  scalex = w/(GP->Pl->P->UpperState[indexx] - 
              GP->Pl->P->LowerState[indexx]); 
  scaley = -h/(GP->Pl->P->UpperState[indexy] - 
              GP->Pl->P->LowerState[indexy]); 
  tranx = tx-1.0 * scalex * GP->Pl->P->LowerState[indexx];
  trany = ty+h-1.0 * scaley * GP->Pl->P->LowerState[indexy];

  // Show path (if it exists)
  dc.setForeground(FXRGB(200,0,0));
  dc.setLineWidth(2);
  list<MSLVector> path;
  list<MSLVector>::iterator pi;
  path = GP->Pl->Path;
  if (path.size() >= 2) {
    x1 = path.front();
    pi = path.begin(); 
    pi++;
    while (pi != path.end()) {
      x2 = *pi;
      dc.drawLine(x1[indexx]*scalex+tranx,
                  x1[indexy]*scaley+trany,
                  x2[indexx]*scalex+tranx,
                  x2[indexy]*scaley+trany);
      x1 = x2;
      pi++;
    }
  }

  // Show first tree (if it exists)
  dc.setLineWidth(lw);
  dc.setForeground(FXRGB(0,0,255));
  if (GP->Pl->T) {
    nlist = GP->Pl->T->Nodes();
    forall(ni,nlist) {
      if ((*ni)->Parent()) {  // Make sure it has a parent to connect to!
        x1 = (*ni)->State();
        x2 = (*ni)->Parent()->State();
        dc.drawLine(x1[indexx]*scalex+tranx,
                    x1[indexy]*scaley+trany,
                    x2[indexx]*scalex+tranx,
                    x2[indexy]*scaley+trany);
      }
    }
  }
  // Show second tree (if it exists)
  dc.setForeground(FXRGB(255,0,0));
  if (GP->Pl->T2) {
    nlist = GP->Pl->T2->Nodes();
    forall(ni,nlist) {
      if ((*ni)->Parent()) {  // Make sure it has a parent to connect to!
        x1 = (*ni)->State();
        x2 = (*ni)->Parent()->State();
        dc.drawLine(x1[indexx]*scalex+tranx,
                    x1[indexy]*scaley+trany,
                    x2[indexx]*scalex+tranx,
                    x2[indexy]*scaley+trany);
      }
    }
  }

  // Show roadmap (if it exists)
  dc.setForeground(FXRGB(0,150,0));
  if (GP->Pl->Roadmap) {
    elist = GP->Pl->Roadmap->Edges();
    forall(ei,elist) {
      x1 = (*ei)->Source()->State();
      x2 = (*ei)->Target()->State();
      dc.drawLine(x1[indexx]*scalex+tranx,
                  x1[indexy]*scaley+trany,
                  x2[indexx]*scalex+tranx,
                  x2[indexy]*scaley+trany);
    }
  }

  // Restore original values
  dc.setLineWidth(lw);
}



// *********************************************************************
// *********************************************************************
// CLASS:     GuiPlanner
// 
// *********************************************************************
// *********************************************************************

GuiPlanner::GuiPlanner(Render *render, Planner *planner):Gui(render) {
  Pl = planner;

  LineWidth = 1.0;
  PSLineWidth = 1.0;
  DrawIndexX = 0;
  DrawIndexY = 1;

  if (!render) 
    cout << "ERROR: Renderer no defined\n";

  FilePath = Pl->P->FilePath;

  CreateMenuWindow();
}



void GuiPlanner::Init() {
  list<MSLVector> tpath;
  
  // Read the planner type, if exists
  if (is_file(Pl->P->FilePath + "RRT"))
    ButtonHandle(201);
  if (is_file(Pl->P->FilePath + "RRTGoalBias"))
    ButtonHandle(202);
  if (is_file(Pl->P->FilePath + "RRTGoalPull"))
    ButtonHandle(203);
  if (is_file(Pl->P->FilePath + "RRTCon"))
    ButtonHandle(204);
  if (is_file(Pl->P->FilePath + "RRTPolar"))
    ButtonHandle(208);
  if (is_file(Pl->P->FilePath + "RRTHull"))
    ButtonHandle(209);
  if (is_file(Pl->P->FilePath + "RRTStar"))
    ButtonHandle(212);
  if (is_file(Pl->P->FilePath + "RRTGoalZoom"))
    ButtonHandle(207);
  if (is_file(Pl->P->FilePath + "RRTDual")) 
    ButtonHandle(205);
  if (is_file(Pl->P->FilePath + "RRTExtExt"))
    ButtonHandle(206);
  if (is_file(Pl->P->FilePath + "RRTExtCon"))
    ButtonHandle(210);
  if (is_file(Pl->P->FilePath + "RRTConCon"))
    ButtonHandle(211);
  if (is_file(Pl->P->FilePath + "PlannerHsu"))
    ButtonHandle(213);
  if (is_file(Pl->P->FilePath + "RRTNaive"))
    ButtonHandle(214);    
  if (is_file(Pl->P->FilePath + "PRM"))
    ButtonHandle(230);    
  if (is_file(Pl->P->FilePath + "FDP"))
    ButtonHandle(240);    
  if (is_file(Pl->P->FilePath + "FDPStar"))
    ButtonHandle(241);    
  if (is_file(Pl->P->FilePath + "FDPBestFirst"))
    ButtonHandle(242);    
  if (is_file(Pl->P->FilePath + "FDPBi"))
    ButtonHandle(243);    
  
  Gui::Init();

  // Set up to animate a single frame initially
  tpath.clear();
  //tpath.push(Pl->P->GoalState);
  tpath.push_back(Pl->P->InitialState);
  R->MakeAnimationFrames(tpath, 1.0);   
  R->AnimationActive = true;
}


void GuiPlanner::CreateMenuWindow() {
  int argc;
  char **argv;

  // Make application
  //FXApp application("DataTarget","FoxTest");
  
  // Open display (multiple inheritance from FXApp)
  init(argc,argv);
  
  // Main window
  Window=new MSLPlannerWindow(this);
  
  // Handle interrupt to save stuff nicely (from FXApp)
  //addSignal(SIGINT,Window,FXApp::ID_QUIT);

  // Create app (from FXApp)
  create();
  
  // Run (from FXApp)
  //run();

}


void GuiPlanner::ResetPlanner()
{
  R->SetScene(new Scene(Pl->P,FilePath));
  Pl->Reset();
  Window->Restart();
}


void GuiPlanner::ButtonHandle(int b){
  //cout << "button " << b << "\n";
  //char *icon;
  if ((b >= 70) && (b <= 90))
    R->ButtonHandle(b);
  else {
    switch (b) {
    case 22: cout << "Construct\n";
      Pl->Construct();
      //U.DrawGraphs();
      break;
    case 23: cout << "Plan\n";
      if (Pl->Plan()) {
        cout << "Making Animation Frames\n";
        // Make the animation frames
        if ((Pl->Path.size() >= 2)||
            (R->FrameList.size() > 0))
          {
          R->MakeAnimationFrames(Pl->Path,Pl->TimeList); 
          }
      }
      //U.DrawPath();
      //U.DrawGraphs();
      break;
    case 24: cout << "Clear Graphs\n";
      ResetPlanner();
      break;
    case 31: cout << "2D Graph Projection\n";
      DrawGraphs();
      break;
    case 32: cout << "3D Graph Projection\n";
      //DrawRRTNodes();
      break;
    case 33: cout << "Draw Voronoi Diagram\n";
      //DrawVoronoi();
      break;
    case 41: cout << "Write 2D Graph Projection to PS\n";
      //PSDrawGraphs();
      break;
    case 42: cout << "Write Voronoi Edges to PS\n";
      //PSDrawVoronoi();
      break;
    case 43: cout << "Write Path to PS\n";
      //PSDrawPath();
      break;
    case 44: cout << "Write Graph(s)\n";
      WriteGraphs();
      break;
    case 45: cout << "Read Graph(s)\n";
      ReadGraphs();
      break;
    case 46: cout << "Write Animation Frames\n";
      WriteAnimationFrames();
      break;
    case 47: cout << "Read Animation Frames\n";
      ReadAnimationFrames();      
      break;
    case 48: cout << "Write Path\n";
      WritePath();
      break;
    case 49: cout << "Read Path\n";
      ReadPath();      
      break;
    case 51: cout << "Done\n";
      Finished = true;  // This should trigger leaving (for most renderers)
      break;
    case 80: cout << "Toggle Show Path\n";
      R->ShowPathOn = !R->ShowPathOn; 
      break;
    case 201: cout << "Switch to RRT Planner\n";
      ResetPlanner();
      Pl = new RRT(Pl->P); // Keep the old model, change the planner
      break;
    case 202: cout << "Switch to RRTGoalBias Planner\n";
      ResetPlanner();
      Pl = new RRTGoalBias(Pl->P); // Keep the old model, change the planner
      break;
    case 203: cout << "Switch to RRTGoalPull Planner\n";
      ResetPlanner();
      //Pl = new RRTGoalPull(Pl->P); // Keep the old model, change the planner
      break;
    case 204: cout << "Switch to RRTCon Planner\n";
      ResetPlanner();
      Pl = new RRTCon(Pl->P); // Keep the old model, change the planner
      break;
    case 205: cout << "Switch to RRTDual Planner\n";
      ResetPlanner();
      Pl = new RRTDual(Pl->P); // Keep the old model, change the planner
      break;
    case 206: cout << "Switch to RRTExtExt Planner\n";
      ResetPlanner();
      Pl = new RRTExtExt(Pl->P); // Keep the old model, change the planner
      break;
    case 207: cout << "Switch to RRTGoalZoom Planner\n";
      ResetPlanner();
      //Pl = new RRTGoalZoom(Pl->P); // Keep the old model, change the planner
      break;
    case 208: cout << "Switch to RRTPolar Planner\n";
      ResetPlanner();
      //Pl = new RRTPolar(Pl->P); // Keep the old model, change the planner
      break;
    case 209: cout << "Switch to RRTHull Planner\n";
      ResetPlanner();
      //Pl = new RRTHull(Pl->P);
      break;
    case 210: cout << "Switch to RRTExtCon (RRT-Connect) Planner\n";
      ResetPlanner();
      Pl = new RRTExtCon(Pl->P);
      break;
    case 211: cout << "Switch to RRTConCon Planner\n";
      ResetPlanner();
      Pl = new RRTConCon(Pl->P);
      break;
    case 212: cout << "Switch to RRTStar Planner\n";
      ResetPlanner();
      //Pl = new RRTStar(Pl->P);
      break;
    case 213: cout << "Switch to PlannerHsu Planner\n";
      ResetPlanner();
      //Pl = new PlannerHsu(Pl->P);
      break;
    case 214: cout << "Switch to RandomTree Planner\n";
      ResetPlanner();
      //Pl = new RandomTree(Pl->P);
      break;
    case 230: cout << "Switch to PRM Planner\n";
      ResetPlanner();
      Pl = new PRM(Pl->P);
      break;
    case 240: cout << "Switch to FDP Planner\n";
      ResetPlanner();
      Pl = new FDP(Pl->P);
      break;
    case 241: cout << "Switch to FDPStar Planner\n";
      ResetPlanner();
      Pl = new FDPStar(Pl->P);
      break;
    case 242: cout << "Switch to FDPBestFirst Planner\n";
      ResetPlanner();
      Pl = new FDPBestFirst(Pl->P);
      break;
    case 243: cout << "Switch to FDPBi Planner\n";
      ResetPlanner();
      Pl = new FDPBi(Pl->P);
      break;
      
    default: cout << "Option " << b << " not implemented\n";
      break;
    }
  }
}



void GuiPlanner::HandleEvents() {
  runOneEvent();  // Run a FOX event (came from FXApp parent class)
}



void GuiPlanner::WriteGraphs()
{
  FXFileDialog dialog(Window,"Write Solution Path");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("graphs");
  if (dialog.execute()) {
    std::ofstream outfile(dialog.getFilename().text()); 
    if (outfile) {   
      Pl->WriteGraphs(outfile);
      outfile.close();
    }
  }
}



void GuiPlanner::ReadGraphs()
{
  FXFileDialog dialog(Window,"Read Animation Frames");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("graphs");
  if (dialog.execute()) {
    std::ifstream infile(dialog.getFilename().text()); 
    if (infile) {   
      Pl->ReadGraphs(infile);
      infile.close();
    }
  }
}



void GuiPlanner::WriteAnimationFrames()
{
  FXFileDialog dialog(Window,"Write Animation Frames");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("frames");
  if (dialog.execute()) {
    std::ofstream outfile(dialog.getFilename().text()); 
    if (outfile) {   
      outfile << R->FrameList;
      outfile.close();
    }
  }
}



void GuiPlanner::ReadAnimationFrames()
{
  FXFileDialog dialog(Window,"Read Animation Frames");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("frames");
  if (dialog.execute()) {
    std::ifstream infile(dialog.getFilename().text()); 
    if (infile) {   
      infile >> R->FrameList;
      infile.close();
    }
  }

  R->AnimationActive = true;
}


void GuiPlanner::WritePath()
{
  FXFileDialog dialog(Window,"Write Solution Path");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("path");
  if (dialog.execute()) {
    std::ofstream outfile(dialog.getFilename().text()); 
    if (outfile) {   
      outfile << Pl->Path;
      outfile.close();
    }
  }
}



void GuiPlanner::ReadPath()
{
  FXFileDialog dialog(Window,"Read Animation Frames");
  dialog.setDirectory(("./"+FilePath).c_str());
  dialog.setFilename("path");
  if (dialog.execute()) {
    std::ifstream infile(dialog.getFilename().text()); 
    if (infile) {   
      infile >> Pl->Path;
      infile.close();
    }
  }

  R->AnimationActive = true;
  R->MakeAnimationFrames(Pl->Path,Pl->TimeList); 
}


void GuiPlanner::DrawGraphs()
{
  MSLPlotWindow *pw = new MSLPlotWindow(Window);

  //pw->execute();  This one is modal
  pw->create();
  pw->show();

  cout << "Draw Graphs\n";
}

---

Web page maintained by Steve LaValle
Partial support provided by NSF CAREER Award IRI-970228 (LaValle), Honda Research, and Iowa State University.
Contributors: Anna Atramentov, Peng Cheng, James Kuffner, Steve LaValle, and Libo Yang.