wxSurfaceMPR.cxx

Go to the documentation of this file.

#include <vtkPlanes.h>
#include <vtkProperty.h> 
#include <vtkPolyData.h> 
#include <vtkDataSet.h> 

#include "wxSurfaceMPR.h"
#include <wx/colordlg.h>



//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------

/*


void boxVolumeObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) {  // virtual
        if (eventId==vtkCommand::StartInteractionEvent){
                _renWin->SetDesiredUpdateRate(10);
        }
        if (eventId==vtkCommand::InteractionEvent){
                _renWin->SetDesiredUpdateRate(0.001);
        }
        if (eventId==vtkCommand::EndInteractionEvent){
                vtkPlanes *planes = vtkPlanes::New();
                vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
                boxwidget->GetPlanes(planes);
                _volumeMapper->SetClippingPlanes(planes);
                planes -> Delete();
        }
}
//-------------------------------------------------------------------
void boxVolumeObserver::SetRenWin( vtkRenderWindow *renWin ){
        _renWin = renWin;
}
//-------------------------------------------------------------------
void boxVolumeObserver::SetVolumeMapper(vtkVolumeRayCastMapper *volumeMapper){
        _volumeMapper = volumeMapper;
}


//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------

void boxSurfaceObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) {  // virtual
        vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
        boxwidget->GetPlanes(_planes);
        _actor->VisibilityOn();
}
//-------------------------------------------------------------------
void boxSurfaceObserver::SetPlanes(vtkPlanes *planes){
        _planes = planes;
}
//-------------------------------------------------------------------
void boxSurfaceObserver::SetActor(vtkActor *actor){
        _actor = actor;
}

*/

//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------


/*
vtkMPR3DData::vtkMPR3DData()
{
        _colour[0]= new wxColour(255,127, 64);
        _colour[1]= new wxColour(255,255,250);
        _colour[2]= new wxColour(  0,255,000);
        _colour[3]= new wxColour(  0,  0,255);
        _visiblePosition[0]=true;
        _visiblePosition[1]=true;
        _visiblePosition[2]=true;
}
//-------------------------------------------------------------------
vtkMPR3DData::~vtkMPR3DData()
{
        int i;
        for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
                _tissueExtractor[i]             ->Delete();
                _tissueNormals[i]               ->Delete();
                _tissueStripper[i]              ->Delete();
                _tissueMapper[i]                ->Delete();
                delete _colour[i];
                _tissuePlanes[i]                ->Delete();
                _tissueClipper[i]               ->Delete();
        }
        _outlineData            ->Delete();
        _mapOutline                     ->Delete();
        _outline                        ->Delete();

        // Volume
        _tfun                           ->Delete();
        _ctfun                          ->Delete();
        _compositeFunction      ->Delete();
        _volumeMapper           ->Delete();
        _volumeProperty         ->Delete();
        _newvol                         ->Delete();
}
//-------------------------------------------------------------------
vtkActor* vtkMPR3DData::GetOutlineActor()
{
        return _outline;
}
//-------------------------------------------------------------------
vtkPolyDataMapper* vtkMPR3DData::GetTissueMapper(int id)
{
        return _tissueMapper[id];
}
//-------------------------------------------------------------------
vtkPlanes* vtkMPR3DData::GetTissuePlanes(int id)
{
        return _tissuePlanes[id];
}
//-------------------------------------------------------------------
vtkStripper* vtkMPR3DData::GetTissueStripper(int id)
{
        return _tissueStripper[id];
}
//-------------------------------------------------------------------
vtkImageActor* vtkMPR3DData::GetImageActor(int id)
{
        vtkImageActor *tmpVtkActor=NULL;
        if (id==0){
                tmpVtkActor = GetvtkActor_saggital();
        }
        if (id==1){
                tmpVtkActor = GetvtkActor_coronal();
        }
        if (id==2){
                tmpVtkActor = GetvtkActor_axial();
        }
        return tmpVtkActor;
}
//-------------------------------------------------------------------
void vtkMPR3DData::Configure()
{
        int i;

        for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){

                _tissueExtractor[i] = vtkContourFilter::New();
                _tissueExtractor[i]->SetInput((vtkDataSet *) GetImageData() );
                _tissueExtractor[i]->SetValue(0, 0);
            _tissueNormals[i] = vtkPolyDataNormals::New();
                _tissueNormals[i]->SetInput(_tissueExtractor[i]->GetOutput());
                _tissueNormals[i]->SetFeatureAngle(60.0);
                _tissueStripper[i] = vtkStripper::New();
                _tissueStripper[i]->SetInput(_tissueNormals[i]->GetOutput());

                if (i==0){
                        _tissuePlanes[i]  = vtkPlanes::New();
                        _tissueClipper[i] = vtkClipPolyData::New();
                        _tissueClipper[i]->SetInput( _tissueStripper[i]->GetOutput() );
                        _tissueClipper[i]->SetClipFunction( _tissuePlanes[i] );
                        _tissueClipper[i]->InsideOutOn( );

                        _tissueMapper[i] = vtkPolyDataMapper::New();
                        _tissueMapper[i]->SetInput( _tissueClipper[i]->GetOutput() );
                } else {
                        _tissueMapper[i] = vtkPolyDataMapper::New();
                        _tissueMapper[i]->SetInput(_tissueStripper[i]->GetOutput());
//                      _tissueMapper[i]->ScalarVisibilityOff();

                }

        }



  // An outline provides context around the data.
  //
        _outlineData = vtkOutlineFilter::New();
    _outlineData->SetInput((vtkDataSet *) GetImageData() );
        _mapOutline = vtkPolyDataMapper::New();
    _mapOutline->SetInput(_outlineData->GetOutput());
        _outline = vtkActor::New();
    _outline->SetMapper(_mapOutline);
    _outline->GetProperty()->SetColor(0,0,0);

  // Now we are creating three orthogonal planes passing through the
  // volume. Each plane uses a different texture map and therefore has
  // diferent coloration.


  // Volume
  _tfun = vtkPiecewiseFunction::New();

//      _tfun->AddPoint(70.0, 0.0);
//      _tfun->AddPoint(599.0, 0);
//      _tfun->AddPoint(600.0, 0);
//      _tfun->AddPoint(1195.0, 0);
//      _tfun->AddPoint(1200, .2);
//      _tfun->AddPoint(1300, .3);
//      _tfun->AddPoint(2000, .3);
//      _tfun->AddPoint(4095.0, 1.0);

        _tfun->AddPoint(70      , 0.0);
        _tfun->AddPoint(599     , 0.0);
        _tfun->AddPoint(600     , 0.0);
        _tfun->AddPoint(1110, 0.0);
        _tfun->AddPoint(1111, 1.0);
        _tfun->AddPoint(1300, 1.0);
        _tfun->AddPoint(2000, 1.0);
        _tfun->AddPoint(4095, 1.0);

  _ctfun = vtkColorTransferFunction::New();

//    _ctfun->AddRGBPoint(0.0, 0.5, 0.0, 0.0);
//      _ctfun->AddRGBPoint(600.0, 1.0, 0.5, 0.5);
//      _ctfun->AddRGBPoint(1280.0, 0.9, 0.2, 0.3);
//      _ctfun->AddRGBPoint(1960.0, 0.81, 0.27, 0.1);
//      _ctfun->AddRGBPoint(4095.0, 0.5, 0.5, 0.5);

        _ctfun->AddRGBPoint(0.0         , 0.5   , 0.0   , 0.0 );
        _ctfun->AddRGBPoint(600.0       , 1.0   , 0.5   , 0.5 );
        _ctfun->AddRGBPoint(1130.0      , 0.9   , 0.2   , 0.3 );
        _ctfun->AddRGBPoint(1131.0      , 0.3   , 0.9   , 0.9 );
        _ctfun->AddRGBPoint(1135.0      , 0.3   , 0.8   , 0.8 );
        _ctfun->AddRGBPoint(1960.0      , 0.1   , 0.27  , 0.71);
        _ctfun->AddRGBPoint(4095.0      , 0.5   , 0.5   , 0.5 );

  _compositeFunction = vtkVolumeRayCastCompositeFunction::New();
  
  _volumeMapper = vtkVolumeRayCastMapper::New();
        _volumeMapper->SetInput( GetImageData() );
        _volumeMapper->SetVolumeRayCastFunction(_compositeFunction);

  _volumeProperty = vtkVolumeProperty::New();
        _volumeProperty->SetColor(_ctfun);
        _volumeProperty->SetScalarOpacity(_tfun);
        _volumeProperty->SetInterpolationTypeToLinear();
        _volumeProperty->ShadeOn();

  _newvol = vtkVolume::New();
        _newvol->SetMapper(_volumeMapper);
        _newvol->SetProperty(_volumeProperty);

        vtkMPRBaseData::Configure();

}


//-------------------------------------------------------------------
void vtkMPR3DData::SetIsovalue(int idTissue, int isoValue)
{
        _tissueExtractor[idTissue]->SetValue(0, isoValue);
}

//-------------------------------------------------------------------
wxColour* vtkMPR3DData::GetColour(int idColour)
{
        return _colour[idColour];
}
//-------------------------------------------------------------------
void vtkMPR3DData::SetVisiblePosition(int idPosition, bool visible)
{
        _visiblePosition[idPosition]=visible;
}
//-------------------------------------------------------------------
bool vtkMPR3DData::GetVisiblePosition(int idPosition)
{
        return _visiblePosition[idPosition];
}
//-------------------------------------------------------------------
vtkVolume* vtkMPR3DData::GetVolumeActor()
{
   return _newvol;
}
//-------------------------------------------------------------------
vtkVolumeRayCastMapper* vtkMPR3DData::GetVolumeMapper(){
        return _volumeMapper;
}

*/

//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------

/*

wxVtkMPR3DView::wxVtkMPR3DView(wxWindow *parent)
:wxVtk3DBaseView( parent )
{
        int i;
        for (i=0; i<VTKMPRDATA_MAXTISSUE; i++){
                _visibleTissue[i]=true;
        }
        _visibleVolume=true;

}

//-------------------------------------------------------------------
wxVtkMPR3DView::~wxVtkMPR3DView(){
        int i;
        for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
                _tissue[i]->Delete();
        }

        _boxWidget              -> Delete();
        _observerV              -> Delete();
        _boxWidgetS1    -> Delete();
        _observerS1             -> Delete();

}
//-------------------------------------------------------------------
void wxVtkMPR3DView::SetVisibleTissue(int idTissue, bool visible){
        _visibleTissue[idTissue]=visible;
}
//-------------------------------------------------------------------
bool wxVtkMPR3DView::GetVisibleTissue(int idTissue){
        return _visibleTissue[idTissue];
}
//-------------------------------------------------------------------
vtkActor* wxVtkMPR3DView::GetTissueActor(int id){
        return _tissue[id];
}
//-------------------------------------------------------------------
void wxVtkMPR3DView::Configure(){
        vtkMPR3DData *vtkmpr3Ddata = (vtkMPR3DData*)GetVtkmprbasedata();
        wxVtk3DBaseView::Configure();
        // vtkActor tissue
        int i;
        for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
                // tissue
                _tissue[i] = vtkActor::New();
                _tissue[i]->SetMapper(vtkmpr3Ddata->GetTissueMapper(i));

//              wxColour* cc=_vtkmprdata->GetColour(i); 
//              float cr=cc->Red(),cg=cc->Green(),cb=cc->Blue();
//              _tissue[i]->GetProperty()->SetDiffuseColor(cr/255, cg/255   , cb/255   );
//              _tissue[i]->GetProperty()->SetSpecular(.3);
//              _tissue[i]->GetProperty()->SetSpecularPower(20);

                if (i==0) _tissue[i]->GetProperty()->SetColor(1, 0   , 0   );
                if (i==2) _tissue[i]->GetProperty()->SetColor(0.85, 0.85   , 0.85   );
                if (i==3) _tissue[i]->GetProperty()->SetColor(0, 1   ,  0  );
                if (i==4) _tissue[i]->GetProperty()->SetColor(0, 0   , 1   );

                if (i==0){
                  _tissue[i]->VisibilityOff();
                  _tissue[i]->SetScale(1.01, 1.01, 1.01);
                }
        }

  // Volume (RayCast)
        GetRenderer()->AddVolume( vtkmpr3Ddata->GetVolumeActor()  );    // RayCast
        GetRenderer()->SetBackground(0.5, 0.5, 0.5);

  // Actors are added to the renderer. 
  GetRenderer()->AddActor( vtkmpr3Ddata->GetOutlineActor() );                   
  GetRenderer()->AddActor( vtkmpr3Ddata->GetImageActor(0)  );   // _saggital
  GetRenderer()->AddActor( vtkmpr3Ddata->GetImageActor(1)  );   // _axial
  GetRenderer()->AddActor( vtkmpr3Ddata->GetImageActor(2)  );   // _coronal



        // Box Volume
        
  // The SetInteractor method is how 3D widgets are associated with the
  // render window interactor. Internally, SetInteractor sets up a bunch
  // of callbacks using the Command/Observer mechanism (AddObserver()).
  _boxWidget = vtkBoxWidget::New();
        _boxWidget->SetInteractor( GetWxVTKRenderWindowInteractor() );
        _boxWidget->SetPlaceFactor(1.0);

  // Place the interactor initially. The output of the reader is used to
  // place the box widget.

        _observerV = boxVolumeObserver::New();
        _observerV->SetRenWin( GetRenWin() );
        _observerV->SetVolumeMapper( vtkmpr3Ddata->GetVolumeMapper() );

        _boxWidget->SetInput( vtkmpr3Ddata->GetImageData() );
        _boxWidget->PlaceWidget();
        _boxWidget->InsideOutOn();
        _boxWidget->AddObserver( vtkCommand::StartInteractionEvent      , _observerV );
        _boxWidget->AddObserver( vtkCommand::InteractionEvent           , _observerV );
        _boxWidget->AddObserver( vtkCommand::EndInteractionEvent        , _observerV );
        _boxWidget->On();

        vtkProperty *outlineProperty = _boxWidget->GetOutlineProperty();
        outlineProperty->SetRepresentationToWireframe();
        outlineProperty->SetAmbient(1.0);
        outlineProperty->SetAmbientColor(1, 1, 1);
        outlineProperty->SetLineWidth(3);

        vtkProperty *selectedOutlineProperty = _boxWidget->GetSelectedOutlineProperty();
        selectedOutlineProperty->SetRepresentationToWireframe();
        selectedOutlineProperty->SetAmbient(1.0);
        selectedOutlineProperty->SetAmbientColor(1, 0, 0);
        selectedOutlineProperty->SetLineWidth(3);

//--
        // Box Surface

  // Place the interactor initially. The output of the reader is used to
  // place the box widget.

//      _observerV = boxVolumeObserver::New();
//      _observerV->SetRenWin( _renWin );
//      _observerV->SetVolumeMapper( _vtkmprdata->GetVolumeMapper() );

        _observerS1 = boxSurfaceObserver::New();
        _observerS1->SetPlanes( vtkmpr3Ddata->GetTissuePlanes(0) );
        _observerS1->SetActor( _tissue[0] );

  _boxWidgetS1 = vtkBoxWidget::New();
        _boxWidgetS1->SetInteractor( GetWxVTKRenderWindowInteractor() );
        _boxWidgetS1->SetPlaceFactor(1.25);


        _boxWidgetS1->SetInput( vtkmpr3Ddata->GetTissueStripper(0)->GetOutput() );
//      _boxWidgetS1->SetInput( vtkmpr3Ddata->GetGlyph(0)->GetOutput() );
        _boxWidgetS1->PlaceWidget();
        _boxWidgetS1->InsideOutOff();
//      _boxWidgetS1->AddObserver( vtkCommand::StartInteractionEvent , _observerV );
//      _boxWidgetS1->AddObserver( vtkCommand::InteractionEvent          , _observerV );
//      _boxWidgetS1->AddObserver( vtkCommand::EndInteractionEvent       , _observerV );
//      _boxWidgetS1->AddObserver( vtkCommand::EndInteractionEvent       , _observerS1 );
        _boxWidgetS1->AddObserver( vtkCommand::InteractionEvent          , _observerS1 );

//      vtkProperty *outlinePropertyS1 = _boxWidgetS1->GetOutlineProperty();
//      outlinePropertyS1->SetRepresentationToWireframe();
//      outlinePropertyS1->SetAmbient(1.0);
//      outlinePropertyS1->SetAmbientColor(0, 0, 1);
//      outlinePropertyS1->SetLineWidth(3);

//      vtkProperty *selectedOutlinePropertyS1 = _boxWidgetS1->GetSelectedOutlineProperty();
//      selectedOutlinePropertyS1->SetRepresentationToWireframe();
//      selectedOutlinePropertyS1->SetAmbient(1.0);
//      selectedOutlinePropertyS1->SetAmbientColor(1, 0, 0);
//      selectedOutlinePropertyS1->SetLineWidth(3);


        // vtkActor tissue
        for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++){
                GetRenderer()->AddActor( _tissue[i] );                  
        }

        _boxWidgetS1->On();

//--

  // Turn off bone for this example.
//  _bone->VisibilityOff();


  // An initial camera view is created.  The Dolly() method moves 
  // the camera towards the FocalPoint, thereby enlarging the image.
  GetRenderer()->SetActiveCamera(GetCamera());
  GetRenderer()->ResetCamera ();
  GetCamera()->Dolly(1.5);

  // Set a background color for the renderer and set the size of the
  // render window (expressed in pixels).
  GetRenderer()->SetBackground(1,1,1);
  GetRenWin()->SetSize(400, 400);

  // Note that when camera movement occurs (as it does in the Dolly()
  // method), the clipping planes often need adjusting. Clipping planes
  // consist of two planes: near and far along the view direction. The 
  // near plane clips out objects in front of the plane; the far plane
  // clips out objects behind the plane. This way only what is drawn
  // between the planes is actually rendered.
  GetRenderer()->ResetCameraClippingRange();

}


//-------------------------------------------------------------------
void wxVtkMPR3DView::VisibleActor(int idTissue, bool visTissue, bool visGuide){
        if (visTissue!=GetVisibleTissue(idTissue)){
                if (visTissue==false){
                        GetRenderer()->RemoveActor( GetTissueActor(idTissue)  );        
                } else {
                        GetRenderer()->AddActor( GetTissueActor(idTissue)  );   
                }
                SetVisibleTissue(idTissue,visTissue);
        }

        if (visGuide==true){
                _boxWidgetS1->On();
        } else {
                _boxWidgetS1->Off();
        }

}
//-------------------------------------------------------------------
void wxVtkMPR3DView::VisibleImageActor(int idPosition, bool visible){
        vtkMPR3DData *vtkmpr3Ddata = (vtkMPR3DData*)GetVtkmprbasedata();
        if (visible!=vtkmpr3Ddata->GetVisiblePosition(idPosition)){
                if (visible==false){
                        GetRenderer()->RemoveActor( vtkmpr3Ddata->GetImageActor(idPosition)  ); 
                } else {
                        GetRenderer()->AddActor( vtkmpr3Ddata->GetImageActor(idPosition)  );    
                }
                vtkmpr3Ddata->SetVisiblePosition(idPosition,visible);
        }
}

//-------------------------------------------------------------------

void wxVtkMPR3DView::VisibleVolumeActor( bool visVolume,bool visGuide){
        vtkMPR3DData *vtkmpr3Ddata = (vtkMPR3DData*)GetVtkmprbasedata();
        if (visVolume!=_visibleVolume){
                if (visVolume==false){
                        GetRenderer()->RemoveActor( vtkmpr3Ddata->GetVolumeActor()  );  
                } else {
                        GetRenderer()->AddActor( vtkmpr3Ddata->GetVolumeActor() );      
                }
                _visibleVolume=visVolume;
        }
        if (visGuide==true){
                _boxWidget->On();
        } else {
                _boxWidget->Off();
        }
}

*/

//-------------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------


/*
wxSurfaceMPR::wxSurfaceMPR(wxWindow *parent,  vtkImageData *imagedata, const wxString& title)
                                : wxFrame( parent, -1, title) {

        _vtkmpr3Ddata = new vtkMPR3DData(); 
        _vtkmpr3Ddata->SetImageData(imagedata);

        wxPanel *MPRPanel               = CreateMPRPanel(this,_vtkmpr3Ddata);
        wxPanel *controlPanel   = CreateControlPanel(this);

    wxFlexGridSizer *sizer  = new wxFlexGridSizer(2);
        sizer->Add(MPRPanel );
        sizer->Add(controlPanel );
        this->SetSizer(sizer);
        this->SetAutoLayout(true);
        this->SetSize(800,900);
}

//-------------------------------------------------------------------
wxPanel* wxSurfaceMPR::CreateMPRPanel(wxWindow *parent, vtkMPR3DData *vtkmpr3Ddata){
        wxPanel *panel=new wxPanel(parent,-1);

        _vtkmprview[1] = new wxVtkMPR3DView(panel);
        _vtkmprview[1]->SetVtkmprbasedata(vtkmpr3Ddata);
        wxVTKRenderWindowInteractor *iren1 = _vtkmprview[1]->GetWxVTKRenderWindowInteractor();  

        _vtkmprview[2] = new wxVtkMPR3DView(panel);
        _vtkmprview[2]->SetVtkmprbasedata(vtkmpr3Ddata);
        wxVTKRenderWindowInteractor *iren2 = _vtkmprview[2]->GetWxVTKRenderWindowInteractor();  

        _vtkmprview[3] = new wxVtkMPR3DView(panel);
        _vtkmprview[3]->SetVtkmprbasedata(vtkmpr3Ddata);
        wxVTKRenderWindowInteractor *iren3 = _vtkmprview[3]->GetWxVTKRenderWindowInteractor();  

        _vtkmprview[0] = new wxVtkMPR3DView(panel);
        _vtkmprview[0]->SetVtkmprbasedata(vtkmpr3Ddata);
        wxVTKRenderWindowInteractor *iren0 = _vtkmprview[0]->GetWxVTKRenderWindowInteractor();  

    wxBoxSizer *sizerV = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer *sizerH1= new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *sizerH2= new wxBoxSizer(wxHORIZONTAL);
        sizerH1->Add(iren0 , 1, wxEXPAND, 0);

        sizerH1->Add(iren1 , 1, wxEXPAND, 0);
        sizerH2->Add(iren2 , 1, wxEXPAND, 0);
        sizerH2->Add(iren3 , 1, wxEXPAND, 0);

        sizerV->Add(sizerH1, 1, wxEXPAND, 0);
        sizerV->Add(sizerH2, 1, wxEXPAND, 0);

        panel->SetAutoLayout(true);
        panel->SetSizer(sizerV);
        panel->SetSize(900,900);
        panel->Layout();


        return panel;
}

//-------------------------------------------------------------------

wxPanel* wxSurfaceMPR::CreateControlPanel(wxWindow *parent){
        wxPanel *panel=new wxPanel(parent,-1);

// position 
        wxPanel *panel1 =new wxPanel(panel,-1);
        wxStaticText *text_space1 = new wxStaticText(panel1,-1,"    ");
        wxStaticText *text1_box1  = new wxStaticText(panel1,-1,"x  ");
        wxStaticText *text2_box1  = new wxStaticText(panel1,-1,"y  ");
        wxStaticText *text3_box1  = new wxStaticText(panel1,-1,"z  ");
        _sl1_box1 = new wxSlider( panel1, -1, 0, 0, _vtkmpr3Ddata->GetMaxPositionX(), wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _sl2_box1 = new wxSlider( panel1, -1, 0, 0, _vtkmpr3Ddata->GetMaxPositionY(), wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _sl3_box1 = new wxSlider( panel1, -1, 0, 0, _vtkmpr3Ddata->GetMaxPositionZ(), wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );

        _sl1_box1->SetSize(250,20);
        _sl2_box1->SetSize(250,20);
        _sl3_box1->SetSize(250,20);

    wxFlexGridSizer *sizerBox1 = new wxFlexGridSizer(3);
        // line 1
        sizerBox1->Add(text_space1);
        sizerBox1->Add(text1_box1);
        sizerBox1->Add( _sl1_box1);
        // line 2
        sizerBox1->Add(text_space1);
        sizerBox1->Add(text2_box1);
        sizerBox1->Add( _sl2_box1);
        // line 3
        sizerBox1->Add(text_space1);
        sizerBox1->Add(text3_box1);
        sizerBox1->Add( _sl3_box1);
        panel1->SetSizer(sizerBox1);
        panel1->SetAutoLayout(true);
        panel1->SetSize(250,80);


// Layers
        wxPanel *panel2 =new wxPanel(panel,-1);
        wxStaticText *text_space2 = new wxStaticText(panel2,-1,"   ");
        wxStaticText *text_             = new wxStaticText(panel2,-1,"  ");
                                  _btnA         = new wxButton(panel2,-1,"A");
                                  _btnB         = new wxButton(panel2,-1,"B");
                                  _btnC         = new wxButton(panel2,-1,"C");
                                  _btnD         = new wxButton(panel2,-1,"D");
                      _text_A   = new wxStaticText(panel2,-1,"000000");
                      _text_B   = new wxStaticText(panel2,-1,"000000");
                      _text_C   = new wxStaticText(panel2,-1,"000000");
                      _text_D   = new wxStaticText(panel2,-1,"000000");
        wxStaticText *text_A    = new wxStaticText(panel2,-1,"A ");
        wxStaticText *text_B    = new wxStaticText(panel2,-1,"B ");
        wxStaticText *text_C    = new wxStaticText(panel2,-1,"C ");
        wxStaticText *text_D    = new wxStaticText(panel2,-1,"D ");
        _slA1_box2 = new wxSlider( panel2, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _slA2_box2 = new wxSlider( panel2, -1, 0, 0,  60, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slA3_box2 = new wxSlider( panel2, -1, 0, 0,  50, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slB1_box2 = new wxSlider( panel2, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _slB2_box2 = new wxSlider( panel2, -1, 0, 0,  60, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slB3_box2 = new wxSlider( panel2, -1, 0, 0,  50, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slC1_box2 = new wxSlider( panel2, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _slC2_box2 = new wxSlider( panel2, -1, 0, 0,  60, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slC3_box2 = new wxSlider( panel2, -1, 0, 0,  50, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slD1_box2 = new wxSlider( panel2, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
        _slD2_box2 = new wxSlider( panel2, -1, 0, 0,  60, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );
        _slD3_box2 = new wxSlider( panel2, -1, 0, 0,  50, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL  );

        _chk1_box1 = new wxCheckBox(panel2, -1, "Visible X");
        _chk2_box1 = new wxCheckBox(panel2, -1, "Visible Y");
        _chk3_box1 = new wxCheckBox(panel2, -1, "Visible Z");

        _chkA_box2              = new wxCheckBox(panel2, -1, "Vis.");
        _chkB_box2              = new wxCheckBox(panel2, -1, "Vis.");
        _chkC_box2              = new wxCheckBox(panel2, -1, "Vis.");
        _chkD_box2              = new wxCheckBox(panel2, -1, "Vis.");
        _chkAA_box2             = new wxCheckBox(panel2, -1, ".");
        _chkBB_box2             = new wxCheckBox(panel2, -1, ".");
        _chkCC_box2             = new wxCheckBox(panel2, -1, ".");
        _chkDD_box2             = new wxCheckBox(panel2, -1, ".");
        _chkViewA_box2  = new wxCheckBox(panel2, -1, "A");
        _chkViewB_box2  = new wxCheckBox(panel2, -1, "B");
        _chkViewC_box2  = new wxCheckBox(panel2, -1, "C");
        _chkViewD_box2  = new wxCheckBox(panel2, -1, "D");

        _chk1_box1->SetValue(true);
        _chk2_box1->SetValue(true);
        _chk3_box1->SetValue(true);
        _chkA_box2->SetValue(true);
        _chkB_box2->SetValue(true);
        _chkC_box2->SetValue(true);
        _chkD_box2->SetValue(true);
        _chkAA_box2->SetValue(true);
        _chkBB_box2->SetValue(true);
        _chkCC_box2->SetValue(true);
        _chkDD_box2->SetValue(true);
        _chkViewA_box2->SetValue(true);
        _chkViewB_box2->SetValue(true);
        _chkViewC_box2->SetValue(true);
        _chkViewD_box2->SetValue(true);

        _slA1_box2->SetSize(250,20);
        _slA2_box2->SetSize(150,20);
        _slA3_box2->SetSize(150,20);
        _slB1_box2->SetSize(250,20);
        _slB2_box2->SetSize(150,20);
        _slB3_box2->SetSize(150,20);
        _slC1_box2->SetSize(250,20);
        _slC2_box2->SetSize(150,20);
        _slC3_box2->SetSize(150,20);
        _slD1_box2->SetSize(250,20);
        _slD2_box2->SetSize(150,20);
        _slD3_box2->SetSize(150,20);
        _btnA->SetSize(20,20);
        _btnB->SetSize(20,20);
        _btnC->SetSize(20,20);
        _btnD->SetSize(20,20);

        _btnA->SetBackgroundColour( *(_vtkmpr3Ddata->GetColour(0))  );
        _btnB->SetBackgroundColour( *(_vtkmpr3Ddata->GetColour(1))  );
        _btnC->SetBackgroundColour( *(_vtkmpr3Ddata->GetColour(2))  );
        _btnD->SetBackgroundColour( *(_vtkmpr3Ddata->GetColour(3))  );


    wxFlexGridSizer *sizerPanel2A = new wxFlexGridSizer(5);
    // line A2
        sizerPanel2A->Add(text_space2);
        sizerPanel2A->Add(text_A);
        sizerPanel2A->Add(_slA2_box2);
        sizerPanel2A->Add(_slA3_box2);
        sizerPanel2A->Add(_text_A);
    // line B2
        sizerPanel2A->Add(text_space2);
        sizerPanel2A->Add(text_B);
        sizerPanel2A->Add(_slB2_box2);
        sizerPanel2A->Add(_slB3_box2);
        sizerPanel2A->Add(_text_B);
    // line C2
        sizerPanel2A->Add(text_space2);
        sizerPanel2A->Add(text_C);
        sizerPanel2A->Add(_slC2_box2);
        sizerPanel2A->Add(_slC3_box2);
        sizerPanel2A->Add(_text_C);
    // line D2
        sizerPanel2A->Add(text_space2);
        sizerPanel2A->Add(text_D);
        sizerPanel2A->Add(_slD2_box2);
        sizerPanel2A->Add(_slD3_box2);
        sizerPanel2A->Add(_text_D);


    wxFlexGridSizer *sizerPanel2B = new wxFlexGridSizer(5);
    // line A1
        sizerPanel2B->Add(text_space2);
        sizerPanel2B->Add(_btnA);
        sizerPanel2B->Add(_slA1_box2);
        sizerPanel2B->Add(_chkA_box2);
        sizerPanel2B->Add(_chkAA_box2);
    // line B1
        sizerPanel2B->Add(text_space2);
        sizerPanel2B->Add(_btnB);
        sizerPanel2B->Add(_slB1_box2);
        sizerPanel2B->Add(_chkB_box2);
        sizerPanel2B->Add(_chkBB_box2);
    // line C1
        sizerPanel2B->Add(text_space2);
        sizerPanel2B->Add(_btnC);
        sizerPanel2B->Add(_slC1_box2);
        sizerPanel2B->Add(_chkC_box2);
        sizerPanel2B->Add(_chkCC_box2);
    // line D1
        sizerPanel2B->Add(text_space2);
        sizerPanel2B->Add(_btnD);
        sizerPanel2B->Add(_slD1_box2);
        sizerPanel2B->Add(_chkD_box2);
        sizerPanel2B->Add(_chkDD_box2);

    wxFlexGridSizer *sizerPanel2C = new wxFlexGridSizer(4);
        sizerPanel2C->Add(_chkViewA_box2);
        sizerPanel2C->Add(_chkViewB_box2);
        sizerPanel2C->Add(_chkViewC_box2);
        sizerPanel2C->Add(_chkViewD_box2);

    wxFlexGridSizer *sizerPanel2D = new wxFlexGridSizer(2);
        sizerPanel2D->Add(text_space2);
        sizerPanel2D->Add(_chk1_box1);
        sizerPanel2D->Add(text_space2);
        sizerPanel2D->Add(_chk2_box1);
        sizerPanel2D->Add(text_space2);
        sizerPanel2D->Add(_chk3_box1);

    wxFlexGridSizer *sizerPanel2 = new wxFlexGridSizer(1);
        sizerPanel2->Add(sizerPanel2A);
        sizerPanel2->Add(text_space2);
        sizerPanel2->Add(sizerPanel2C);
        sizerPanel2->Add(text_space2);
        sizerPanel2->Add(sizerPanel2D);
        sizerPanel2->Add(text_space2);
        sizerPanel2->Add(sizerPanel2B);

        panel2->SetSizer(sizerPanel2);
        panel2->SetAutoLayout(true);
        panel2->SetSize(350,320);

// cut1
        wxPanel *panel3 = new wxPanel(panel,-1);
        wxStaticText *text_space3 = new wxStaticText(panel3,-1,"    ");
        _chk_box3 = new wxCheckBox(panel3, -1, "Vis.");
        _chk_box33 = new wxCheckBox(panel3, -1, "Vis.");
        _chk_box3->SetValue(true);
        _chk_box33->SetValue(true);
    wxFlexGridSizer *sizerPanel3 = new wxFlexGridSizer(3);
        // line 1
        sizerPanel3->Add(text_space3);
        sizerPanel3->Add(_chk_box3);
        sizerPanel3->Add(_chk_box33);
        panel3->SetSizer(sizerPanel3);
        panel3->SetAutoLayout(true);
        panel3->SetSize(250,100);

//      _sl1_box3 = new wxSlider( panel3, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl2_box3 = new wxSlider( panel3, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl3_box3 = new wxSlider( panel3, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      wxStaticText *text1_box3 = new wxStaticText(panel3,-1,"A");
//      wxStaticText *text2_box3 = new wxStaticText(panel3,-1,"B");
//      wxStaticText *text3_box3 = new wxStaticText(panel3,-1,"Dist");
//  wxFlexGridSizer *sizerPanel3 = new wxFlexGridSizer(3);
//      // line 1
//      sizerPanel3->Add(text_space3);
//      sizerPanel3->Add(_chk_box3);
//      sizerPanel3->Add(text_space3);
//      // line 2
//      sizerPanel3->Add(text_space3);
//      sizerPanel3->Add(text1_box3);
//      sizerPanel3->Add(_sl1_box3);
//      // line 3
//      sizerPanel3->Add(text_space3);
//      sizerPanel3->Add(text2_box3);
//      sizerPanel3->Add(_sl2_box3);
//      // line 4
//      sizerPanel3->Add(text_space3);
//      sizerPanel3->Add(text3_box3);
//      sizerPanel3->Add(_sl3_box3);
//      panel3->SetSizer(sizerPanel3);
//      panel3->SetAutoLayout(true);
//      panel3->SetSize(250,100);
//  // cut2
//
//      wxPanel *panel4 = new wxPanel(panel,-1);
//      _chk_box4 = new wxCheckBox(panel4, -1, "Vis.");
//      _slA_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _slB_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl1_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl2_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl3_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl4_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl5_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      _sl6_box4 = new wxSlider( panel4, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS );
//      wxStaticText *text_space4 = new wxStaticText(panel3,-1,"    ");
//      wxStaticText *textA_box4 = new wxStaticText(panel4,-1,"A");
//      wxStaticText *textB_box4 = new wxStaticText(panel4,-1,"B");
//      wxStaticText *text1_box4 = new wxStaticText(panel4,-1,"D1");
//      wxStaticText *text2_box4 = new wxStaticText(panel4,-1,"D2");
//      wxStaticText *text3_box4 = new wxStaticText(panel4,-1,"D3");
//      wxStaticText *text4_box4 = new wxStaticText(panel4,-1,"D4");
//      wxStaticText *text5_box4 = new wxStaticText(panel4,-1,"D5");
//      wxStaticText *text6_box4 = new wxStaticText(panel4,-1,"D6");
//  wxFlexGridSizer *sizerPanel4 = new wxFlexGridSizer(3);
//      // line 1
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(_chk_box4);
//      sizerPanel4->Add(text_space4);
//      // line 2
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(textA_box4);
//      sizerPanel4->Add(_slA_box4);
//      // line 3
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(textB_box4);
//      sizerPanel4->Add(_slB_box4);
//      // line 4
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text1_box4);
//      sizerPanel4->Add(_sl1_box4);
//      // line 5
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text2_box4);
//      sizerPanel4->Add(_sl2_box4);
//      // line 6
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text3_box4);
//      sizerPanel4->Add(_sl3_box4);
//      // line 7
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text4_box4);
//      sizerPanel4->Add(_sl4_box4);
//      // line 8
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text5_box4);
//      sizerPanel4->Add(_sl5_box4);
//      // line 9
//      sizerPanel4->Add(text_space4);
//      sizerPanel4->Add(text6_box4);
//      sizerPanel4->Add(_sl6_box4);
//      //
//      panel4->SetSizer(sizerPanel4);
//      panel4->SetAutoLayout(true);
//      panel4->SetSize(250,300);



// All
    wxFlexGridSizer *sizer = new wxFlexGridSizer(1);

        sizer->Add(new wxStaticText(panel,-1,"Position") );
        sizer->Add(panel1);
        sizer->Add(new wxStaticText(panel,-1,"Layer") );
        sizer->Add(panel2);
        sizer->Add(new wxStaticText(panel,-1,"Cut 1") );
        sizer->Add(panel3);
//      sizer->Add(new wxStaticText(panel,-1,"Cut 2") );
//      sizer->Add(panel4);

        panel->SetSizer(sizer);
        panel->SetAutoLayout(true);
        panel->SetSize(350,750);


        // Position 
        Connect(_sl1_box1->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnPositionX );
        Connect(_sl2_box1->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnPositionY );
        Connect(_sl3_box1->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnPositionZ );
        Connect(_chk1_box1->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleX );
        Connect(_chk2_box1->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleY );
        Connect(_chk3_box1->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleZ );
 

        // Opacity
        Connect(_slA1_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE   , (wxObjectEventFunction) &wxSurfaceMPR::OnOpacity0 );
        Connect(_slB1_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE   , (wxObjectEventFunction) &wxSurfaceMPR::OnOpacity1 );
        Connect(_slC1_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE   , (wxObjectEventFunction) &wxSurfaceMPR::OnOpacity2 );
        Connect(_slD1_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE   , (wxObjectEventFunction) &wxSurfaceMPR::OnOpacity3 );
        Connect(_btnA->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxSurfaceMPR::OnBtnColourA );
        Connect(_btnB->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxSurfaceMPR::OnBtnColourB );
        Connect(_btnC->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxSurfaceMPR::OnBtnColourC );
        Connect(_btnD->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxSurfaceMPR::OnBtnColourD );



        // Isovalue
        Connect(_slA2_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue0 );
        Connect(_slA3_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue0 );
        Connect(_slB2_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue1 );
        Connect(_slB3_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue1 );
        Connect(_slC2_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue2 );
        Connect(_slC3_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue2 );
        Connect(_slD2_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue3 );
        Connect(_slD3_box2->GetId()  , wxEVT_SCROLL_THUMBRELEASE  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue3 );
        Connect(_slA2_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_0 );
        Connect(_slA3_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_0 );
        Connect(_slB2_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_1 );
        Connect(_slB3_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_1 );
        Connect(_slC2_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_2 );
        Connect(_slC3_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_2 );
        Connect(_slD2_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_3 );
        Connect(_slD3_box2->GetId()  , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) &wxSurfaceMPR::OnIsoValue_3 );

        Connect(_chkA_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueA );
        Connect(_chkB_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueB );
        Connect(_chkC_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueC );
        Connect(_chkD_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueD );
        Connect(_chkAA_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueA );
        Connect(_chkBB_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueB );
        Connect(_chkCC_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueC );
        Connect(_chkDD_box2->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleTissueD );

        Connect(_chk_box3->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleVolume );
        Connect(_chk_box33->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxSurfaceMPR::OnVisibleVolume );

        return panel;
}


*/


/*

//------------------------------------------------------------------------

void wxSurfaceMPR::Refresh(){
        _vtkmprview[0]->Refresh();
        _vtkmprview[1]->Refresh();
        _vtkmprview[2]->Refresh();
        _vtkmprview[3]->Refresh();
}


//------------------------------------------------------------------------
void wxSurfaceMPR::OnPositionX(wxScrollEvent& event){
        _vtkmpr3Ddata->SetPositionX( _sl1_box1->GetValue() );
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnPositionY(wxScrollEvent& event){
        _vtkmpr3Ddata->SetPositionY( _sl2_box1->GetValue() );
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnPositionZ(wxScrollEvent& event){
        _vtkmpr3Ddata->SetPositionZ( _sl3_box1->GetValue() );
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OpacityTissue(int idView, int idTissue, int opacity){
        vtkActor *tmpActor;
        tmpActor = _vtkmprview[ idView ]->GetTissueActor(idTissue);
        tmpActor->GetProperty()->SetOpacity((float) opacity/100 );
        _vtkmprview[idView]->Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnOpacity0(wxScrollEvent& event){
        int opacity = _slA1_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){OpacityTissue(0,0, opacity ); }
        if (_chkViewB_box2->GetValue()==true){OpacityTissue(1,0, opacity ); }
        if (_chkViewC_box2->GetValue()==true){OpacityTissue(2,0, opacity ); }
        if (_chkViewD_box2->GetValue()==true){OpacityTissue(3,0, opacity ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnOpacity1(wxScrollEvent& event){
        int opacity = _slB1_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){OpacityTissue(0,1, opacity ); }
        if (_chkViewB_box2->GetValue()==true){OpacityTissue(1,1, opacity ); }
        if (_chkViewC_box2->GetValue()==true){OpacityTissue(2,1, opacity ); }
        if (_chkViewD_box2->GetValue()==true){OpacityTissue(3,1, opacity ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnOpacity2(wxScrollEvent& event){
        int opacity = _slC1_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){OpacityTissue(0,2, opacity ); }
        if (_chkViewB_box2->GetValue()==true){OpacityTissue(1,2, opacity ); }
        if (_chkViewC_box2->GetValue()==true){OpacityTissue(2,2, opacity ); }
        if (_chkViewD_box2->GetValue()==true){OpacityTissue(3,2, opacity ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnOpacity3(wxScrollEvent& event){
        int opacity = _slD1_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){OpacityTissue(0,3, opacity ); }
        if (_chkViewB_box2->GetValue()==true){OpacityTissue(1,3, opacity ); }
        if (_chkViewC_box2->GetValue()==true){OpacityTissue(2,3, opacity ); }
        if (_chkViewD_box2->GetValue()==true){OpacityTissue(3,3, opacity ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue0(wxScrollEvent& event){
        int isoValue=_slA2_box2->GetValue() * 50 + _slA3_box2->GetValue();
        _vtkmpr3Ddata->SetIsovalue(0,isoValue);
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_A->SetLabel(tmpStr);
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue1(wxScrollEvent& event){
        int isoValue=_slB2_box2->GetValue() * 50 + _slB3_box2->GetValue();
        _vtkmpr3Ddata->SetIsovalue(1,isoValue);
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_B->SetLabel(tmpStr);
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue2(wxScrollEvent& event){
        int isoValue=_slC2_box2->GetValue() * 50 + _slC3_box2->GetValue();
        _vtkmpr3Ddata->SetIsovalue(2,isoValue);
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_C->SetLabel(tmpStr);
    Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue3(wxScrollEvent& event){
        int isoValue=_slD2_box2->GetValue() * 50 + _slD3_box2->GetValue();
        _vtkmpr3Ddata->SetIsovalue(3,isoValue);
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_D->SetLabel(tmpStr);
    Refresh();
}



//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue_0(wxScrollEvent& event){
        int isoValue=_slA2_box2->GetValue() * 50 + _slA3_box2->GetValue();
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_A->SetLabel(tmpStr);
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue_1(wxScrollEvent& event){
        int isoValue=_slB2_box2->GetValue() * 50 + _slB3_box2->GetValue();
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_B->SetLabel(tmpStr);
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue_2(wxScrollEvent& event){
        int isoValue=_slC2_box2->GetValue() * 50 + _slC3_box2->GetValue();
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_C->SetLabel(tmpStr);
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnIsoValue_3(wxScrollEvent& event){
        int isoValue=_slD2_box2->GetValue() * 50 + _slD3_box2->GetValue();
        wxString tmpStr;
        tmpStr.Printf("%d",isoValue);
        _text_D->SetLabel(tmpStr);
}


//------------------------------------------------------------------------
void wxSurfaceMPR::OnBtnColourA(wxCommandEvent& event){
  wxColourDialog dlgColour(this);
  dlgColour.ShowModal();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnBtnColourB(wxCommandEvent& event){
  wxColourDialog dlgColour(this);
  dlgColour.ShowModal();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnBtnColourC(wxCommandEvent& event){
  wxColourDialog dlgColour(this);
  dlgColour.ShowModal();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnBtnColourD(wxCommandEvent& event){
  wxColourDialog dlgColour(this);
  dlgColour.ShowModal();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::VisibleActor(int idView, int idTissue, bool visTissue, bool visGuide){
        _vtkmprview[idView]->VisibleActor(idTissue, visTissue, visGuide);
        _vtkmprview[idView]->Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::VisibleImageActor(int idView, int idTissue, bool visible){
        _vtkmprview[idView]->VisibleImageActor(idTissue, visible);
        _vtkmprview[idView]->Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleX(wxCommandEvent& event){
        bool visible = _chk1_box1->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleImageActor(0,0, visible ); }
        if (_chkViewB_box2->GetValue()==true){VisibleImageActor(1,0, visible ); }
        if (_chkViewC_box2->GetValue()==true){VisibleImageActor(2,0, visible ); }
        if (_chkViewD_box2->GetValue()==true){VisibleImageActor(3,0, visible ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleY(wxCommandEvent& event){
        bool visible = _chk2_box1->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleImageActor(0,1, visible ); }
        if (_chkViewB_box2->GetValue()==true){VisibleImageActor(1,1, visible ); }
        if (_chkViewC_box2->GetValue()==true){VisibleImageActor(2,1, visible ); }
        if (_chkViewD_box2->GetValue()==true){VisibleImageActor(3,1, visible ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleZ(wxCommandEvent& event){
        bool visible = _chk3_box1->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleImageActor(0,2, visible ); }
        if (_chkViewB_box2->GetValue()==true){VisibleImageActor(1,2, visible ); }
        if (_chkViewC_box2->GetValue()==true){VisibleImageActor(2,2, visible ); }
        if (_chkViewD_box2->GetValue()==true){VisibleImageActor(3,2, visible ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleTissueA(wxCommandEvent& event){
        bool visiTissue = _chkA_box2->GetValue();
        bool visGuide = _chkAA_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleActor(0,0, visiTissue, visGuide ); }
        if (_chkViewB_box2->GetValue()==true){VisibleActor(1,0, visiTissue, visGuide ); }
        if (_chkViewC_box2->GetValue()==true){VisibleActor(2,0, visiTissue, visGuide ); }
        if (_chkViewD_box2->GetValue()==true){VisibleActor(3,0, visiTissue, visGuide ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleTissueB(wxCommandEvent& event){
        bool visiTissue = _chkA_box2->GetValue();
        bool visGuide = _chkAA_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleActor(0,1, visiTissue, visGuide ); }
        if (_chkViewB_box2->GetValue()==true){VisibleActor(1,1, visiTissue, visGuide ); }
        if (_chkViewC_box2->GetValue()==true){VisibleActor(2,1, visiTissue, visGuide ); }
        if (_chkViewD_box2->GetValue()==true){VisibleActor(3,1, visiTissue, visGuide ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleTissueC(wxCommandEvent& event){
        bool visiTissue = _chkA_box2->GetValue();
        bool visGuide = _chkAA_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleActor(0,2, visiTissue, visGuide ); }
        if (_chkViewB_box2->GetValue()==true){VisibleActor(1,2, visiTissue, visGuide ); }
        if (_chkViewC_box2->GetValue()==true){VisibleActor(2,2, visiTissue, visGuide ); }
        if (_chkViewD_box2->GetValue()==true){VisibleActor(3,2, visiTissue, visGuide ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleTissueD(wxCommandEvent& event){
        bool visiTissue = _chkA_box2->GetValue();
        bool visGuide = _chkAA_box2->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleActor(0,3, visiTissue, visGuide ); }
        if (_chkViewB_box2->GetValue()==true){VisibleActor(1,3, visiTissue, visGuide ); }
        if (_chkViewC_box2->GetValue()==true){VisibleActor(2,3, visiTissue, visGuide ); }
        if (_chkViewD_box2->GetValue()==true){VisibleActor(3,3, visiTissue, visGuide ); }
}
//------------------------------------------------------------------------
void wxSurfaceMPR::VisibleVolumeActor(int idView, bool visVolume, bool visGuide){
        _vtkmprview[idView]->VisibleVolumeActor( visVolume,visGuide);
        _vtkmprview[idView]->Refresh();
}
//------------------------------------------------------------------------
void wxSurfaceMPR::OnVisibleVolume(wxCommandEvent& event){
        bool visVolume = _chk_box3->GetValue();
        bool visGuide = _chk_box33->GetValue();
        if (_chkViewA_box2->GetValue()==true){VisibleVolumeActor(0, visVolume, visGuide); }
        if (_chkViewB_box2->GetValue()==true){VisibleVolumeActor(1, visVolume, visGuide); }
        if (_chkViewC_box2->GetValue()==true){VisibleVolumeActor(2, visVolume, visGuide); }
        if (_chkViewD_box2->GetValue()==true){VisibleVolumeActor(3, visVolume, visGuide); }
}

//------------------------------------------------------------------------
void wxSurfaceMPR::ConfigureVTK(){
        _vtkmprview[0]->Configure();
        _vtkmprview[1]->Configure();
        _vtkmprview[2]->Configure();
        _vtkmprview[3]->Configure();
}


*/