Panel.cxx

Go to the documentation of this file.

#include "Panel.h"
#include "wx/menu.h"
#include "NIREPvtkInteractorStyleImage2D.h"
#include "NIREPvtkViewImage2DCommand.h"
#include "PanelForm.h"
#include "NIREPDisplay.h"
#include "wxVtkImageFlip.h"
#include "NIREPvtkViewImage.h"
#include <vtkLookupTableManager.h>
#include "vtkIntArray.h"
#include "vtkCharArray.h"
#include "lut/HotMetal.h"
#include <vtkImageFlip.h>
#include "RelativeOverlap.h"
#include "vtkRendererCollection.h"
#include "NIREPRelativeOverlap.h"
#include "NIREPInverseConsistencyError.h"
#include "NIREPTransitivityError.h"
#include "NIREPIntensityVariance.h"
#include "VectorField.h"
//#include "gecMath.h"

// OBJMAP includes
#include "vtkLookupTable.h"
#include "ObjectmapForm.h"




IMPLEMENT_DYNAMIC_CLASS( Panel, wxPanel )



BEGIN_EVENT_TABLE( Panel, wxPanel )

    EVT_MENU(ID_POPUP,Panel::PanelFrame)
    EVT_MENU(ID_POPUPTHREE,Panel::Mouse)
    EVT_MENU(ID_POPUPFOUR,Panel::Mouse)
    EVT_MENU(ID_POPUPFIVE,Panel::Mouse)
    EVT_MENU(ID_POPUPSIX,Panel::Flip)
    EVT_MENU(ID_POPUPSEVEN,Panel::ObjectMapForm)

END_EVENT_TABLE()


/*
  function:  Panel
  purpose:   constructor
  overloads: Panel(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
*/
Panel::Panel()
{
    Init();
}

/*
  function:  Panel
  purpose:   constructor
  overloads: Panel(void)
*/
Panel::Panel(wxWindow* parent,DisplayDescription *dd, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
{
  //Initialize some of the class variables
    Init();

    m_displayDescription = dd;

    //create the initial items for the panel.  However, to have a true 
    //view be displayed, you will need to call either the function
    //use(int widget) or one of the use*() functions
    bool temp = Create(parent, id, pos, size, style);
}


/*
  function: Create
  purpose:  
  input:
  output:   bool
*/
bool Panel::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
{
    wxPanel::Create(parent, id, pos, size, style);
    CreateControls();
    return true;
}


/*
  function: ~Panel
  purpose: class destructor, destroying references to pointers 
  input:
  output:
*/
Panel::~Panel()
{
  if(!ObjectEntryTable.empty()) {
    ObjectEntryTable.clear();
  }
  if(wxView) {
    wxView->Delete();
    wxView = NULL;
  }
  if(m_widget) {
    m_widget->Delete();
    m_widget = NULL;
  }
  if(TreePopupMenu) {
    delete TreePopupMenu;
    TreePopupMenu = NULL;
  }
  if(PanelLookupTable) {
    //PanelLookupTable->Delete();
    PanelLookupTable = NULL;
  }
  if(parent) {
    parent = NULL;
  }
  if(evaluator) {
    evaluator = NULL;
  }
  if(m_flexGridSizer) {
    m_flexGridSizer = NULL;
  }
  if(m_richTextController) {
    m_richTextController = NULL;
  }
  if(m_displayDescription) {
    m_displayDescription = NULL;
  }
}


/*
  function: Init
  purpose:  
  input:
  output:
*/
void Panel::Init()
{
  wxView = NULL;
  m_widget = NULL;
  m_richTextController = NULL;
  TreePopupMenu = NULL;
  mouse = 0;

  PanelLookupTable = vtkLookupTable::New();
  PanelLookupTable->SetTableRange (0, 1);
  PanelLookupTable->SetSaturationRange (0, 0);
  PanelLookupTable->SetHueRange (0, 0);
  PanelLookupTable->SetValueRange (0, 1);
  PanelLookupTable->SetAlphaRange (0, 1);
  PanelLookupTable->Build();
  m_lookupTableSelection = 0;
  this->m_orientation = NIREPvtkViewImage::AXIAL_ID;
}

/*
  function: SetLookUpTable
  purpose:  
  input: vtkLookupTable *
         int
  output:
*/
void Panel::SetLookUpTable(vtkLookupTable *vlt, int selection)
{
  m_lookupTableSelection = selection;
  if(PanelLookupTable)
      PanelLookupTable->Delete();


  PanelLookupTable = vlt;
  // TODO: m_widgetType is a std::string, cannot compare to integer 
  //if(m_widget && !m_widgetType.compare("4") && !m_widgetType.compare("5"))
    //m_widget->SetLookupTable(vlt);
}



/*
  function: CreateControls
  purpose:  
  input:
  output:
*/
//Create the initial items for this panel.  However, to have a true 
//view be displayed, you will need to call either the function
//use(int widget) or one of the use*() functions
void Panel::CreateControls()
{    
    Panel* itemPanel1 = this;
    //Add a flex grid for the view
    m_flexGridSizer = new wxFlexGridSizer(2, 1, 0, 0);

    //Set the sizer up so that when the panel is resized that the view also
    //resizes.
    m_flexGridSizer->AddGrowableCol(0);
    m_flexGridSizer->AddGrowableRow(0);

    //Set the sizer to this panel
    itemPanel1->SetSizer(m_flexGridSizer);

    //Create the vtkRenderWindow and partial interactor.  This is still not
    //the view, this is just the RenderWindow which will need to be used
    //to display the different views.
    wxView = new NIREPwxVTKRenderWindowInteractor(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE, wxT("")); 

    //Add the RenderWindow to the panel
    m_flexGridSizer->Add(wxView, 1, wxALL|wxEXPAND|wxGROW, 0);
}


/*
  function: ShowToolTips
  purpose:  
  input:
  output: bool
*/
bool Panel::ShowToolTips()
{
    return true;
}

/*
  function: GetBitmapResource
  purpose:  
  input: const wxString&
  output: wxBitmap
*/
wxBitmap Panel::GetBitmapResource( const wxString& name )
{
    wxUnusedVar(name);
    return wxNullBitmap;
}

/*
  function: GetIconResource
  purpose:  
  input: const wxString&
  output: wxIcon
*/
wxIcon Panel::GetIconResource( const wxString& name )
{
    wxUnusedVar(name);
    return wxNullIcon;
}


//-------------------------------Beginning of Use-------------------------
//The following Use*() are functions to make the programmers life easier.
//This way the programmer does not have to know which integer goes with
//which widget.
void Panel::UseImage()
{
  //this->UseWidget(IMAGE_WIDGET);
  this->UseWidget(WidgetCmd["view"]);
}

void Panel::UseCheckerboard()
{
  //this->UseWidget(CHECKERBOARD_WIDGET);
  this->UseWidget(WidgetCmd["checkerboard"]);
}

void Panel::UseWipe()
{
  //this->UseWidget(WIPE_WIDGET);
  this->UseWidget(WidgetCmd["wipe"]);
}

void Panel::UseObjectMap()
{
  //this->UseWidget(OBJECTMAP_WIDGET);
  this->UseWidget(WidgetCmd["objectmap"]);
}

void Panel::UseOverlayObjectMap()
{
  //this->UseWidget(OVERLAY_OBJECTMAP_WIDGET);
  this->UseWidget(WidgetCmd["overlayObjectMap"]);
}

void Panel::UseOverlayImage()
{
  //this->UseWidget(OVERLAY_IMAGE_WIDGET);
  this->UseWidget(WidgetCmd["overlayImage"]);
}

void Panel::UseRelativeOverlap()
{
  //this->UseWidget(RELATIVE_OVERLAP);
  this->UseWidget(WidgetCmd["relativeOverlap"]);
}

void Panel::UseRelativeOverlapTextStatistic()
{
  //this->UseWidget(RELATIVE_OVERLAP_TEXT);
  this->UseWidget(WidgetCmd["relativeOverlapTextWidget"]);
}

void Panel::UseIntensityVarianceTextStatistic()
{
  //this->UseWidget(INTENSITY_VARIANCE_TEXT);
  this->UseWidget(WidgetCmd["intensityVarianceTextWidget"]);
}

void Panel::UseInverseConsistencyTextStatistic()
{
  //this->UseWidget(INVERSE_CONSISTENCY_TEXT);
  this->UseWidget(WidgetCmd["inverseConsistencyTextWidget"]);
}

void Panel::UseTransitivityErrorTextStatistic()
{
  //this->UseWidget(TRANSITIVITY_ERROR_TEXT);
  this->UseWidget(WidgetCmd["transitivityErrorTextWidget"]);
}

void Panel::UseVarianceTransformTextStatistic()
{
  //this->UseWidget(VARIANCE_TRANSFORM_TEXT);
  this->UseWidget(WidgetCmd["varianceTransformText"]);
}

void Panel::UseVarianceImageTextStatistic()
{
  //this->UseWidget(VARIANCE_IMAGE_TEXT);
  this->UseWidget(WidgetCmd["varianceImageText"]);
}

void Panel::UseBlank()
{
  //this->UseWidget(BLANK_WIDGET);
  this->UseWidget(WidgetCmd["blankWidget"]);
}

void Panel::UseVectorField()
{
  //this->UseWidget(BLANK_WIDGET);
  this->UseWidget(WidgetCmd["vectorField"]);
}


/*
  function: UseWidget
  purpose:  
  input: int
  output:
*/
//This is the main use function, all the previous use function will call
//this function with the correct integer value.  However, if you know which
//integer goes with which widget then you can call this right away.
void Panel::UseWidget(const std::string& widget)
{
  
  //Set the class variable m_widgetType to the widget that is being used
  m_widgetType = widget;

  //Clear the ObjectEntryTable just in case the user changed the widget,
  //to a widget that does not use the object entries.
  ObjectEntryTable.clear();

  //Grab the children and parent of the old widget so that we 
  //can add them to the new widget.
  vtkSynchronizedView *tempParent = NULL;
  std::vector < vtkSynchronizedView* > tempChildren;
  if(m_widget) {
    
    //Get the Parent and place it into the tempParent
    tempParent=this->m_widget->GetParent();
    tempChildren=this->m_widget->GetChildren();
    
    //m_widget->clClear();
    m_widget->Detach();
    m_widget->Delete();
    m_widget = NULL;
    //wxView->Delete();
    wxView = NULL;
  }

  //if(  widget == INVERSE_CONSISTENCY_TEXT ||
  //     widget == RELATIVE_OVERLAP_TEXT ||
  //     widget == INTENSITY_VARIANCE_TEXT ||
  //     widget == TRANSITIVITY_ERROR_TEXT ||
  //     widget == VARIANCE_TRANSFORM_TEXT ||
  //     widget == VARIANCE_IMAGE_TEXT)
  if(  widget.compare(WidgetCmd["relativeOverlapTextWidget"])    == 0 ||
       widget.compare(WidgetCmd["intensityVarianceTextWidget"])  == 0 ||
       widget.compare(WidgetCmd["inverseConsistencyTextWidget"]) == 0 ||
       widget.compare(WidgetCmd["transitivityErrorTextWidget"])  == 0 ||
       widget.compare(WidgetCmd["varianceTransformText"])        == 0 ||
       widget.compare(WidgetCmd["varianceImageText"])            == 0)
  {
    //wxSizer* m_flexGridSizer = this->GetSizer();
    if(wxView!=NULL) {
      m_flexGridSizer->Detach(wxView);
      //m_flexGridSizer->Remove(wxView);
      
      wxView->Delete();
      wxView = NULL;
    }
    if(m_richTextController != NULL)
      delete m_richTextController;
    m_richTextController = new wxRichTextCtrl( this, wxID_ANY, _T(""), wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL );
    m_flexGridSizer->Add(m_richTextController,1, wxALL|wxEXPAND|wxGROW, 0);
    m_flexGridSizer->Layout();
    
    
    NIREPStatistics* stats = NULL;
    TextTable textTable;  // this is what will be returned
    //if(widget == INVERSE_CONSISTENCY_TEXT) {
    if(widget.compare(WidgetCmd["inverseConsistencyTextWidget"]) == 0) {
      if(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL ) {
        return;
      }
      ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
      stats = new NIREPInverseConsistencyError(evaluator);
      textTable = stats->ComputeStatistic(this->ids, m_displayDescription);
    }
    //else if(widget == RELATIVE_OVERLAP_TEXT) {
    else if(widget.compare(WidgetCmd["relativeOverlapTextWidget"]) == 0) {
      if(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL ) {
        return;
      }
      ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription)->GetObjectEntryTable());
      stats = new NIREPRelativeOverlap(evaluator);
      textTable = stats->ComputeStatistic(this->ids, m_displayDescription);
    }
    //else if(widget == INTENSITY_VARIANCE_TEXT) {
    else if(widget.compare(WidgetCmd["intensityVarianceTextWidget"]) == 0) {
      if(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL ) {
        return;
      }
      ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription)->GetObjectEntryTable());
      //textStatTable = stats.ComputeIV(this->ids);
    }
    //else if(widget == TRANSITIVITY_ERROR_TEXT) {
    else if(widget.compare(WidgetCmd["transitivityErrorTextWidget"]) == 0) {
      if(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL ) {
        return;
      }
      ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
      stats = new NIREPTransitivityError(evaluator);
      textTable = stats->ComputeStatistic(this->ids, m_displayDescription);
    }
    //else if(widget == VARIANCE_TRANSFORM_TEXT) {
    else if(widget.compare(WidgetCmd["varianceTransformText"]) == 0) {
      stats = new NIREPIntensityVariance(evaluator);
      this->ids.insert(this->ids.begin(),"RegisteredImageVariance");
      textTable = stats->ComputeStatistic(this->ids, m_displayDescription);
    }
    //else if(widget == VARIANCE_IMAGE_TEXT) {
    else if(widget.compare(WidgetCmd["varianceImageText"]) == 0) {
      stats = new NIREPIntensityVariance(evaluator);
      this->ids.insert(this->ids.begin(),"ImageVariance");
      textTable = stats->ComputeStatistic(this->ids, m_displayDescription);
    }

    if(stats != NULL) {
      delete stats;  // Not needed anymore beyond this point
      stats = NULL;
    }

    wxArrayInt tabs;
    tabs.Add(200);
    tabs.Add(600);
    for(int i=1; i<textTable.ColumnHeading.size();i++) {
       tabs.Add(600+200*i);
    }
    wxTextAttrEx attr;
    attr.SetFlags(wxTEXT_ATTR_TABS);
    attr.SetTabs(tabs);
    m_richTextController->SetDefaultStyle(attr);


    m_richTextController->WriteText( wxString(textTable.Title.c_str(), wxConvUTF8) );
    m_richTextController->Newline();
    for(int i=0; i< textTable.ColumnHeading.size(); i++) {
      m_richTextController->WriteText(wxT("\t") + wxString(textTable.ColumnHeading.at(i).c_str(), wxConvUTF8));
    }
    m_richTextController->Newline();

    if(!ObjectEntryTable.empty()) {
      for(int i=0;i<ObjectEntryTable.size();i++) {
        m_richTextController->WriteText(wxString::Format(wxT("%d"), i));
        m_richTextController->WriteText(wxT("\t")); 
        m_richTextController->WriteText(wxString( ObjectEntryTable.at(i)->GetName().c_str(), wxConvUTF8 ));
        m_richTextController->WriteText(wxT("\t")); 
        for(int j=0;j<textTable.ColumnHeading.size()-1;j++) {
          * m_richTextController << textTable.Value[j][i];
          m_richTextController->WriteText(wxT("\t")); 
        }
        m_richTextController->Newline();
      }
    }
    else if(!textTable.Value.empty()) {
      for(int i=0; i<textTable.Value[0].size();i++) {
        for(int j=0;j<textTable.ColumnHeading.size();j++) {
          * m_richTextController << textTable.Value[j][i];
          m_richTextController->WriteText(wxT("\t")); 
        }
        m_richTextController->Newline();
      }
    }
    return;
  }
  else if(wxView == NULL)
  {
    if(m_richTextController != NULL)
    {
      m_flexGridSizer->Remove(0);
      delete m_richTextController;
      m_richTextController = NULL;
    }
    //Create the vtkRenderWindow and partial interactor.  This is still not
    //the view, this is just the RenderWindow which will need to be used
    //to display the different views.
    wxView = new NIREPwxVTKRenderWindowInteractor(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE, wxT("")); 

    //Add the RenderWindow to the panel
    m_flexGridSizer->Add(wxView, 1, wxALL|wxEXPAND|wxGROW, 0);
    m_flexGridSizer->Layout();
  }

  //Ok the following code is thrown together.  I need to through and clean it up.
  //So the gist of what is happening:

  //Create the NIREPvtkInteractorStyleImage2D, which is going to be called the interactorStyle.
  //We pass the panel to the interactorStyle so that the interactorStyle can call the panel
  //if the user right clicks.  The right click will pop up a menu for the user to make 
  //some changes or bring up more windows to make more changes.

  NIREPvtkInteractorStyleImage2D *interactorStyle = NIREPvtkInteractorStyleImage2D::New();
  interactorStyle->SetPanel(this);
    
  //Create a NIREPvtkViewImage2DCommand.  This will be used to funnel
  //off the different actions that happen.
  NIREPvtkViewImage2DCommand *cbk = NIREPvtkViewImage2DCommand::New();  
  
  //Add a bunch of observers to the interactorStyle.
  //The first part will take care of normal vtk commands.
  interactorStyle->AddObserver(vtkCommand::KeyPressEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::WindowLevelEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::StartWindowLevelEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::ResetWindowLevelEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::PickEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::StartPickEvent, cbk);
  interactorStyle->AddObserver(vtkCommand::EndPickEvent, cbk);

  //This second part will take care of the other commands that
  //deal with the vtkInria3D items.  
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::ResetZoomEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::ResetPositionEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::StartZSliceMoveEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::ZSliceMoveEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::EndZSliceMoveEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::StartMeasureEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::MeasureEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::EndMeasureEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::FullPageEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::ZoomEvent, cbk);
  interactorStyle->AddObserver(NIREPvtkViewImage2DCommand::DefaultMoveEvent, cbk);
    
  //Create a renderer.
  vtkRenderer* rend = vtkRenderer::New();

  //Figure out which widget should be used.
  //if(widget == BLANK_WIDGET) {
  if(widget.compare(WidgetCmd["blankWidget"]) == 0) {
    m_widget = NIREPvtkViewImage2D::New();
    m_widget->SetConventionsToNeurological();
    m_widget->SetOrientation(this->m_orientation);
    m_widget->SetLookupTable(PanelLookupTable);
    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    return;
  }
  //else if(widget == IMAGE_WIDGET) {
  else if(widget.compare(WidgetCmd["view"]) == 0) {
    m_widget = NIREPvtkViewImage2D::New();
    //m_widget->SetConventionsToNeurological();
    m_widget->SetConventionsToRadiological();
    m_widget->SetOrientation(this->m_orientation);
    if(m_lookupTableSelection != OTHER )
    {
      vtkLookupTableManager *tempTwo = vtkLookupTableManager::New();
      vtkLookupTable *temp = tempTwo->GetLookupTable(m_lookupTableSelection);
      // = vtkLookupTableManager::GetLookupTable(colorMapChoice);
      //panel->SetLookUpTable(temp,colorMapChoice);
      m_widget->SetLookupTable(temp);
      temp->Delete();
      tempTwo->Delete();
    }

    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    m_widget->SetRenderer (rend);
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    
    
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    m_widget->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
    m_widget->GetScalarBar()->SetInteractor(m_widget->GetRenderWindowInteractor());

    m_widget->SetShow2DAxis(0);
  }
  //else if(widget == CHECKERBOARD_WIDGET) {
  else if(widget.compare(WidgetCmd["checkerboard"]) == 0) {
    Checkerboard *tempThree = Checkerboard::New();

    //tempThree->SetConventionsToRadiological(); GEC Switching to radiological had no effect
    tempThree->SetConventionsToNeurological();

    tempThree->SetOrientation(this->m_orientation);
    tempThree->SetLookupTable(PanelLookupTable);
    cbk->SetView(tempThree);
    interactorStyle->SetView(tempThree);
    tempThree->SetRenderWindow (wxView->GetRenderWindow());
    tempThree->SetRenderer (rend);
    tempThree->ScalarBarVisibilityOn();
    tempThree->SetLinkZoom (true);
    tempThree->SetLinkCameraFocalAndPosition(true);
    tempThree->SetBackgroundColor (0.0,0.0,0.0);
    tempThree->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    tempThree->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    tempThree->SetSecondImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
    tempThree->GetScalarBar()->SetInteractor(tempThree->GetRenderWindowInteractor());


    m_widget = tempThree;
  }
  //else if(widget == WIPE_WIDGET) {
  else if(widget.compare(WidgetCmd["wipe"]) == 0) {
    Wipe *tempTwo = Wipe::New();
    
    //tempTwo->SetConventionsToRadiological();  GEC Switching to radiological had no effect
    tempTwo->SetConventionsToNeurological();

    tempTwo->SetOrientation(this->m_orientation);
    tempTwo->SetLookupTable(PanelLookupTable);
    cbk->SetView(tempTwo);
    interactorStyle->SetView(tempTwo);
    tempTwo->SetRenderWindow (wxView->GetRenderWindow());
    tempTwo->SetRenderer (rend);
    //wxView->Render();   GEC 7/10/2010 removed to prevent wipe window from appearing in wrong window
    //wxView->GetRenderWindow()->Render(); GEC 7/10/2010 removed to prevent wipe window from appearing in wrong window
    tempTwo->ScalarBarVisibilityOn();
    tempTwo->SetLinkZoom (true);
    tempTwo->SetLinkCameraFocalAndPosition(true);
    tempTwo->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    tempTwo->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    tempTwo->SetSecondImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
    tempTwo->SetBackgroundColor (0.0,0.0,0.0);
    tempTwo->GetScalarBar()->SetInteractor(tempTwo->GetRenderWindowInteractor());
    m_widget = tempTwo;
  }
  //else if(widget == OVERLAY_IMAGE_WIDGET) {
  else if(widget.compare(WidgetCmd["overlayImage"]) == 0) {
    m_widget = NIREPvtkViewImage2D::New();
    m_widget->SetConventionsToNeurological();
    m_widget->SetOrientation(this->m_orientation);
    m_widget->SetLookupTable(PanelLookupTable);
    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    m_widget->SetRenderer (rend);
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    m_widget->SetImage( (this->evaluator->GetImage(this,this->ids[0], m_displayDescription)) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    m_widget->SetOverlappingImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
    m_widget->GetScalarBar()->SetInteractor(m_widget->GetRenderWindowInteractor());
  }
  else if(m_widgetType.compare(WidgetCmd["vectorField"]) == 0) {
    VectorField *tempTwo = VectorField::New();
    tempTwo->SetConventionsToNeurological();
    tempTwo->SetOrientation(this->m_orientation);
    tempTwo->SetLookupTable(PanelLookupTable);
    cbk->SetView(tempTwo);
    interactorStyle->SetView(tempTwo);
    tempTwo->SetRenderWindow (wxView->GetRenderWindow());
    tempTwo->SetRenderer (rend);
    tempTwo->ScalarBarVisibilityOn();
    tempTwo->SetLinkZoom (true);
    tempTwo->SetLinkCameraFocalAndPosition(true);
    tempTwo->SetBackgroundColor (0.0,0.0,0.0);
    tempTwo->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    tempTwo->SetImage( (this->evaluator->GetImage(this,this->ids[0], m_displayDescription)) );
    m_widget = tempTwo;
  }

  //this begins the object map portion of the widgets
  //else if(widget == OVERLAY_OBJECTMAP_WIDGET) {
  else if(widget.compare(WidgetCmd["overlayObjectMap"]) == 0) {
    m_widget = NIREPvtkViewImage2D::New();
    m_widget->SetConventionsToNeurological();
    m_widget->SetOrientation(this->m_orientation);
    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    m_widget->SetRenderer (rend);
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    m_widget->SetImage( (this->evaluator->GetImage(this,this->ids[0], m_displayDescription)) );
    if( this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();

    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    m_widget->SetMaskImage((this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription))->GetVTKData() ,lut );
    m_widget->GetScalarBar()->SetInteractor(m_widget->GetRenderWindowInteractor());
  }
  //else if(widget == RELATIVE_OVERLAP) {
  else if(widget.compare(WidgetCmd["relativeOverlap"]) == 0) {
    RelativeOverlap *relativeOverlap = RelativeOverlap::New();
    m_widget = NIREPvtkViewImage2D::New();
    m_widget->SetConventionsToNeurological();
    m_widget->SetOrientation(this->m_orientation);
    m_widget->SetLookupTable(PanelLookupTable);
    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    m_widget->SetRenderer (rend);
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    relativeOverlap->SetInput1( (this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription))->GetVTKData() );
    if( this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();

    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    m_widget->SetLookupTable(lut);
    relativeOverlap->SetInput2((this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription))->GetVTKData() );
    relativeOverlap->Update();
    m_widget->SetImage(relativeOverlap->GetOutput());
    m_widget->GetScalarBar()->SetInteractor(m_widget->GetRenderWindowInteractor());
    relativeOverlap->Delete();
  }
  //else if(widget == OBJECTMAP_WIDGET) {
  else if(widget.compare(WidgetCmd["objectmap"]) == 0) {
    m_widget = NIREPvtkViewImage2D::New();
    m_widget->SetConventionsToNeurological();
    m_widget->SetOrientation(this->m_orientation);
    cbk->SetView(m_widget);
    interactorStyle->SetView(m_widget);
    m_widget->SetRenderWindow (wxView->GetRenderWindow());
    m_widget->SetRenderer (rend);
    m_widget->ScalarBarVisibilityOn();
    m_widget->SetLinkZoom (true);
    m_widget->SetLinkCameraFocalAndPosition(true);
    m_widget->SetBackgroundColor (0.0,0.0,0.0);
    m_widget->SetInteractionStyle (NIREPvtkViewImage2D::SELECT_INTERACTION);
    if( this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();

    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    m_widget->SetLookupTable(lut);
    m_widget->SetImage((this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription))->GetVTKData() );
    m_widget->GetScalarBar()->SetInteractor(m_widget->GetRenderWindowInteractor());
    
  }
  rend->Delete();
  m_widget->GetRenderWindowInteractor()->SetInteractorStyle(interactorStyle);
  cbk->Delete();
  interactorStyle->Delete();
  m_widget->ResetCurrentPoint();
  m_widget->SetResetWindowLevelModeToFullRange();
  m_widget->ResetWindowLevel();

  //I think I was trying to set up the widgets to be connected so that they
  //update together.
  if(tempParent) {
    tempParent->AddChild(m_widget);
  }
  if(!tempChildren.empty()){
    this->m_widget->AddChildren(tempChildren);
  }

  int* dataDim = m_widget->GetImage()->GetDimensions();
  wxSize tempSize;
  tempSize.SetHeight(dataDim[0]);
  tempSize.SetWidth(dataDim[1]);
  this->SetMinSize(tempSize);
  m_widget->SetVisibility(1);
  //this->Render();
}

//--------------------------------------------End of Use----------------------


/*
  function: SetIds
  purpose:  
  input: std::string d
  output:
*/
//This function stores the ids of the images that are being
//displayed.  This way we can send these ids to the evaluator
//and get back the correct images.
void Panel::SetIds(const std::string& d)
{
  ids.push_back(d);
}

/*
  function: GetIds
  purpose:  
  input:
  output: std::vector<std::string>0
*/
std::vector<std::string> Panel::GetIds()
{
  return ids;
}

/*
  function: ClearIds
  purpose:  
  input: std::string id
  output:
*/
void Panel::ClearIds(const std::string& id)
{
  if(!id.compare("")) {
    ids.clear();
  }
  else {
    std::vector<std::string>::iterator iteratorTwo = this->ids.begin();;
    for(int i =0; i< ids.size();i++) {
      if(ids[i].compare(id)) {
        this->ids.erase(iteratorTwo); 
        return;
      }
      iteratorTwo++;
    }
  }
}

/*
  function: UpdatePanel
  purpose:  
  input:
  output:
*/
void Panel::UpdatePanel()
{
  if(!m_widget) {
    return;
  }

  //if(m_widgetType == IMAGE_WIDGET) {
  if(m_widgetType.compare(WidgetCmd["view"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
  }
  //else if(m_widgetType == CHECKERBOARD_WIDGET) {
  else if(m_widgetType.compare(WidgetCmd["checkerboard"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((Checkerboard*)(this->m_widget))->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ((Checkerboard*)(this->m_widget))->SetSecondImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );    
  }
  //else if(m_widgetType == WIPE_WIDGET) {
  else if(m_widgetType.compare(WidgetCmd["wipe"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((Wipe*)(this->m_widget))->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ((Wipe*)(this->m_widget))->SetSecondImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
  }
  //else if(m_widgetType == OVERLAY_IMAGE_WIDGET) {
  else if(m_widgetType.compare(WidgetCmd["checkerboard"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetImage( (this->evaluator->GetImage(this,this->ids[0], m_displayDescription)) );
    if( this->evaluator->GetImage(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetOverlappingImage( (this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
  }

  //this begins the object map portion of the widgets
  //else if(m_widgetType == OVERLAY_OBJECTMAP_WIDGET) {
  else if(m_widgetType.compare(WidgetCmd["overlayObjectMap"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetImage( (this->evaluator->GetImage(this,this->ids[0], m_displayDescription)) );
    if( this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();

    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetMaskImage((this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription))->GetVTKData() ,lut );
  }
  //else if(m_widgetType == RELATIVE_OVERLAP) {
  else if(m_widgetType.compare(WidgetCmd["relativeOverlap"]) == 0) {
    RelativeOverlap *relativeOverlap = RelativeOverlap::New();
    if( this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    relativeOverlap->SetInput1( (this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription))->GetVTKData() );
    if( this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();
    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetLookupTable(lut);
    relativeOverlap->SetInput2((this->evaluator->GetObjectMap(this,this->ids[1], m_displayDescription))->GetVTKData() );
    relativeOverlap->Update();
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetImage(relativeOverlap->GetOutput());
    relativeOverlap->Delete();
  }
  //else if(m_widgetType == OBJECTMAP_WIDGET) {
  else if(m_widgetType.compare(WidgetCmd["objectmap"]) == 0) {
    if( this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ObjectEntryTable = *(this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription)->GetObjectEntryTable());
    vtkLookupTable* lut = vtkLookupTable::New();
    lut->SetNumberOfTableValues(ObjectEntryTable.size());
    lut->Build();
    for(int i=0;i<ObjectEntryTable.size();i++) {
      if(ObjectEntryTable.at(i)->GetDisplayFlag() != 0)
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), (double)ObjectEntryTable.at(i)->GetOpacity());
      else
        lut->SetTableValue(i, (double)ObjectEntryTable.at(i)->GetEndRed(), (double)ObjectEntryTable.at(i)->GetEndGreen(), (double)ObjectEntryTable.at(i)->GetEndBlue(), 0);
    }

    if(PanelLookupTable)
      PanelLookupTable->Delete();

    PanelLookupTable = lut;
    m_lookupTableSelection = OTHER;
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetLookupTable(lut);
    ((NIREPvtkViewImage2D*)(this->m_widget))->SetImage((this->evaluator->GetObjectMap(this,this->ids[0], m_displayDescription))->GetVTKData() );
  }
  else if(m_widgetType.compare(WidgetCmd["vectorField"]) == 0) {
    if( this->evaluator->GetImage(this,this->ids[0], m_displayDescription) == NULL) {
      return;
    }
    ((VectorField*)(this->m_widget))->SetImage(this->evaluator->GetImage(this,this->ids[0], m_displayDescription) );
  }
  this->m_widget->Render();
}

/*
  function: Render
  purpose:  
  input:
  output:
*/
void Panel::Render()
{
  wxView->Modified();
  wxView->Render();
  this->Refresh();
}

/*
  function: GetRenderWindow
  purpose:  
  input:
  output: vtkRenderWindow*
*/
vtkRenderWindow* Panel::GetRenderWindow()
{
  return wxView->GetRenderWindow();
}

/*
  function: GetView
  purpose:  
  input:
  output: NIREPvtkViewImage2D*
*/
NIREPvtkViewImage2D* Panel::GetView()
{
  return m_widget;
}

/*
  function: PanelFrame
  purpose:  
  input: wxCommandEvent &
  output:
*/
//This function creates the window that lets the user
//modify this panel
void Panel::PanelFrame(wxCommandEvent &event)
{
  //Now for the fun.  Need to create a form to change this panel.
  PanelForm *panelForm = new PanelForm(this,wxID_ANY);
  panelForm->Show();
  panelForm->Layout();
}

/*
  function: ObjectMapForm
  purpose:  
  input: wxCommandEvent &
  output:
*/
void Panel::ObjectMapForm(wxCommandEvent &event)
{
  //Now for the fun.  Need to create a form to change the object map.
  ObjectmapForm *objectmapForm = new ObjectmapForm(this,wxID_ANY);
  objectmapForm->SetPanel(this);
  objectmapForm->Show();
  objectmapForm->Layout();
}

/*
  function: RightClick
  purpose:  
  input: int x
         int y
  output:
*/
//Display to the user the different options
//that they can do to the view and panel
void Panel::RightClick(int x, int y)
{
  TreePopupMenu = new wxMenu;
  wxMenu *wxmenu = new wxMenu;
  TreePopupMenu->Append(ID_POPUP, wxT("Edit m_widget"));
  wxmenu->Append(ID_POPUPTHREE,wxT("Pointer"));
  wxmenu->Append(ID_POPUPFOUR,wxT("Level/Window"));
  wxmenu->Append(ID_POPUPFIVE,wxT("Zoom"));
  TreePopupMenu->Append(ID_POPUPTWO, wxT("Left Click"),wxmenu);
  TreePopupMenu->Append(ID_POPUPSIX,wxT("Flip Image"));
  if(!ObjectEntryTable.empty())
    TreePopupMenu->Append(ID_POPUPSEVEN,wxT("Object Map"));
  this->PopupMenu(TreePopupMenu);
  delete TreePopupMenu;
  TreePopupMenu = NULL;
}

/*
  function:
  purpose:  
  input:
  output:
*/
void Panel::Delete()
{
  parent->DeleteWidget(id);
}

/*
  function: Mouse
  purpose:  
  input: wxCommandEvent&
  output:
*/
//Figure out what the user picked from the popup
void Panel::Mouse(wxCommandEvent &event)
{
  if(event.GetId()==ID_POPUPTHREE) {
    mouse = 0;
    this->m_widget->SetInteractionStyle(NIREPvtkViewImage2D::SELECT_INTERACTION);
  }
  else if(event.GetId()==ID_POPUPFOUR) {
    mouse = 1;
    this->m_widget->SetInteractionStyle(NIREPvtkViewImage2D::WINDOW_LEVEL_INTERACTION);
  }
  else if(event.GetId()==ID_POPUPFIVE) {
    mouse = 2;
    this->m_widget->SetInteractionStyle(NIREPvtkViewImage2D::ZOOM_INTERACTION);
  }
}

/*
  function: Flip
  purpose:  
  input: wxCommandEvent&
  output:
*/
//Todo:
//Make this work, here is the code from the interactor, so it should be easy to modify.
void Panel::Flip(wxCommandEvent& event)
{
    //if(m_widgetType == OVERLAY_OBJECTMAP_WIDGET) {
    if(m_widgetType.compare(WidgetCmd["overlayObjectMap"])) {
//      vtkErrorMacro("Can not flip overlay object maps right now.");
      return;
    }
    wxVtkImageFlip* myflipper = new wxVtkImageFlip (this, -1,
                                                    wxT("Radiologic conventions"),
                                                    wxDefaultPosition,
                                                    wxSize(400,400));
    
    myflipper->SetImage (m_widget->GetImage());
    int OK = myflipper->ShowModal();
    if (OK == wxID_OK ) {
      m_widget->SetImage(myflipper->GetOutput());
    }
    //if(m_widgetType == CHECKERBOARD_WIDGET) {
    if(m_widgetType.compare(WidgetCmd["checkerboard"])) {
      myflipper->SetImage (((Checkerboard*)m_widget)->GetSecondImage());
      ((Checkerboard*)m_widget)->SetSecondImage(myflipper->GetOutput());
    }
    //else if(m_widgetType == OVERLAY_OBJECTMAP_WIDGET) {
    else if(m_widgetType.compare(WidgetCmd["overlayObjectMap"])) {
      vtkImageFlip *flip = vtkImageFlip::New();
      flip->SetInput((this->evaluator->GetImage(this,this->ids[1], m_displayDescription)) );
      flip->SetFilteredAxes(1);
      flip->Update();
      myflipper->SetImage (flip->GetOutput());
      myflipper->Update();
      m_widget->SetMaskImage(myflipper->GetOutput(),this->GetLookUpTable());
      flip->Delete();
    }
    myflipper->Destroy();
    this->m_widget->Render();
}

/*
  function: BlendImages
  purpose:  
  input:
  output:
*/
void Panel::BlendImages()
{
  //blender->SetLookupTable(this->GetLookUpTable());
  //blender->Modified();
 // blender->Update();
  //m_widget->SetImage(blender->GetOutput());
  m_widget->SetMaskImage(m_widget->GetMaskImage(),this->GetLookUpTable());
}

/*
  function: GetObjectEntries
  purpose:  
  input:
  output: gec::ObjectMap::ObjectEntryTable&
*/
itk::AnalyzeObjectEntryArrayType * Panel::GetObjectEntries()
{
  return &ObjectEntryTable;
}

/*
  function:  CheckImage
  purpose:  
  input: gec::Image *
  output: bool
*/
bool Panel::CheckImage(gec::Image *image)
{
  if(image == NULL) {
    return false;
  }
  return true;
}

void Panel::SetCursorLocation(int x, int y)
{
  if(this->m_widget != NULL) {
    double  *temp = new double[2]();
    temp[0] = x;
    temp[1] = y;
    this->m_widget->SyncSetCurrentPoint(temp);
  }
}

void Panel::SetSlice(int s)
{
  if(this->m_widget != NULL)
    this->m_widget->SyncSetSlice(this->GetOrientation(), s);
}