manualViewBaseContour.cpp

Go to the documentation of this file.

#include "manualViewBaseContour.h"


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

manualViewBaseContour::manualViewBaseContour()
{
        _show_text                      = true;
        _textActor                      = NULL;
        _manContModel           = NULL;
        _wxvtkbaseview          = NULL;
        _selected                       = false;
        _posibleSelected        = false;
        _viewControlPoints      = false;
        _pts                            = NULL;
        _pd                                     = NULL;
        _contourVtkActor        = NULL;
        _bboxMapper                     = NULL;
        _range                          = 1;
        _sizePointsContour      = 100;
        _spc[0]                         = 1;
        _spc[1]                         = 1;
        _spc[2]                         = 1;

        _coulorEdit_r           = 1;
        _coulorEdit_g           = 1;
        _coulorEdit_b           = 0;

        _coulorNormal_r         = 1;
        _coulorNormal_g         = 0;
        _coulorNormal_b         = 1;

        _coulorSelection_r      = 0;
        _coulorSelection_g      = 1;
        _coulorSelection_b      = 0;

        _widthline                      = 1;

}
// ----------------------------------------------------------------------------
manualViewBaseContour::~manualViewBaseContour()
{
        int i,size=_lstViewPoints.size();
        for (i=0;i<size; i++){
                delete _lstViewPoints[i];
        }
        _lstViewPoints.clear();
}
// ----------------------------------------------------------------------------


int manualViewBaseContour::GetType() // virtual
{
// Information...
//int manualViewBaseContour::GetType()          0;
//int manualViewContour::GetType()                      1;
//int manualViewRoi::GetType()                          2;
//int manualViewCircle::GetType()                       3;
//int manualViewStar::GetType()                         4;
//int manualViewLine::GetType()                         6;


        return 0;
}
// ----------------------------------------------------------------------------

void manualViewBaseContour::Save(FILE *pFile)
{
        fprintf(pFile,"TypeView %d\n", GetType() );
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::Open(FILE *pFile)
{
}

// ----------------------------------------------------------------------------
void manualViewBaseContour :: AddCompleteContourActor(  bool ifControlPoints )
{
        _viewControlPoints = ifControlPoints;
         /*vtkRenderer * theRenderer = */  _wxvtkbaseview->GetRenderer();  // JPRx ??
         //Adding the spline
         AddSplineActor();

         AddTextActor();
         //Adding each control point
         if( ifControlPoints )
                AddControlPoints();
         RefreshContour();
         Refresh();
}
// ---------------------------------------------------------------------------

void manualViewBaseContour :: RemoveCompleteContourActor()
{
        /*vtkRenderer * theRenderer =*/  _wxvtkbaseview->GetRenderer(); // JPRx ??
         //Removing the spline
        RemoveSplineActor();
        RemoveTextActor();

        //Removing each point
        RemoveControlPoints();
        RefreshContour();
        Refresh();
}
// ---------------------------------------------------------------------------
manualViewBaseContour *  manualViewBaseContour :: Clone( )//virtual
{
        manualViewBaseContour * clone = new manualViewBaseContour();
        CopyAttributesTo(clone);
        return clone;

}

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

void manualViewBaseContour::CopyAttributesTo( manualViewBaseContour * cloneObject)
{
        // Fathers object
        //XXXX::CopyAttributesTo(cloneObject);

        cloneObject-> SetWxVtkBaseView( this->_wxvtkbaseview );
        cloneObject-> SetSelected( this->GetSelected() );
        cloneObject-> SetPosibleSelected( this->GetPosibleSelected() );
        cloneObject-> SetIfViewControlPoints( this->GetIfViewControlPoints() );
        cloneObject-> SetRange( this->GetRange() );
        cloneObject-> SetZ( this->GetZ() );
        cloneObject-> SetSpacing( _spc );
        cloneObject-> SetColorNormalContour( _coulorNormal_r, _coulorNormal_g, _coulorNormal_b );
        cloneObject-> SetColorEditContour( _coulorEdit_r, _coulorEdit_g, _coulorEdit_b );
        cloneObject-> SetColorSelectContour( _coulorSelection_r, _coulorSelection_g, _coulorSelection_b );

        int i, size = _lstViewPoints.size();
        for ( i=0; i<size; i++ )
        {
                cloneObject->AddPoint(  );
        }
}

// ----------------------------------------------------------------------------
void manualViewBaseContour :: AddSplineActor()
{
        vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
        if (_contourVtkActor!=NULL)
                theRenderer->AddActor( _contourVtkActor  );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour :: RemoveSplineActor() // virtual
{
        vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
        if (_contourVtkActor!=NULL)
                theRenderer->RemoveActor( _contourVtkActor );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour :: RemoveControlPoints()
{
        if (_wxvtkbaseview!=NULL){
                vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
                int i,size=_lstViewPoints.size();
                for (i=0;i<size; i++)
                {
                        vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
                        theRenderer->RemoveActor( pointActor );
                } // for
        } // if
        SetIfViewControlPoints( false );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::AddControlPoints()
{
        vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
        SetIfViewControlPoints( true );
         if( _viewControlPoints )
         {
                int i,size=_lstViewPoints.size();
                for (i=0;i<size; i++)
                {
                        vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
                        theRenderer->AddActor( pointActor );
                }
         }
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::AddTextActor()
{
        _wxvtkbaseview->GetRenderer()->AddActor2D( _textActor );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::RemoveTextActor()
{
        _wxvtkbaseview->GetRenderer()->RemoveActor2D( _textActor );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::DeleteVtkObjects()
{
        if ( _contourVtkActor   != NULL )       { _contourVtkActor  -> Delete(); }
        if ( _bboxMapper                != NULL )       { _bboxMapper           -> Delete(); }
        if ( _pts                               != NULL )       { _pts                          -> Delete(); }
        if ( _pd                                != NULL )       { _pd                           -> Delete(); }
        _contourVtkActor        = NULL;
        _bboxMapper                     = NULL;
        _pts                            = NULL;
        _pd                                     = NULL;
}


// ----------------------------------------------------------------------------
void manualViewBaseContour::SetWidthLine(double width)
{
        _widthline = width;
        this->UpdateColorActor();

        // for the control points
        int id, size = _lstViewPoints.size();
        for( id=0; id<size; id++)
        {
                this->_lstViewPoints[id]->SetWidthLine(_widthline);
        }

}

// ----------------------------------------------------------------------------
double manualViewBaseContour::GetWidthLine()
{
        return _widthline;
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::ConstructVTKObjects()
{
//JSTG 29-02-08 -----------------------------------------------
        //int i , nps = _sizePointsContour;
        int i;
        int nps = _manContModel->GetNumberOfPointsSpline();
//-------------------------------------------------------------
        DeleteVtkObjects();
        _pts = vtkPoints::New();
        _pts->SetNumberOfPoints(nps);

        for (i=0 ; i<nps ; i++){
                _pts->SetPoint(i,       0       , 0     , 0 );
        }
        // This is for the boundaring inicialisation

//EED 29Mars2009        
        _pts->SetPoint(0,       0       , 0     , -1000 );
        _pts->SetPoint(1,       0       , 0     ,  1000 );
//      _pts->SetPoint(0,       -1000   , -1000 , -1000 );
//      _pts->SetPoint(1,       1000    , 1000  , 1000  );


        vtkCellArray *lines = vtkCellArray::New();
        lines->InsertNextCell( nps /* +1 */ );
        for ( i=0 ; i<nps+1 ; i++ ){
                lines->InsertCellPoint(i % nps );
        }

        _pd = vtkPolyData::New();
        _pd->SetPoints( _pts );
        _pd->SetLines( lines );
        lines->Delete();  //do not delete lines ??

        _contourVtkActor        =       vtkActor::New();
    _bboxMapper                 =       vtkPolyDataMapper::New();
    _bboxMapper->ScalarVisibilityOff( );

        _bboxMapper->SetInput(_pd);
        _bboxMapper->ImmediateModeRenderingOn();
        _contourVtkActor->SetMapper(_bboxMapper);
        _contourVtkActor->GetProperty()->BackfaceCullingOff();

        UpdateColorActor();

        _pd->ComputeBounds();

        //      Text
        _textActor = vtkTextActor::New();
//      _textActor->SetDisplayPosition(200, 200);
        _textActor->SetInput("00");
        // Set coordinates to match the old vtkScaledTextActor default value
//      _textActor->GetPosition2Coordinate()->SetCoordinateSystemToNormalizedViewport();
//      _textActor->GetPosition2Coordinate()->SetValue( 0.2 , 0.2 );
        _textActor->GetPositionCoordinate()->SetCoordinateSystemToWorld ();
//      _textActor->GetPositionCoordinate()->SetValue( 0.8 , 0.8 );

        vtkTextProperty *tprop = _textActor->GetTextProperty();
        tprop->SetFontSize(14);
        tprop->SetFontFamilyToArial();
        tprop->SetColor(0, 0, 1);
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::CreateNewContour()
{
        ConstructVTKObjects();
        /*
        _wxvtkbaseview->GetRenderer()->AddActor( _contourVtkActor );
        _wxvtkbaseview->GetRenderer()->AddActor2D(_textActor);*/
        AddCompleteContourActor();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::UpdateViewPoint(int id) // virtual
{
        manualPoint             *mp             = _manContModel->GetManualPoint(id);

//EEDx6
                        double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
//                      wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
//                      wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);

        _lstViewPoints[id]->SetPositionXY( XX , YY ,_range, ZZ );
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::UpdateViewPoints()
{
        int id, size = _lstViewPoints.size();
        for( id=0; id<size; id++)
        {
                UpdateViewPoint( id );
        }
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::AddPoint()
{
        manualViewPoint *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );
        AddPoint( mvp );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::AddPoint( manualViewPoint * manualViewPoint )
{
        _lstViewPoints.push_back( manualViewPoint );

        // EED 3 oct 2006
        manualViewPoint->SetSpacing(_spc);

        vtkActor *actor = manualViewPoint->CreateVtkPointActor();
        _wxvtkbaseview->GetRenderer()->AddActor( actor );       
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::InsertPoint(int id)
{
        manualViewPoint         *mvp    = new manualViewPoint( this->GetWxVtkBaseView() );

// EED 3 oct 2006
        mvp->SetSpacing(_spc);

        std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
        _lstViewPoints.insert(itNum,mvp);
        _wxvtkbaseview->GetRenderer()->AddActor( mvp->CreateVtkPointActor() );
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::DeleteContour()
{
        RemoveCompleteContourActor();
        /*if (_contourVtkActor!=NULL){
                _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
        }*/
        DeleteVtkObjects();
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                manualViewBaseContour::DeletePoint(0);
        }
        Refresh();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::DeletePoint(int id) // virtual
{
        int size=_lstViewPoints.size();
        if ( (id>=0) && (id<size) ){
                manualViewPoint         *mvp    =_lstViewPoints[id];
//EED ups1
//              _handlePicker->DeletePickList(mvp->GetVtkActor());
                _wxvtkbaseview->GetRenderer()->RemoveActor( mvp->GetVtkActor() );
                std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
                _lstViewPoints.erase(itNum);
                delete mvp;
                Refresh();
        }
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::DeletePoint(int x, int y, int z)
{
        int id=GetIdPoint(x,y,z);
        if (id!=-1){
                DeletePoint(id);
        }
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetSelected(bool selected)
{
        _selected=selected;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetPosibleSelected(bool posibleSelected)
{
        _posibleSelected=posibleSelected;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour::GetEditable()
{
        return *_editable;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetEditable( bool * condition )
{
        _editable = condition;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour::GetSelected()
{
        return _selected;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour::GetPosibleSelected()
{
        return _posibleSelected;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::DeleteSelectedPoints()
{
        int i,size=_lstViewPoints.size();
        for (i=size-1;i>=0;i--){
                if (_lstViewPoints[i]->GetSelected()==true){
                        DeletePoint(i);
                }
        }
        Refresh();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SelectPoint(int i, bool select)
{
        _lstViewPoints[i]->SetSelected(select);
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SelectLstPoints()
{
        // ToDo
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SelectAllPoints(bool select)
{
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                SelectPoint(i,select);
        }
}
//-----------------------------------------------------------------------------
void manualViewBaseContour:: SetIfViewControlPoints(bool ifShow)
{
        _viewControlPoints = ifShow;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour:: GetIfViewControlPoints()
{
        return _viewControlPoints;
}

// ----------------------------------------------------------------------------
void manualViewBaseContour::SetPointPosibleSelected(int id,bool select)
{
        _lstViewPoints[id]->SetPosibleSelected(select);
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetPointSelected(int id,bool select)
{
        _lstViewPoints[id]->SetSelected(select);
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SelectAllPossibleSelected(bool select)
{
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                SetPointPosibleSelected(i,select);
        }
}
// ----------------------------------------------------------------------------
int manualViewBaseContour::SelectPosiblePoint(int x, int y, int z)  // virtual
{
        SelectAllPossibleSelected(false);

    int id = GetIdPoint(x,y,z);
        if (id!=-1)
        {
                SetPointPosibleSelected(id,true);
        }
        return id;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour::SelectPosibleContour(int x, int y, int z)
{
        bool result=false;
        SetPosibleSelected(result);
    int id = GetIdPoint(x,y,z);
        if( !GetEditable() && !_selected && id!= -1)
        {
                result=true;
                SetPosibleSelected(result);
        }
        else
        {
                if ( (GetEditable()==true) && (id==-1 ) && (this->_lstViewPoints.size()>=2) )
                {
                        if (ifTouchContour(x,y,z)==true)
                        {
                                result=true;
                                SetPosibleSelected(result);
                        }
                }

                if (GetEditable()==false)
                {
                        if (ifTouchContour(x,y,z)==true)
                        {
                                result=true;
                                SetPosibleSelected(result);
                        }
                }


        }
        return result;
}
// ----------------------------------------------------------------------------
bool manualViewBaseContour::ifTouchContour(int x,int y, int z) // virtual
{
        return false;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::UnSelectPoint(int i){
        _lstViewPoints[i]->SetSelected(false);
        Refresh();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::UnSelectLstPoints(){
        // ToDo
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::UnSelectAllPoints(){
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                UnSelectPoint(i);
        }
        Refresh();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetModel(manualContourModel *manContModel){
        _manContModel=manContModel;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetWxVtkBaseView(wxVtkBaseView *wxvtkbaseview){
        _wxvtkbaseview = wxvtkbaseview;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::RefreshContour()  // Virtual
{
}
// ----------------------------------------------------------------------------
double* manualViewBaseContour::GetVectorPointsXManualContour(){
        double pp[3];
        int i,size = _sizePointsContour;
        double *vx = (double*)malloc(sizeof(double)*size);
        for (i=0;i<size;i++){
                _pts->GetPoint(i,pp);
                vx[i]=pp[0];
        }
        return vx;
}
// ----------------------------------------------------------------------------
double* manualViewBaseContour::GetVectorPointsYManualContour()
{
        double pp[3];
        int i,size = _sizePointsContour;
        double *vy = (double*)malloc(sizeof(double)*size);
        for (i=0;i<size;i++){
                _pts->GetPoint(i,pp);
                vy[i]=pp[1];
        }
        return vy;
}
// ----------------------------------------------------------------------------
double* manualViewBaseContour::GetVectorPointsZManualContour()
{
        double pp[3];
        int i,size = _sizePointsContour;
        double *vz = (double*)malloc(sizeof(double)*size);
        for (i=0;i<size;i++){
                _pts->GetPoint(i,pp);
                vz[i]=pp[2];
        }
        return vz;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::Refresh() // virtual
{
        if (_contourVtkActor!=NULL){
                RefreshContour();
        }
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                UpdateViewPoint(i);
                _lstViewPoints[i]->UpdateColorActor();
        }
        UpdateColorActor();

        if (_show_text==true)
        {
                RefreshText();
        }

        vtkRenderWindowInteractor *vri = _wxvtkbaseview->GetWxVTKRenderWindowInteractor ();
        if (vri==NULL)
        {
                _wxvtkbaseview->GetRenWin()->Render();
        }

}
// ----------------------------------------------------------------------------
void manualViewBaseContour::RefreshText()  // virtual
{
        if( _textActor!=NULL)
                _textActor -> SetInput("00");
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetColorNormalContour(double r, double g, double b)
{
        _coulorNormal_r = r;
        _coulorNormal_g = g;
        _coulorNormal_b = b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::GetColorNormalContour(double &r, double &g, double &b)
{
        r = _coulorNormal_r;
        g = _coulorNormal_g;
        b = _coulorNormal_b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetColorEditContour(double r, double g, double b)
{
        _coulorEdit_r = r;
        _coulorEdit_g = g;
        _coulorEdit_b = b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::GetColorEditContour(double &r, double &g, double &b)
{
        r = _coulorEdit_r;
        g = _coulorEdit_g;
        b = _coulorEdit_b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetColorSelectContour(double r, double g, double b)
{
        _coulorSelection_r = r;
        _coulorSelection_g = g;
        _coulorSelection_b = b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::GetColorSelectContour(double &r, double &g, double &b)
{
        r = _coulorSelection_r;
        g = _coulorSelection_g;
        b = _coulorSelection_b;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::UpdateColorActor()
{
        if (_contourVtkActor!=NULL)
        {
                _contourVtkActor->GetProperty()->SetLineWidth( _widthline );
                _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorNormal_r , _coulorNormal_g , _coulorNormal_b );
                if (_posibleSelected || (_posibleSelected && GetEditable() ) )
                {
                        _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorEdit_r , _coulorEdit_g , _coulorEdit_b );
                }
                if( _selected )
                {
                        _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorSelection_r , _coulorSelection_g , _coulorSelection_b );
                }
        }
}
// ----------------------------------------------------------------------------
int     manualViewBaseContour::GetIdPoint(int x, int y, int z) // virtual
{
        int ii = -1;
        if (_manContModel!=NULL){
                double xx = x;
                double yy = y;
                double zz = z;
                TransfromCoordViewWorld(xx,yy,zz);
                ii=_manContModel->GetIdPoint(xx,yy,zz,_range,-1);
        }
        return ii;
}

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


int manualViewBaseContour::GetNumberOfPoints()
{
        return _lstViewPoints.size();
}

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

//JSTG 25-02-08 ---------------------------------------------------------------
/*int manualViewBaseContour::GetNumberOfPointsSpline()
{
        return _sizePointsContour;
}*/
//----------------------------------------------------------------------------

//JSTG 25-02-08 ---------------------------------------------------------------
/*void manualViewBaseContour::SetNumberOfPointsSpline(int size)
{
        _sizePointsContour = size;
}*/
//----------------------------------------------------------------------------
// virtual
void manualViewBaseContour::TransfromCoordViewWorld(double &X, double &Y, double &Z, int type)  // Virtual
{
        _wxvtkbaseview->TransFromCoordScreenToWorld(X, Y, Z,false, type);


//EED 27 sep 2007
//   //EEDx6
//      wxVtk2DBaseView *wxvtk2Dbaseview = (wxVtk2DBaseView*)_wxvtkbaseview;
//      wxvtk2Dbaseview->TransformCoordinate_spacing_ModelToView(X,Y,Z);

}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetRange(int range)
{
        _range=range;
}
// ----------------------------------------------------------------------------
int     manualViewBaseContour::GetRange()
{
        return _range;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetZ(int z)
{
//      _Z=z;
}
// ----------------------------------------------------------------------------
int     manualViewBaseContour::GetZ()
{
//      return _Z;
        return 0;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::InitMove(int x, int y, int z) // virtual
{

}
// ----------------------------------------------------------------------------
void manualViewBaseContour::MoveContour(int x, int y, int z) // virtual
{
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::MoveContour(int horizontalUnits, int verticalUnits )// virtual
{

}
// ----------------------------------------------------------------------------
void manualViewBaseContour::GetMinMax( double &minX,double &minY, double &minZ, double &maxX, double &maxY, double &maxZ )// virtual
{
        double  pp[3];
        manualPoint *mp;
        int i;
        int size=_manContModel->GetSizeLstPoints();
        minX=99999;
        minY=99999;
        maxX=-99999;
        maxY=-99999;
        bool ifFindZ = minZ!=-1.0 && maxZ!=-1.0;
        if ( ifFindZ )
        {
                minZ=99999;
                maxZ=-99999;
        }
        for( i = 0; i < size; i++ )
        {
                mp=_manContModel->GetManualPoint(i);
                pp[0]=mp->GetX();
                pp[1]=mp->GetY();
                if ( ifFindZ )
                        pp[2]=mp->GetZ();

                // min X
                if (pp[0]<minX)
                {
                        minX=pp[0];
                }
                //min Y
                if (pp[1]<minY)
                {
                        minY=pp[1];
                }
                //max X
                if (pp[0]>maxX)
                {
                        maxX=pp[0];
                }
                // max Y
                if (pp[1]>maxY)
                {
                        maxY=pp[1];
                }
                if ( ifFindZ )
                {
                        // min Z
                        if (pp[2]<minZ)
                        {
                                minZ=pp[2];
                        }
                        // max Z
                        if (pp[2]>maxZ)
                        {
                                maxZ=pp[2];
                        }
                }
        }
        if ( size<1 )
        {
                minX = 0;
                maxX = 0;

                minY = 0;
                maxY = 0;

                minZ = 0;
                maxZ = 0;
        }
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::ClearContour()
{
        if (_contourVtkActor!=NULL){
                _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
        }
        DeleteVtkObjects();
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                ClearPoint(0);
        }
        Refresh();
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::ClearPoint(int id)
{
        DeletePoint(id);
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetVisible(bool ok)
{
        double opacity;
        if (ok==true)
        {
                opacity=1;
        } else {
                opacity=0.5;
        }
        vtkActor *actor;
        int i,size=_lstViewPoints.size();
        for (i=0;i<size;i++){
                actor = _lstViewPoints[i]->GetVtkActor();
                actor->GetProperty()->SetOpacity( opacity );
        }
        _contourVtkActor->GetProperty()->SetOpacity( opacity );
        _textActor->GetProperty()->SetOpacity( opacity );
        _textActor->SetInput("00");

}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetShowText(bool ok)
{
        _show_text = ok;
        if (_show_text==false)
        {
                _textActor->SetInput("00");
        }
}
// ----------------------------------------------------------------------------
wxVtkBaseView *manualViewBaseContour::GetWxVtkBaseView()
{
        return this->_wxvtkbaseview;
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::GetSpacing(double spc[3])
{
        spc[0] = _spc[0];
        spc[1] = _spc[1];
        spc[2] = _spc[2];
}
// ----------------------------------------------------------------------------
void manualViewBaseContour::SetSpacing(double spc[3])
{
        _spc[0] = spc[0];
        _spc[1] = spc[1];
        _spc[2] = spc[2];
}