manualViewContour.cpp

Go to the documentation of this file.

#include "manualViewContour.h"

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

manualViewContour::manualViewContour()
{
        _id_viewPoint_for_text  =       0;
        _mesureScale                    =       1;
        _initialConoturModel = new manualContourModel();
}
// ----------------------------------------------------------------------------
manualViewContour::~manualViewContour()
{
        delete _initialConoturModel;
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
manualViewContour * manualViewContour :: Clone()
{
        manualViewContour * clone = new manualViewContour();
        CopyAttributesTo(clone);
        return clone;
}

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

void manualViewContour::CopyAttributesTo( manualViewContour * cloneObject)
{
        // Call to Fathers object
        manualViewBaseContour::CopyAttributesTo(cloneObject);

        cloneObject->SetMesureScale(_mesureScale);
}

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

int manualViewContour::GetType() // virtual
{
        return 1;
}

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

void manualViewContour::Save(FILE *pFile)
{
        manualViewBaseContour::Save(pFile);
}

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

void manualViewContour::Open(FILE *pFile)
{
}



// ----------------------------------------------------------------------------
void manualViewContour::RefreshContour() // virtual
{

        int i,np,nps;

//JSTG 25-02-08 --------------------
        //double t,delta, x,y,z;
        double x,y,z;
//----------------------------------

        _manContModel->UpdateSpline();
    np  = GetNumberOfPoints( );
        //nps = GetNumberOfPointsSpline();
    nps = _manContModel->GetNumberOfPointsSpline();
        //delta=( double ) ( np  ) / ( double ) ( nps-1  );             //JSTG 25-02-08


        if ( _pts!=NULL )
        {
                if (np>=2  )
                {
                        for( i = 0; i < nps; i++ )
                        {
//JSTG 25-02-08 ------------------------------------------------
                                //t = delta * (double)i;
                                //_manContModel->GetSplinePoint(t,x,y,z);
                                _manContModel->GetSpline_i_Point(i,&x,&y,&z);
//--------------------------------------------------------------
        // EED 27 sep 2006
        //                      _pts->SetPoint(i, x,y,z );
                                _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );


                        }// for
                }
                else
                {
                                _pts->SetPoint(0, 0 , 0 , 0);
                                _pts->SetPoint(1, 0 , 0 , 0);
                } // if
        }
}

// ----------------------------------------------------------------------------
void manualViewContour::RefreshText()  // virtual
{
        if ((_textActor!=NULL) && ( _textActor->GetProperty()->GetOpacity()!=0 )){
                int size = GetNumberOfPoints();
                char text[50];
                char resultText[50];
                strcpy(resultText," ");
                if (size==2)
                {
                        strcpy(resultText,"L= ");
                        gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
                        strcat(resultText,text);
                }
                if (size>2)
                {
                        if (_manContModel->IfCloseContour()==true)
                        {
                                strcpy(resultText,"P= ");
                                gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
                                strcat(resultText,text);
                                gcvt ( _mesureScale * _mesureScale * this->_manContModel->GetPathArea() , 5, text );
                                strcat(resultText,"   A= ");
                                strcat(resultText,text);
                        } else {
                                strcpy(resultText,"L= ");
                                gcvt (  _mesureScale * this->_manContModel->GetPathSize() , 5, text );
                                strcat(resultText,text);
                        }
                }

                _textActor->SetInput(resultText);
                
                if (size>=1){

                        int i;
                        for (i=0; i<size; i++)
                        {
                                if (_lstViewPoints[i]->GetPosibleSelected()==true)
                                {
                                        _id_viewPoint_for_text = i;
                                }
                        }

                        int id = _id_viewPoint_for_text;
                        double px = _manContModel->GetManualPoint(id)->GetX();
                        double py = _manContModel->GetManualPoint(id)->GetY();

                        //EED 27 sep 2006
                        px=px*_spc[0];
                        py=py*_spc[1];

                        _textActor->SetPosition(px+GetRange()+1,py);
                }

        }
}

// ----------------------------------------------------------------------------
bool manualViewContour::ifTouchContour(int x,int y,int z){
        bool result=false;
        double xx=x;
        double yy=y;
        double zz=z;
        double ppA[3];
        double ppB[3];
        double d1,d2,d3;
        TransfromCoordViewWorld(xx,yy,zz);

//EED 27 sep 2006
        xx = xx * _spc[0];
        yy = yy * _spc[1];
        zz = zz * _spc[2];

    unsigned int i, nps,nps_t;
    nps   = _sizePointsContour;
        
        if (this->_manContModel->IfCloseContour()==true)
        {
                nps_t = nps;
        } else {
                nps_t = nps-1;
        }

        
        for( i = 0; i < nps_t; i++ ) 
        {
                _pts->GetPoint(i%nps, ppA);
                _pts->GetPoint((i+1)%nps, ppB);
                d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
                d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
                d3= sqrt( (ppB[0]-ppA[0])*(ppB[0]-ppA[0]) + (ppB[1]-ppA[1])*(ppB[1]-ppA[1]) + (ppB[2]-ppA[2])*(ppB[2]-ppA[2]));


                if (  ((d1+d2)>=d3) &&  ((d1+d2)<=d3*1.3) ) 
                {
                        result=true;
                        i=nps;
                }
        }
        
        return result;
}

// ----------------------------------------------------------------------------
void manualViewContour::DeletePoint(int id) // virtual
{
        if (_lstViewPoints.size()>2)
        {
                manualViewBaseContour::DeletePoint( id );
        }
}
// ----------------------------------------------------------------------------

void manualViewContour::ClearPoint(int id)
{
        manualViewBaseContour::DeletePoint( id );
}

//-------------------------------------------------------------------
void manualViewContour::SetMesureScale(double mesureScale)
{
        _mesureScale = mesureScale;
}
//-------------------------------------------------------------------
void manualViewContour::InitMove(int x, int y, int z)
{
        _initialConoturModel->DeleteAllPoints();

        manualPoint *mp = NULL;
        double XX=x;
        double YY=y;
        double ZZ=z;
        TransfromCoordViewWorld(XX,YY,ZZ);

        int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
        for ( i=0; i<manualPointsSZ; i++ )
        {
                mp = _manContModel->GetManualPoint( i );
                this->_initialConoturModel->AddPoint( mp->GetX() - XX, mp->GetY() - YY, mp->GetZ() );
        }
}
//-------------------------------------------------------------------
void manualViewContour::MoveContour(int x, int y, int z)
{
        manualPoint *mpOrigin = NULL;
        manualPoint *mpMoving = NULL;
        double XX=x;
        double YY=y;
        double ZZ=z;

        TransfromCoordViewWorld(XX,YY,ZZ);

        int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
        for ( i=0; i<manualPointsSZ; i++ )
        {
                mpOrigin = _manContModel->GetManualPoint( i );
                mpMoving = _initialConoturModel->GetManualPoint(i);
                mpOrigin->SetPoint( mpMoving->GetX()+XX, mpMoving->GetY() + YY, mpMoving->GetZ() );
        }
        UpdateViewPoints();
}
void manualViewContour::MoveContour(int horizontalUnits, int verticalUnits )
{
        manualPoint *mpOrigin = NULL;

        int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
        for ( i=0; i<manualPointsSZ; i++ )
        {
                mpOrigin = _manContModel->GetManualPoint( i );
                mpOrigin->SetPoint( mpOrigin->GetX()+horizontalUnits, mpOrigin->GetY()+verticalUnits, mpOrigin->GetZ() );
        }
        UpdateViewPoints();
}

---