ContourCrownWidget.cxx

Go to the documentation of this file.

#include "ContourCrownWidget.h"

#include <vtkImageMapToColors.h>
#include <vtkImageActor.h>

#include "wxVtk2DBaseView.h"
#include "vtkLookupTable.h"

//----------------------------------------------------------------------
  wxMaracasCoutourTool::wxMaracasCoutourTool(wxWindow *parent, wxVtkBaseView *wxvtkbaseview, vtkImageData* imagedata)
    : wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
  {
//EED    this->mbbtkContourCrown        = contourcrown;
    this->imagedata                     = imagedata;
        this->wxvtkbaseview             = wxvtkbaseview;
        wxPanel *panel                  = this;
    wxSizer *sizer                      = NULL;
        
        InitVtkImagesResult();

         vtkLookupTable *table = vtkLookupTable::New();
//       table->SetAlphaRange(128,255);
     table->SetRange(0, 255); // image intensity range
//   table->SetValueRange(0.0, 1.0); // from black to white
     table->SetValueRange(0.0, 255.0); // from black to white

         table->SetTableValue (0, 1.0 , 1.0 , 1.0 , 0.1 );
         table->SetTableValue (255, 1.0 , 1.0 , 0.0 , 0.1);

//       table->SetTableValue (0, 0.0 , 0.0 , 1.0 , 0.35 );
//       table->SetTableValue (255, 1.0 , 0.0 , 0.0 , 0.10);

     table->SetSaturationRange(0.0, 0.0); // no color saturation
     table->SetRampToLinear();
     table->Build();

        vtkImageMapToColors  *mapperImage = vtkImageMapToColors::New();
        mapperImage->SetLookupTable(table);
        mapperImage->SetInput( imagedataMaskResult );
        vtkImageActor *actorImage       = vtkImageActor::New();
        actorImage->SetInput( mapperImage->GetOutput() );
        actorImage->SetOpacity(1);

        wxvtkbaseview->GetRenderer()->AddActor(actorImage);

        // Widget interface
        wxButton *btnContourA   = new wxButton( panel, -1, _T("Crown Extern"));
        wxButton *btnContourB   = new wxButton( panel, -1, _T("Crown Intern"));
        wxButton *btnContourAB  = new wxButton( panel, -1, _T("Crown Extern and Intern"));

//JSTG 21-03-08 --------------------------------------------------------------------
        wxButton *btnSaveContour                = new wxButton( panel, -1, _T("Save Contour"));
        wxButton *btnSaveControlPoints  = new wxButton( panel, -1, _T("Save Control Points"));
//JSTG 11-04-08
        wxButton *btnEreaseLastContour  = new wxButton( panel, -1, _T("Erease Last Contour"));
        wxButton *btnEreaseLastCP               = new wxButton( panel, -1, _T("Erease Last Control Points"));
//----------------------------------------------------------------------------------

        wxFlexGridSizer *sizer1 = new wxFlexGridSizer(10); //Original Value = 10
    sizer1->Add(new wxStaticText(panel,-1,_T("  ")));
    sizer1->Add(new wxStaticText(panel,-1,_T("  ")));

    Connect(btnContourA->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::OnContourA  );
    Connect(btnContourB->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::OnContourB  );
    Connect(btnContourAB->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::OnContourAB );

//JSTG 21-03-08 ---------------------------------------------------------------------
        Connect(btnSaveContour->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::OnSaveContour );
        Connect(btnSaveControlPoints->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::OnSaveControlPoints );
//JSTG 11-04-08
        Connect(btnEreaseLastContour->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::EreaseLastContour );
        Connect(btnEreaseLastCP->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &wxMaracasCoutourTool::EreaseLastCP );        
//-----------------------------------------------------------------------------------

    sizer1->Add(btnContourA);
    sizer1->Add(btnContourB);
    sizer1->Add(btnContourAB);

//JSTG 21-03-08 --------------------
        sizer1->Add(btnSaveContour);
        sizer1->Add(btnSaveControlPoints);
//JSTG 11-04-08
        sizer1->Add(btnEreaseLastContour);
        sizer1->Add(btnEreaseLastCP);
//----------------------------------    
        sizer = sizer1;
        panel   ->      SetSizer(sizer);
    panel       ->      SetAutoLayout(true);
    panel       ->      Layout();  
        
}

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

  wxMaracasCoutourTool::~wxMaracasCoutourTool()
  {
  }

  // ------------------------------------------------------------------------
  wxVtkBaseView *wxMaracasCoutourTool::GetWxVtkBaseView()
        {
                return this->wxvtkbaseview;
        }


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

  void wxMaracasCoutourTool::ConfigureVTK()
  {
          double spc[3];
          this->imagedata->GetSpacing(spc);

        // Contorno 1
        _manContourControl_1    = new manualContourControler();
        _mContourModel_1                = new manualContourModel();
        _mViewContour_1                 = new manualViewContour();
        _mViewContour_1->SetModel( _mContourModel_1 );
        _mViewContour_1->SetWxVtkBaseView( this->wxvtkbaseview );
        _mViewContour_1->SetRange( 2 );
        _mViewContour_1->SetZ( 1000 );

//JSTG 18-06-07
        _mContourModel_1->SetNumberOfPointsSpline(100);


//EED 3 oct 2006
        _mViewContour_1->SetSpacing(spc);


//EED 3 oct 2006
        _mViewContour_1->SetColorNormalContour(0, 0, 1);
        _mViewContour_1->SetColorEditContour(0.5, 0.5, 0.5);


        _manContourControl_1->SetModelView( _mContourModel_1 , _mViewContour_1 );
        ((vtkInteractorStyleBaseView*)this->wxvtkbaseview->GetInteractorStyleBaseView())->AddInteractorStyleMaracas( _manContourControl_1 );
        _manContourControl_1->CreateNewManualContour();
        _manContourControl_1->SetActive(false);
        _mViewContour_1->RefreshContour();


        // Contorno 2
        _manContourControl_2    = new manualContourControler();
        _mContourModel_2                = new manualContourModel();
        _mViewContour_2                 = new manualViewContour();
        _mViewContour_2->SetModel( _mContourModel_2 );
        _mViewContour_2->SetWxVtkBaseView( this->wxvtkbaseview );
        _mViewContour_2->SetRange( 2 );
        _mViewContour_2->SetZ( 1000 );

//EED 3 oct 2006
        _mViewContour_2->SetSpacing(spc);

//EED 3 oct 2006
        _mViewContour_2->SetColorNormalContour(1, 0, 0);
        _mViewContour_2->SetColorEditContour(0.5, 0.5, 0.5);


        _manContourControl_2->SetModelView( _mContourModel_2 , _mViewContour_2 );
        ((vtkInteractorStyleBaseView*)this->wxvtkbaseview->GetInteractorStyleBaseView())->AddInteractorStyleMaracas( _manContourControl_2 );
        _manContourControl_2->CreateNewManualContour();
        _manContourControl_2->SetActive(false);
        _mViewContour_2->RefreshContour();

//      Refresh();      

//JSTG 16-06-08
        _contprop = new ContourPropagation();
 }

//JSTG 26-02-08 -------------------------------------------------------------------------------------------------------------
  void wxMaracasCoutourTool::SetControlPoints(  std::vector<double> *InVectorX, 
                                                                                                std::vector<double> *InVectorY, 
                                                                                                std::vector<double> *InVectorZ )
  {
        int lstSize;
        if (InVectorX!=NULL)
        {
                int i,size=InVectorX->size();
                if (size!=0)
                {
                        _mContourModel_1->DeleteAllPoints();
                        _mViewContour_1->DeleteContour();

                        for (i=0;i<size;i++)
                        {
                                lstSize = _mContourModel_1->AddPoint( (*InVectorX)[i] , (*InVectorY)[i] , (*InVectorZ)[i] );
                                _mViewContour_1->AddPoint();
                        }
                        //_manContourControl_1->CreateNewManualContour();
                        //_manContourControl_1->SetActive(true);
                        _mViewContour_1->CreateNewContour();
                        _mContourModel_1->UpdateSpline();
                        _mViewContour_1->RefreshContour();
                        //_mViewContour_1->Refresh ();
                } 
         } 
  }

// JSTG 26-02-08 ------------------------------------------------------------------------------
  void wxMaracasCoutourTool::GetSplinePoints(   std::vector<double> *pLstContourX,
                                                                                                std::vector<double> *pLstContourY,
                                                                                                std::vector<double> *pLstContourZ  )
  {
          int i;
          double x,y,z;
          _mContourModel_1->UpdateSpline();
          
          for(i=0; i<_mContourModel_1->GetNumberOfPointsSpline(); i++)
          {
                _mContourModel_1->GetSpline_i_Point( i, &x, &y, &z );
                pLstContourX->push_back(x);
                pLstContourY->push_back(y);
                //pLstContourY->push_back(z);                   //Fake Z -> For Visualization
                pLstContourZ->push_back(_zz);                   //True Z -> For processing
          }
  }
//---------------------------------------------------------------------------------------------

//------------------------------------------------------------------------
void wxMaracasCoutourTool::OnContourA(wxCommandEvent& event)
{
        _manContourControl_1 -> SetActive(true);
        _manContourControl_2 -> SetActive(false);
}
//------------------------------------------------------------------------
void wxMaracasCoutourTool::OnContourB(wxCommandEvent& event)
{
        _manContourControl_1 -> SetActive(false);
        _manContourControl_2 -> SetActive(true);
}
//------------------------------------------------------------------------
void wxMaracasCoutourTool::OnContourAB(wxCommandEvent& event)
{
        _manContourControl_1 -> SetActive(true);
        _manContourControl_2 -> SetActive(true);
}

//------------------------------------------------------------------------
void wxMaracasCoutourTool::GetMinMaxPoint(int *minPoint, 
                                                                                  int *maxPoint, 
                                                                                  manualViewBaseContour *manualviewbaseecontour,
                                                                                  manualContourModel *manualcontourmodel
                                                                                  )
{
        int i;
        //int   np  = manualviewbaseecontour->GetNumberOfPoints( );  // number of control points // JPRx

// JSTG 26-02-08 ---------------------------------------------------------------------------------------
        //int nps = manualviewbaseecontour->GetNumberOfPointsSpline(); // number of points in the spline
        int nps = manualcontourmodel->GetNumberOfPointsSpline(); // number of points in the spline
//------------------------------------------------------------------------------------------------------
        
// JSTG 26-02-08 ---------------------------------------------------------------------------------------
        //double x,y,z,t;
        double x,y,z;
        //double delta=( double ) ( np  ) / ( double ) ( nps  );
        manualcontourmodel->UpdateSpline();
        for (i=0; i<nps; i++)
        {
                //t= delta * (double)i;
                //manualcontourmodel->GetSplinePoint(t,x,y,z);
                manualcontourmodel->GetSpline_i_Point(i,&x,&y,&z);
                if (x<minPoint[0]){ minPoint[0]=(int)x; }
                if (y<minPoint[1]){ minPoint[1]=(int)y; }
                if (x>maxPoint[0]){ maxPoint[0]=(int)x; }
                if (y>maxPoint[1]){ maxPoint[1]=(int)y; }
        }
//------------------------------------------------------------------------------------------------------
}

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

int wxMaracasCoutourTool::AnalisisContourInside(int x, 
                                                                                                int y, 
                                                                                                manualViewBaseContour *manualviewbaseecontour,
                                                                                                manualContourModel *manualcontourmodel
                                                                                                )
{
        int result = 0;
        int i;
        int     np  = manualviewbaseecontour->GetNumberOfPoints( );  // number of control points

// JSTG 26-02-08 ---------------------------------------------------------------------------------------
        //int nps = manualviewbaseecontour->GetNumberOfPointsSpline(); // number of points in the spline
        int nps = manualcontourmodel->GetNumberOfPointsSpline(); // number of points in the spline
        //double x1,y1,z1,x2,y2,z2,t;
        double x1,y1,z1,x2,y2,z2;
        double xx1, yy1,xx2, yy2;
        //double delta=( double ) ( np  ) / ( double ) ( nps  );
        manualcontourmodel->UpdateSpline();
//------------------------------------------------------------------------------------------------------
        double d;
        bool ok;
        if (np>=2)
        {
// JSTG 26-02-08 ---------------------------------------------------------------------------------------
                nps--;
                //manualcontourmodel->GetSplinePoint(0,x1,y1,z1);
                manualcontourmodel->GetSpline_i_Point(0,&x1,&y1,&z1);
                for (i=1; i<=nps; i++)
                {
                        ok=false;
                        //t= delta * (double)(i%nps);
                        //manualcontourmodel->GetSplinePoint(t,x2,y2,z2);
                        manualcontourmodel->GetSpline_i_Point(i,&x2,&y2,&z2);
//------------------------------------------------------------------------------------------------------
                        //by triangle similarity
                        if ( ((y1<y2)&&(y>=y1)&&(y<y2)) || ((y1>y2)&&(y<=y1)&&(y>y2)) )
                        {
                                if (y1<y2) { xx1=x1; yy1=y1; xx2=x2; yy2=y2;} else { xx1=x2; yy1=y2; xx2=x1; yy2=y1; } 
                                d = ( fabs(xx2-xx1)*(y-yy1) ) / (yy2-yy1) ;
                                if (  ((xx1<xx2)&&(x<(xx1+d)))  ||  ((xx1>xx2)&&(x<(xx1-d)))  ) { result++; }
                        }
                        x1=x2; y1=y2; z1=z2;
                }
        }
        return result;
}

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


bool wxMaracasCoutourTool::isInside(int x, int y)
{
        bool result=false;

        int ext[6];
        imagedataValueResult->GetExtent(ext);

        if ((x>=0) && (x<=ext[1]) && (y>=0) && (y<=ext[3]))
        {
                int numberLeftA=AnalisisContourInside(x,y,_mViewContour_1, _mContourModel_1); 
                int numberLeftB=AnalisisContourInside(x,y,_mViewContour_2, _mContourModel_2);
                if ( (numberLeftA+numberLeftB) % 2 ==1){        result = true;  } 
        }

        return result;
}

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

double wxMaracasCoutourTool::GetDataValue(int x, int y)
{
        unsigned short *p;
        wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)wxvtkbaseview;
        int z = (int)wxvtk2dbaseview->GetVtkBaseData()->GetZ();
        //JSTG 13-03-08-----
        _zz = z;
        //------------------
        p = (unsigned short *)imagedata->GetScalarPointer(x,y,z);
        return (double)(*p);
}

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

void wxMaracasCoutourTool::PutVtkImageDataResultValue( int x, int y, double value )
{
        unsigned short *pValue;
        unsigned short *pMask;
        pValue  = (unsigned short *)imagedataValueResult->GetScalarPointer(x,y,0);
        pMask   = (unsigned short *)imagedataMaskResult->GetScalarPointer(x,y,0);
        *pMask  = 255;
        *pValue = (unsigned short)value;
}

//------------------------------------------------------------------------
void wxMaracasCoutourTool::ResetImageResult()
{
        unsigned short *pValue;
        unsigned short *pMask;
        pValue  = (unsigned short *)imagedataValueResult->GetScalarPointer(0,0,0);
        pMask   = (unsigned short *)imagedataMaskResult->GetScalarPointer(0,0,0);
        
        int ext[6];
        imagedataValueResult->GetExtent(ext);

        int i,size = (ext[1]-ext[0]+1) * (ext[3]-ext[2]+1); 
        for(i=0; i<size; i++)
        {
                *pMask  = 0;
                *pValue = 0;
                pMask++;
                pValue++;
        }
}
//------------------------------------------------------------------------

void wxMaracasCoutourTool::GetValuesInsideCrown(std::vector<double> *pLstValue,
                                                                                                std::vector<double> *pLstValuePosX,
                                                                                                std::vector<double> *pLstValuePosY,
                                                                                                std::vector<double> *pLstValuePosZ)
{
  pLstValue->clear();
  pLstValuePosX->clear();
  pLstValuePosY->clear();
  pLstValuePosZ->clear();
  ResetImageResult();
  
        int minPoint[2];
        int maxPoint[2];
        int i,j;
        double value;


        minPoint[0]=999999;
        minPoint[1]=999999;
        maxPoint[0]=-999999;
        maxPoint[1]=-999999;

        GetMinMaxPoint(minPoint,maxPoint, _mViewContour_1, _mContourModel_1);
        GetMinMaxPoint(minPoint,maxPoint, _mViewContour_2, _mContourModel_2);

        for (j=minPoint[1]; j<maxPoint[1]; j++)
        {
                for (i=minPoint[0]; i<maxPoint[0]; i++)
                {
                        if (isInside(i,j)==true)
                        {
                                value = GetDataValue(i,j);
                                PutVtkImageDataResultValue(i,j,  value );
                                pLstValue               -> push_back( value );
                                pLstValuePosX   -> push_back( i );
                                pLstValuePosY   -> push_back( j );
                                pLstValuePosZ   -> push_back( -1 );
                        } // if
                } // for
        } // for

        imagedataValueResult->Modified();
        imagedataMaskResult->Modified();
}

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

vtkImageData *wxMaracasCoutourTool::GetVtkImageValueResult()
{
        return imagedataValueResult;
}
//------------------------------------------------------------------------
vtkImageData *wxMaracasCoutourTool::GetVtkImageMaskResult()
{
        return imagedataMaskResult;
}
// ------------------------------------------------------------------------
void wxMaracasCoutourTool::InitVtkImagesResult()
  {
          int ext[6];
          int newDim[3];
          double spc[3];
          int scalartype;

          imagedata->GetSpacing(spc);
          imagedata->GetExtent(ext);
          newDim[0]=ext[1]-ext[0]+1;
          newDim[1]=ext[3]-ext[2]+1;
          newDim[2]=1;
          scalartype = imagedata->GetScalarType();

          imagedataValueResult = vtkImageData::New();
//        imagedataValueResult->SetScalarType(scalartype);
          imagedataValueResult->SetScalarTypeToUnsignedShort();
          imagedataValueResult->SetSpacing(spc);
          imagedataValueResult->SetDimensions( newDim );
          imagedataValueResult->AllocateScalars();

          imagedataMaskResult  = vtkImageData::New();
//        imagedataMaskResult->SetScalarType(scalartype);
          imagedataMaskResult->SetScalarTypeToUnsignedShort();
          imagedataMaskResult->SetSpacing(spc);
          imagedataMaskResult->SetDimensions( newDim );
          imagedataMaskResult->AllocateScalars();

  }

//JSTG 21-03-08 -------------------------------------------------------------------
void wxMaracasCoutourTool::OnSaveContour(wxCommandEvent& event)
{
        //For write the actual time and date
        /*
        time_t timer;
        struct tm *tblock;
        timer = time(NULL);
        tblock = localtime(&timer);
        */

        FILE *fd;
        
        //WHERE CAN I MAKE THEM DELETE!!!
        _mpoint = new manualPoint();

        std::vector<double> tempX;
        std::vector<double> tempY;
        std::vector<double> tempZ;
        tempX.clear();
        tempY.clear();
        tempZ.clear();

        int size = _mContourModel_1->GetNumberOfPointsSpline();
        wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)wxvtkbaseview;
        int z = (int)wxvtk2dbaseview->GetVtkBaseData()->GetZ();
        double xx, yy, zz;

        fd = fopen("C:/bbtk_JS/data/SavedContours.txt","a");
        //fprintf(fd,"Date %s", asctime(tblock) );
        fprintf(fd,"\nPointsContour %d", size );
        for(int i=0; i<size; i++)
        {
                _mContourModel_1->GetSpline_i_Point(i,&xx,&yy,&zz);
                fprintf(fd,"\n%f %f %d",xx,yy,z);       //z -> Contain the true value || zz -> Contain the cheating value for visualitation 
                tempX.push_back(xx);
                tempY.push_back(yy);
                tempZ.push_back(z);
        }
        fclose(fd);

//JSTG 16-06-08
        _contprop->appendContour(&tempX,&tempY,&tempZ);
}

//JSTG 21-03-08 --------------------------------------------------------------------
void wxMaracasCoutourTool::OnSaveControlPoints(wxCommandEvent& event)
{
        //For write the actual time and date
        /*
        time_t timer;
        struct tm *tblock;
        timer = time(NULL);
        tblock = localtime(&timer);
        */
        FILE *fd;
        _mpoint = new manualPoint();
        int size = _mContourModel_1->GetSizeLstPoints();
        wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)wxvtkbaseview;
        int z = (int)wxvtk2dbaseview->GetVtkBaseData()->GetZ();

        fd = fopen("C:/bbtk_JS/data/SavedManualPoints.txt","a");
        //fprintf(fd,"Date %s", asctime(tblock) );
        fprintf(fd,"\nNumberOfControlPoints %d", size );
        for(int i=0; i<size; i++)
        {
                _mpoint = _mContourModel_1->GetManualPoint(i);
                fprintf(fd,"\n%f %f %d",_mpoint->GetX(),_mpoint->GetY(),z);
        }
        fclose(fd);
}
//----------------------------------------------------------------------------------
void wxMaracasCoutourTool::EreaseLastContour(wxCommandEvent& event)
{
        char firstline[30];
        int     size = 0,i,j;
        double x,y;
        int z;          
        
        _tempCX.clear();
        _tempCY.clear();
        _tempCZ.clear();
        _tempCPX.clear();
        _tempCPY.clear();
        _tempCPZ.clear();
        _SizesC.clear();
        _SizesCP.clear();

        FILE* fd;
        fd = fopen("C:/bbtk_JS/data/SavedContours.txt","r");
        if(fd!=NULL)
        {
                while(!feof(fd))        
                {
//              //fscanf(fd," %s %d",&firstline,&size); // JPRx
                        fscanf(fd," %s %d",firstline,&size);

                        _SizesC.push_back(size);
                        for(j=0; j<size; j++)
                        {
                                fscanf(fd,"%lf %lf %d",&x,&y,&z);
                                _tempCX.push_back(x);
                                _tempCY.push_back(y);
                                _tempCZ.push_back(z);
                        }
                }
        }
        else
        {
                printf("\nJSTG - wxMaracasCoutourTool::EreaseLastContour - FILE NOT FOUND");
        }
        fclose(fd);

        for(i=0; i<size; i++)
        {
                _tempCX.pop_back();
                _tempCY.pop_back();
                _tempCZ.pop_back();
        }
        _SizesC.pop_back();
        
        fd = fopen("C:/bbtk_JS/data/SavedContours.txt","w");
        if(fd!=NULL)
        {
                int cont = 0;
                for(i=0; i<(int)(_SizesC.size()); i++)
                {
                        fprintf(fd,"\nNumberOfPoints %d", _SizesC[i] );
                        for(j=0; j<_SizesC[i]; j++)
                        {
                                fprintf(fd,"\n%f %f %d",_tempCX[j+cont],_tempCY[j+cont],_tempCZ[j+cont]);
                        }
                        cont = _SizesC[i];
                }
        }
        else
        {
                printf("\nJSTG - wxMaracasCoutourTool::EreaseLastContour - FILE NOT FOUND");
        }
        fclose(fd);

}
//----------------------------------------------------------------------------------
void wxMaracasCoutourTool::EreaseLastCP(wxCommandEvent& event)
{
        char firstline[30];
        int     size = 0,i,j;
        double x,y;
        int z;          
        
        _tempCX.clear();
        _tempCY.clear();
        _tempCZ.clear();
        _tempCPX.clear();
        _tempCPY.clear();
        _tempCPZ.clear();
        _SizesC.clear();
        _SizesCP.clear();

        FILE* fd;
        fd = fopen("C:/bbtk_JS/data/SavedManualPoints.txt","r");
        if(fd!=NULL)
        {
                while(!feof(fd))        
                {
                        //fscanf(fd,"");  // ?? JPRx
                        //fscanf(fd," %s %d",&firstline,&size);// JPRx
                        fscanf(fd," %s %d",firstline,&size); 
                        _SizesC.push_back(size);
                        for(j=0; j<size; j++)
                        {
                                fscanf(fd,"%lf %lf %d",&x,&y,&z);
                                _tempCX.push_back(x);
                                _tempCY.push_back(y);
                                _tempCZ.push_back(z);
                        }
                }
        }
        else
        {
                printf("\nJSTG - wxMaracasCoutourTool::EreaseLastContour - FILE NOT FOUND");
        }
        fclose(fd);

        for(i=0; i<size; i++)
        {
                _tempCX.pop_back();
                _tempCY.pop_back();
                _tempCZ.pop_back();
        }
        _SizesC.pop_back();
        
        fd = fopen("C:/bbtk_JS/data/SavedManualPoints.txt","w");
        if(fd!=NULL)
        {
                int cont = 0;
                for(i=0; i<(int)(_SizesC.size()); i++)
                {
                        fprintf(fd,"\nNumberOfControlPoints %d", _SizesC[i] );
                        for(j=0; j<_SizesC[i]; j++)
                        {
                                fprintf(fd,"\n%f %f %d",_tempCX[j+cont],_tempCY[j+cont],_tempCZ[j+cont]);
                        }
                        cont = _SizesC[i];
                }
        }
        else
        {
                printf("\nJSTG - wxMaracasCoutourTool::EreaseLastContour - FILE NOT FOUND");
        }
        fclose(fd);
}
//----------------------------------------------------------------------------------