+++ /dev/null
-
-#include <vtkActor.h>
-#include <vtkProperty.h>
-
-#include <vtkCellArray.h>
-#include <vtkRenderer.h>
-#include <vtkCoordinate.h>
-#include <vtkTextProperty.h>
-#include <vtkTextActor.h>
-#include <vtkProperty2D.h>
-#include <vtkPointPicker.h>
-#include "widgets/UtilVtk3DGeometriSelection.h"
-
-
-#include "manualContour.h"
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-manualPoint::manualPoint(){
-}
-// ----------------------------------------------------------------------------
-manualPoint::~manualPoint(){
-}
-// ----------------------------------------------------------------------------
-void manualPoint::SetPoint(double x,double y,double z){
- _x=x;
- _y=y;
- _z=z;
-}
-// ----------------------------------------------------------------------------
-void manualPoint::SetPointX(double x){
- _x=x;
-}
-// ----------------------------------------------------------------------------
-void manualPoint::SetPointY(double y){
- _y=y;
-}
-// ----------------------------------------------------------------------------
-void manualPoint::SetPointZ(double z){
- _z=z;
-}
-// ----------------------------------------------------------------------------
-double manualPoint::GetX(){
- return _x;
-}
-// ----------------------------------------------------------------------------
-double manualPoint::GetY(){
- return _y;
-}
-// ----------------------------------------------------------------------------
-double manualPoint::GetZ(){
- return _z;
-}
-// ----------------------------------------------------------------------------
-manualPoint * manualPoint :: Clone()
-{
- manualPoint * clone = new manualPoint();
- clone->SetPoint( GetX(), GetY(), GetZ());
- return clone;
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-manualContourModelCircle::manualContourModelCircle()
-: manualContourModel()
-{
-}
-
-manualContourModelCircle::~manualContourModelCircle()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualContourModelCircle * manualContourModelCircle :: Clone() // virtual
-{
- manualContourModelCircle * clone = new manualContourModelCircle();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourModelCircle::CopyAttributesTo( manualContourModelCircle * cloneObject)
-{
- // Fathers object
- manualContourModel::CopyAttributesTo(cloneObject);
-}
-
-//----------------------------------------------------------------
-int manualContourModelCircle::GetTypeModel() //virtual
-{
- return 3;
-}
-
-//----------------------------------------------------------------
-void manualContourModelCircle::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
-{
- double angle = _deltaAngle*i;
- *x = _radio*cos(angle) + _centerX;
- *y = _radio*sin(angle) + _centerY;
- *z = _centerZ;
-}
-
-//
-// ---------------------------------------------------------------------------
-void manualContourModelCircle::UpdateSpline() // virtal
-{
- manualPoint *mpA,*mpB;
- double difX,difY;
- int np = GetSizeLstPoints( );
- int nps = GetNumberOfPointsSpline();
- _deltaAngle=(3.14159265*2)/(nps-1);
-
- if (np==2){
- mpA = GetManualPoint(0);
- mpB = GetManualPoint(1);
- difX = mpA->GetX() - mpB->GetX();
- difY = mpA->GetY() - mpB->GetY();
- _radio = sqrt( difX*difX + difY*difY );
- _centerX = mpA->GetX();
- _centerY = mpA->GetY();
- _centerZ = mpA->GetZ();
- } else {
- _radio = -1;
- _centerX = -1;
- _centerY = -1;
- _centerZ = -1;
- }
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-//AD: 02-09
-
-manualContourModelLine::manualContourModelLine()
-: manualContourModel()
-{
- SetNumberOfPointsSpline(20);
- this->SetCloseContour(false);
-}
-
-manualContourModelLine::~manualContourModelLine()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualContourModelLine * manualContourModelLine :: Clone() // virtual
-{
- manualContourModelLine * clone = new manualContourModelLine();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourModelLine::CopyAttributesTo( manualContourModelLine * cloneObject)
-{
- manualContourModel::CopyAttributesTo(cloneObject);
-}
-
-//----------------------------------------------------------------
-int manualContourModelLine::GetTypeModel() //virtual
-{
- return 6;
-}
-
-
-//----------------------------------------------------------------
-/*
-void manualContourModelLine::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtual
-{
- int np = GetSizeLstPoints();
- if (np==0)
- {
- *x = 0;
- *y = 0;
- *z = 0;
- }
- if (np==1)
- {
- manualPoint *mp;
- mp = GetManualPoint(0);
- *x = mp->GetX();
- *y = mp->GetY();
- *z = mp->GetZ();
- }
- if (np==2)
- {
- manualPoint *mp;
-
- if (i==0)
- {
- mp = GetManualPoint(0);
- }
- else if (i==1)
- {
- mp = GetManualPoint(1);
- }
-
- *x = mp->GetX();
- *y = mp->GetY();
- *z = mp->GetZ();
- }
-
-}
-*/
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualContourModelBullEye::manualContourModelBullEye()
-: manualContourModel()
-{
- _numberPointsSlineBySector=101; // impaire
-}
-
-manualContourModelBullEye::~manualContourModelBullEye()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualContourModelBullEye * manualContourModelBullEye :: Clone() // virtual
-{
- manualContourModelBullEye * clone = new manualContourModelBullEye();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourModelBullEye::CopyAttributesTo( manualContourModelBullEye * cloneObject)
-{
- // Fathers object
- manualContourModel::CopyAttributesTo(cloneObject);
-}
-
-//----------------------------------------------------------------
-int manualContourModelBullEye::GetTypeModel() //virtual
-{
- return 4;
-}
-
-//----------------------------------------------------------------
-int manualContourModelBullEye::GetNumberOfPointsSplineSectorBulleEje()
-{
- return _numberPointsSlineBySector;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::SetNumberOfPointsSplineSectorBulleEje(int numpoints)
-{
- this->_numberPointsSlineBySector = numpoints;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::AddSector( double radioA,
- double radioB,
- double ang,
- double angDelta)
-{
- manualContourModelBullEyeSector *modelSector = new manualContourModelBullEyeSector();
- modelSector->SetSector(radioA,radioB,ang,angDelta);
- modelSector->SetNumberOfPointsSpline( this->GetNumberOfPointsSplineSectorBulleEje() );
- _lstModelBullEyeSector.push_back(modelSector);
-}
-
-//----------------------------------------------------------------
-manualContourModelBullEyeSector * manualContourModelBullEye::GetModelSector(int id)
-{
- return _lstModelBullEyeSector[id];
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::GetSector(int id,
- double *radioA,
- double *radioB,
- double *ang,
- double *angDelta)
-{
- _lstModelBullEyeSector[id]->GetSector(radioA,radioB,ang,angDelta);
-}
-
-void manualContourModelBullEye::UpdateSpline() // virtual
-{
- manualContourModel::UpdateSpline();
-
- if (this->GetSizeLstPoints()>2){
- double cx,cy;
- double ww,hh;
- manualPoint *mpA = GetManualPoint(0);
- manualPoint *mpB = GetManualPoint(2);
- cx = (mpA->GetX() + mpB->GetX()) / 2.0;
- cy = (mpA->GetY() + mpB->GetY()) / 2.0;
- ww = fabs( mpA->GetX() - mpB->GetX() )/2.0;
- hh = fabs( mpA->GetY() - mpB->GetY() )/2.0;
- int i,size = _lstModelBullEyeSector.size();
- for (i=0;i<size;i++)
- {
- _lstModelBullEyeSector[i]->SetCenter(cx,cy);
- _lstModelBullEyeSector[i]->SetSize(ww,hh);
- } // for
- }
-}
-
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::ResetSectors()
-{
- int i,size=_lstModelBullEyeSector.size();
- for (i=0;i<size;i++)
- {
- delete _lstModelBullEyeSector[i];
- }
- _lstModelBullEyeSector.clear();
-}
-
-//----------------------------------------------------------------
-int manualContourModelBullEye::GetSizeOfSectorLst()
-{
- return _lstModelBullEyeSector.size();
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::Save(FILE *ff) // virtual
-{
- manualContourModel::Save(ff);
- int i,size = GetSizeOfSectorLst();
- fprintf(ff,"numberOfSections %d \n",size);
- for ( i=0 ; i<size ; i++ )
- {
- _lstModelBullEyeSector[i]->Save(ff);
- }
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEye::Open(FILE *ff) // virtual
-{
- manualContourModel::Open(ff);
-
- ResetSectors();
-
- char tmp[255];
- int i;
- int numberOfSections;
-// double radioA,radioB,ang,deltaAng;
-
- fscanf(ff,"%s",tmp); // NumberOfSections
- fscanf(ff,"%s",tmp); // ##
- numberOfSections = atoi(tmp);
- for (i=0;i<numberOfSections;i++)
- {
- AddSector(0,1,90,0);
- _lstModelBullEyeSector[i]->Open(ff);
- }
-
-}
-
-// ----------------------------------------------------------------------------
-std::vector<manualContourModel*> manualContourModelBullEye::ExploseModel( )
-{
-//EED004
- std::vector<manualContourModel*> lstTmp;
- int i,iSize=_lstModelBullEyeSector.size();
- for (i=0;i<iSize;i++)
- {
- lstTmp.push_back( _lstModelBullEyeSector[i] );
- }
- return lstTmp;
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualContourModelBullEyeSector::manualContourModelBullEyeSector()
-: manualContourModel()
-{
-}
-
-manualContourModelBullEyeSector::~manualContourModelBullEyeSector()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualContourModelBullEyeSector * manualContourModelBullEyeSector :: Clone() // virtual
-{
- manualContourModelBullEyeSector * clone = new manualContourModelBullEyeSector();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourModelBullEyeSector::CopyAttributesTo( manualContourModelBullEyeSector * cloneObject)
-{
- // Fathers object
- manualContourModel::CopyAttributesTo(cloneObject);
-}
-
-//----------------------------------------------------------------
-int manualContourModelBullEyeSector::GetTypeModel() //virtual
-{
- return 5;
-}
-
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::SetSector( double radioA,
- double radioB,
- double ang,
- double angDelta)
-{
- _radioA = radioA;
- _radioB = radioB;
- _ang = ang*3.14159265/180.0;
- _angDelta = angDelta*3.14159265/180.0;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::GetSector(
- double *radioA,
- double *radioB,
- double *ang,
- double *angDelta)
-{
- *radioA = _radioA;
- *radioB = _radioB;
- *ang = _ang;
- *angDelta = _angDelta;
-}
-
-// ----------------------------------------------------------------------------
-void manualContourModelBullEyeSector::SetCenter(double cx,double cy)
-{
- _cx = cx;
- _cy = cy;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::SetSize(double ww,double hh)
-{
- _ww = ww;
- _hh = hh;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::GetSpline_i_Point(int i, double *x, double *y, double *z)
-{
-//EED004
-
- int ii,nps;
-// double x,y,z;
- double ang,angcos, angsin;
- double radio;
-
- nps = GetNumberOfPointsSpline() - 3;
-
- if (i==GetNumberOfPointsSpline()-1)
- {
- i=0;
- }
-
- if (i<=nps/2)
- {
- ii=i;
- radio=_radioA;
- } else {
- ii=nps-i+1;
- radio=_radioB;
- }
- ang = ((double)ii/(nps/2))*_angDelta + _ang;
- angcos = cos(ang);
- angsin = sin(ang);
-
- *x = _ww*radio*angcos + _cx;
- *y = _hh*radio*angsin + _cy;
- *z= 900;
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::Save(FILE *ff) // virtual
-{
- manualContourModel::Save(ff);
- fprintf(ff,"rA= %f rB= %f ang= %f deltaAng= %f\n", _radioA,_radioB, _ang , _angDelta);
-}
-
-//----------------------------------------------------------------
-void manualContourModelBullEyeSector::Open(FILE *ff) // virtual
-{
- char tmp[255];
- fscanf(ff,"%s",tmp); // TypeModel
- fscanf(ff,"%s",tmp); // ##
-
- manualContourModel::Open(ff);
-
-
- fscanf(ff,"%s",tmp); // radioA=
- fscanf(ff,"%s",tmp); // radioA
- _radioA = atof(tmp);
-
- fscanf(ff,"%s",tmp); // radioB=
- fscanf(ff,"%s",tmp); // radioB
- _radioB = atof(tmp);
-
- fscanf(ff,"%s",tmp); // ang=
- fscanf(ff,"%s",tmp); // ang
- _ang = atof(tmp);
-
- fscanf(ff,"%s",tmp); // deltaAng=
- fscanf(ff,"%s",tmp); // deltaAng
- _angDelta = atof(tmp);
-}
-
-
-
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-
-//JSTG 25-02-08 --------------------------------------------------
-manualContourModelRoi::manualContourModelRoi()
-: manualContourModel()
-{
- SetNumberOfPointsSpline(5);
-}
-
-manualContourModelRoi::~manualContourModelRoi()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualContourModelRoi * manualContourModelRoi :: Clone() // virtual
-{
- manualContourModelRoi * clone = new manualContourModelRoi();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourModelRoi::CopyAttributesTo( manualContourModelRoi * cloneObject)
-{
- // Fathers object
- manualContourModel::CopyAttributesTo(cloneObject);
-}
-
-//----------------------------------------------------------------
-int manualContourModelRoi::GetTypeModel() //virtual
-{
- return 2;
-}
-
-//----------------------------------------------------------------
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-manualContourModel::manualContourModel()
-{
- _cntSplineX = vtkKochanekSpline::New( );
- _cntSplineY = vtkKochanekSpline::New( );
- _cntSplineZ = vtkKochanekSpline::New( );
-
- this->SetCloseContour(true);
-
- _cntSplineX->SetDefaultTension( 0 );
- _cntSplineX->SetDefaultBias( 0 );
- _cntSplineX->SetDefaultContinuity( 0 );
-
- _cntSplineY->SetDefaultTension( 0 );
- _cntSplineY->SetDefaultBias( 0 );
- _cntSplineY->SetDefaultContinuity( 0 );
-
- _cntSplineZ->SetDefaultTension( 0 );
- _cntSplineZ->SetDefaultBias( 0 );
- _cntSplineZ->SetDefaultContinuity( 0 );
-
-//JSTG 25-02-08 -------------------------------------------------------------------------------------------------
-
- // this parameter is reset in the VIRTUAL manualContourBaseControler::Configure
- _sizePointsContour = 100; //JSTG 25-02-08 The change in the inisialization of these variable is critical.
-
- _delta_JSTG = 0.0;
-//---------------------------------------------------------------------------------------------------------------
-}
-
-// ----------------------------------------------------------------------------
-manualContourModel::~manualContourModel()
-{
- int i,size=_lstPoints.size();
- for (i=0;i<size; i++){
- delete _lstPoints[i];
- }
- _lstPoints.clear();
-
- _cntSplineX->RemoveAllPoints();
- _cntSplineY->RemoveAllPoints();
- _cntSplineZ->RemoveAllPoints();
-
- _cntSplineX->Delete();
- _cntSplineY->Delete();
- _cntSplineZ->Delete();
-}
-// ----------------------------------------------------------------------------
-int manualContourModel::AddPoint(double x,double y,double z)
-{
- manualPoint *mp = new manualPoint();
- mp->SetPoint(x,y,z);
- AddManualPoint(mp);
- //UpdateSpline();
-
- return _lstPoints.size()-1;
-}
-// ----------------------------------------------------------------------------
-int manualContourModel::InsertPoint(double x,double y,double z)
-{
- double dd,ddmin=9999999;
- int ibak=0;
- double xx,x1,x2;
- double yy,y1,y2;
- double zz,z1,z2;
- int i,ii,iii,size=_lstPoints.size();
- double j,MaxDivisions=20,porcentage;
- int sizeB=size;
-
- if (_closeContour==false)
- {
- size=size-1;
- }
-
- double jbak;
-
- for ( i=0 ; i<size ; i++ )
- {
- ii=i % sizeB ;
- iii=(i+1) % sizeB;
- x1=_lstPoints[ii]->GetX();
- y1=_lstPoints[ii]->GetY();
- z1=_lstPoints[ii]->GetZ();
- x2=_lstPoints[iii]->GetX();
- y2=_lstPoints[iii]->GetY();
- z2=_lstPoints[iii]->GetZ();
- for (j=0; j<=MaxDivisions; j++)
- {
- porcentage=(j/MaxDivisions);
- xx=(x2-x1)*porcentage+x1;
- yy=(y2-y1)*porcentage+y1;
- zz=(z2-z1)*porcentage+z1;
- dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
- if ( dd<ddmin )
- {
- ddmin=dd;
- ibak=iii;
- jbak=j;
- }
- }
- }
-
- if (_closeContour==false)
- {
- if ( (ibak==1) && (jbak==0) )
- {
- ibak=0;
- }
- if ( ( ibak==size ) && ( jbak==MaxDivisions ) )
- {
- ibak=sizeB;
- }
- }
-
-
-//JSTG - 25-04-08 ----------------------------------------------------------
- //manualPoint *mp = new manualPoint();
- //mp->SetPoint(x,y,z);
- //std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + ibak;
- //_lstPoints.insert(itNum,mp);
- InsertPoint_id(ibak,x,y,z);
-//----------------------------------------------------------------------------
-
- return ibak;
-}
-// ----------------------------------------------------------------------------
-void manualContourModel::InsertPoint_id(int id, double x, double y, double z)
-{
- manualPoint *mp = new manualPoint();
- mp->SetPoint(x,y,z);
- std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + id;
- _lstPoints.insert(itNum,mp);
-}
-// ----------------------------------------------------------------------------
-
-void manualContourModel::DeletePoint(int i)
-{
- std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + i;
- _lstPoints.erase(itNum);
-}
-// ----------------------------------------------------------------------------
-void manualContourModel::DeleteAllPoints()
-{
- int i,size=_lstPoints.size();
- for (i=0;i<size;i++){
- _lstPoints.erase( _lstPoints.begin() );
- }
- this->UpdateSpline();
-}
-// ----------------------------------------------------------------------------
-
-void manualContourModel::MovePoint(int i,double dx,double dy,double dz)
-{
- manualPoint *mp=_lstPoints[i];
- double x=mp->GetX()+dx;
- double y=mp->GetY()+dy;
- double z=mp->GetZ()+dz;
- mp->SetPoint(x,y,z);
-}
-// ----------------------------------------------------------------------------
-void manualContourModel::MoveLstPoints(double dx,double dy,double dz)
-{
- // ToDo
-}
-// ----------------------------------------------------------------------------
-void manualContourModel::MoveAllPoints(double dx,double dy,double dz)
-{
- int i,size=_lstPoints.size();
- for (i=0;i<size;i++){
- MovePoint(i,dx,dy,dz);
- }
-}
-
-
-// ----------------------------------------------------------------------------
-
-// type=-1 x,y,z
-// type=0 x,y
-// type=1 y,z
-// type=2 x,z
-int manualContourModel::GetIdPoint(double x, double y, double z, int i_range,int type)
-{
- double range = i_range+1;
-
- double xx,yy,zz,dd,ddmin=9999999;
- int ibak=-1;
- int i,size=_lstPoints.size();
- for (i=0;i<size;i++){
- manualPoint *mp=_lstPoints[i];
- xx=mp->GetX();
- yy=mp->GetY();
- zz=mp->GetZ();
-
- if (type==-1)
- {
- if ((fabs(xx-x)<range) && (fabs(yy-y)<range) && (fabs(zz-z)<range)) {
- dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
- if (dd<ddmin){
- ddmin=dd;
- ibak=i;
- }
- }
- }
- if (type==0)
- {
- if ((fabs(yy-y)<range) && (fabs(zz-z)<range)) {
- dd=sqrt( (yy-y)*(yy-y) + (zz-z)*(zz-z) );
- if (dd<ddmin){
- ddmin=dd;
- ibak=i;
- }
- }
- }
- if (type==1)
- {
- if ((fabs(xx-x)<range) && (fabs(zz-z)<range)) {
- dd=sqrt( (xx-x)*(xx-x) + (zz-z)*(zz-z) );
- if (dd<ddmin){
- ddmin=dd;
- ibak=i;
- }
- }
- }
- if (type==2)
- {
- if ((fabs(xx-x)<range) && (fabs(yy-y)<range) ) {
- dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) );
- if (dd<ddmin){
- ddmin=dd;
- ibak=i;
- }
- }
- }
- }
- return ibak;
-}
-// ----------------------------------------------------------------------------
-manualPoint* manualContourModel::GetManualPoint(int id)
-{
- return _lstPoints[id];
-}
-// ----------------------------------------------------------------------------
-int manualContourModel::GetSizeLstPoints()
-{
- return _lstPoints.size();
-}
-//----------------------------------------------------------------------------
-int manualContourModel::GetNumberOfPointsSpline()
-{
- return _sizePointsContour;
-}
-//----------------------------------------------------------------------------
-void manualContourModel::SetNumberOfPointsSpline(int size)
-{
- _sizePointsContour = size;
-}
-
-
-// ----------------------------------------------------------------------------
-
-void manualContourModel::SetCloseContour(bool closeContour)
-{
- _closeContour = closeContour;
- if (_closeContour==true)
- {
- _cntSplineX->ClosedOn();
- _cntSplineY->ClosedOn();
- _cntSplineZ->ClosedOn();
- } else {
- _cntSplineX->ClosedOff();
- _cntSplineY->ClosedOff();
- _cntSplineZ->ClosedOff();
- }
-}
-
-// ----------------------------------------------------------------------------
-bool manualContourModel::IfCloseContour()
-{
- return _closeContour;
-}
-
-// ----------------------------------------------------------------------------
-
-void manualContourModel::UpdateSpline() // virtual
-{
- int i, np;
- np = _lstPoints.size();
- manualPoint *mp;
- _cntSplineX->RemoveAllPoints();
- _cntSplineY->RemoveAllPoints();
- _cntSplineZ->RemoveAllPoints();
- for( i = 0; i < np; i++ ) {
- mp = GetManualPoint(i);
- _cntSplineX->AddPoint( i, mp->GetX() );
- _cntSplineY->AddPoint( i, mp->GetY() );
- _cntSplineZ->AddPoint( i, mp->GetZ() );
- } // rof
-
-//JSTG 25-02-08 ---------------------------------------------------------------------------------------------
- if (this->_closeContour==true)
- {
- _delta_JSTG = (double) (np) / double (_sizePointsContour - 1); //Without the -1 the curve is not close
- } else {
-// _delta_JSTG = (double) (np-1) / double (_sizePointsContour ); //Without the -1 the curve is not close
- _delta_JSTG = (double) (np) / double (_sizePointsContour-1 ); //Without the -1 the curve is not close
- }
-//-----------------------------------------------------------------------------------------------------------
-}
-
-//---------------------------------------------------------------------------------
-
-/*void manualContourModel::GetSplineiPoint(int i, double &x, double &y, double &z)
-{
- double delta=(double)(_lstPoints.size()) / (double)(_sizePointsContour);
- double t = delta*(double)i;
- GetSplinePoint(t, x, y, z);
-}*/
-
-//-----------------------------------------------------------------------------
-
-//JSTG 25-02-08 ---------------------------------------------------------------
-void manualContourModel::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
-{
- GetSpline_t_Point(i*_delta_JSTG,x,y,z);
-}
-
-// ----------------------------------------------------------------------------
-
-//JSTG 25-02-08 ---------------------------------------------------------------
-void manualContourModel::GetSpline_t_Point(double t, double *x, double *y, double *z)
-{
- if (_lstPoints.size()==0)
- {
- *x = 0;
- *y = 0;
- *z = 0;
- }
- if (_lstPoints.size()==1)
- {
- manualPoint *mp;
- mp = GetManualPoint(0);
- *x = mp->GetX();
- *y = mp->GetY();
- *z = mp->GetZ();
- }
- if (_lstPoints.size()>=2)
- {
- *x = _cntSplineX->Evaluate(t);
- *y = _cntSplineY->Evaluate(t);
- *z = _cntSplineZ->Evaluate(t);
- }
-}
-
-// ----------------------------------------------------------------------------
-
-
-/*void manualContourModel::GetSplinePoint(double t, double &x, double &y, double &z)
-{
- if (_lstPoints.size()==0)
- {
- x = 0;
- y = 0;
- z = 0;
- }
- if (_lstPoints.size()==1)
- {
- manualPoint *mp;
- mp = GetManualPoint(0);
- x = mp->GetX();
- y = mp->GetY();
- z = mp->GetZ();
- }
- if (_lstPoints.size()>=2)
- {
- x = _cntSplineX->Evaluate(t);
- y = _cntSplineY->Evaluate(t);
- z = _cntSplineZ->Evaluate(t);
- }
-}*/
-// ----------------------------------------------------------------------------
-double manualContourModel::GetPathSize()
-{
- double result = 0;
- double x1,y1,z1;
- double x2,y2,z2;
-
-// JSTG 25-02-08 -----------------------------
- //double t,delta;
- //int i,np,nps;
- int i;
-//--------------------------------------------
-
- if (_lstPoints.size()==2)
- {
- x1=_lstPoints[0]->GetX();
- y1=_lstPoints[0]->GetY();
- z1=_lstPoints[0]->GetZ();
- x2=_lstPoints[1]->GetX();
- y2=_lstPoints[1]->GetY();
- z2=_lstPoints[1]->GetZ();
- result = sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
- }
- if (_lstPoints.size()>2)
- {
-
-// JSTG 25-02-08 ------------------------------------------
- //np = _lstPoints.size( );
- //nps = 200;
- //delta=( double ) ( np ) / ( double ) ( nps );
- UpdateSpline();
- //GetSplinePoint(0,x1,y1,z1);
- GetSpline_i_Point(0,&x1,&y1,&z1);
-
- //for( i = 1; i < nps; i++ )
- for( i = 1; i < GetNumberOfPointsSpline(); i++ )
- {
- //t = delta * (double)i;
- //GetSplinePoint(t,x2,y2,z2);
- GetSpline_i_Point(i,&x2,&y2,&z2);
-//---------------------------------------------------------
- result=result + sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
- x1=x2;
- y1=y2;
- z1=z2;
- }// for
- }
-
- return result;
-}
-// ----------------------------------------------------------------------------
-double manualContourModel::GetPathArea()
-{
- double result = 555;
- if ((_lstPoints.size()>=3) && IfCloseContour()==true )
- {
- double area;
-//JSTG 25-02-08 ---------------------------------------------
- //double ti,tj;
-//-----------------------------------------------------------
- double x1,y1,z1;
- double x2,y2,z2;
- bool okArea=true;
- int i, j;
-
- // This uses Green's theorem:
- // A = 1/2 * sum( xiyi+1 - xi+1yi); pO == pN
- // A < 0 -> A = |A| (a negative value could raise because points are
- // given in clockwise order).
-
-//JSTG 25-02-08 -------------------------------------------------
- //int np = _lstPoints.size( );
- //int nps = 200;
- int nps = GetNumberOfPointsSpline();
- //double delta=( double ) ( np ) / ( double ) ( nps );
- UpdateSpline();
- for( i = 0, area = 0.0; i < nps; i++ )
- {
- j = ( i + 1 ) % nps;
- //ti = delta * (double)i;
- //tj = delta * (double)j;
- //GetSplinePoint(ti,x1,y1,z1);
- //GetSplinePoint(tj,x2,y2,z2);
- GetSpline_i_Point(i,&x1,&y1,&z1);
- GetSpline_i_Point(j,&x2,&y2,&z2);
-//----------------------------------------------------------------
- area +=
- (x1 * y2 ) -
- ( x2 * y1 );
- if (z1!=z2)
- {
- okArea=false;
- }
- }// for
- area /= 2.0;
- area = fabs( area );
-
-/*
- for( i = 0, area = 0.0; i < _lstPoints.size(); i++ )
- {
- j = ( i + 1 ) % _lstPoints.size();
- // Area
- area +=
- (_lstPoints[i]->GetX() * _lstPoints[j]->GetY() ) -
- ( _lstPoints[j]->GetX() * _lstPoints[i]->GetY() );
- if (_lstPoints[0]->GetZ()!=_lstPoints[i]->GetZ())
- {
- okArea=false;
- }
- } // rof
- area /= 2.0;
- area = fabs( area );
-*/
-
- if (okArea==true)
- {
- result = area;
- } else {
- result = -1;
- }
-
- } else {
- result = 0;
- }
- return result;
-}
-
-// ----------------------------------------------------------------------------
-// p[x,y,z] : data in
-// rp[x,y,z] : data out result point
-// rn[x,y,z] : data out result normal
-
-void manualContourModel::GetNearestPointAndNormal(double *p, double *rp, double *rn)
-{
- double distMin=999999999;
- double dist,dx,dy,dz;
- double x1,y1,z1;
- double x2,y2,z2;
- int i,np,nps;
-
-//JSTG 25-02-08 -------------------
- //double tback;
- int iback;
- //double t,delta;
-//---------------------------------
-
- np = _lstPoints.size( );
- if (np>=2)
- {
-// JSTG 25-02-08 ------------------------------------------
- //nps = 200;
- nps = GetNumberOfPointsSpline();
- //delta = ( double ) ( np ) / ( double ) ( nps );
- UpdateSpline();
- //GetSplinePoint(0,x1,y1,z1);
- GetSpline_i_Point(0,&x1,&y1,&z1);
- for( i = 0; i < nps; i++ )
- {
- //t = delta * (double)i;
- //GetSplinePoint(t,x1,y1,z1);
- GetSpline_i_Point(i,&x1,&y1,&z1);
-//----------------------------------------------------------
- dx= x1-p[0];
- dy= y1-p[1];
- dz= z1-p[2];
- dist = sqrt( dx*dx + dy*dy + dz*dz );
- if (dist<distMin)
- {
- distMin = dist;
-//JSTG tback = t;
- iback = i;
- rp[0] = x1;
- rp[1] = y1;
- rp[2] = z1;
- rn[0] = x2-x1;
- rn[1] = y2-y1;
- rn[2] = z2-z1;
- }
- x2=x1;
- y2=y1;
- z2=z1;
- }// for
-
-// JSTG 25-02-08 ------------------------------------------
- //if (tback==0)
- if (iback==0)
- {
- //t = delta * (double)1.0;
- //GetSplinePoint(t,x1,y1,z1);
- GetSpline_i_Point(i,&x1,&y1,&z1);
-//----------------------------------------------------------
- rn[0]=rp[0]-x1;
- rn[1]=rp[1]-y1;
- rn[2]=rp[2]-z1;
- }
- }
- else
- {
- rp[0] = 0;
- rp[1] = 0;
- rp[2] = 0;
- rn[0] = -1;
- rn[1] = 0;
- rn[2] = 0;
- }
-}
-
-// ----------------------------------------------------------------------------
-manualContourModel * manualContourModel :: Clone() // virtual
-{
- manualContourModel * clone = new manualContourModel();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ----------------------------------------------------------------------------
-void manualContourModel::Open(FILE *ff) // virtual
-{
- char tmp[255];
- int i;
- int numberOfControlPoints;
- double x,y,z;
-
- fscanf(ff,"%s",tmp); // NumberOfControlPoints
- fscanf(ff,"%s",tmp); // ##
- numberOfControlPoints = atoi(tmp);
- for (i=0;i<numberOfControlPoints;i++)
- {
- fscanf(ff,"%s",tmp); // X
- x = atof(tmp);
- fscanf(ff,"%s",tmp); // Y
- y = atof(tmp);
- fscanf(ff,"%s",tmp); // Z
- z = atof(tmp);
- AddPoint(x,y,z);
- }
-}
-
-
-// ----------------------------------------------------------------------------
-int manualContourModel::GetTypeModel() //virtual
-{
- // 0 spline
- // 1 spline
- // 2 rectangle
- // 3 circle
- // 4 BullEye
- // 5 BullEyeSector
- // 6 Line
- return 1;
-}
-
-// ----------------------------------------------------------------------------
-void manualContourModel::Save(FILE *ff) // virtual
-{
- int i,size=_lstPoints.size();
- fprintf(ff,"TypeModel %d\n", GetTypeModel() );
- fprintf(ff,"NumberOfControlPoints %d\n",size);
- for (i=0;i<size;i++)
- {
- manualPoint *mp=_lstPoints[i];
- fprintf(ff,"%f %f %f\n", mp->GetX(), mp->GetY(), mp->GetZ() );
- }
-}
-
-
-// ---------------------------------------------------------------------------
-
-void manualContourModel::CopyAttributesTo( manualContourModel * cloneObject)
-{
- // Fathers object
- //XXXX::CopyAttributesTo(cloneObject);
-
- cloneObject->SetCloseContour( this->IfCloseContour() );
- int i, size = GetSizeLstPoints();
- for( i=0; i<size; i++ )
- {
- cloneObject->AddManualPoint( GetManualPoint( i )->Clone() );
- }
- cloneObject->SetNumberOfPointsSpline( GetNumberOfPointsSpline () );
- cloneObject->SetCloseContour( _closeContour );
- cloneObject->UpdateSpline();
-}
-
-
-// ---------------------------------------------------------------------------
-void manualContourModel::AddManualPoint( manualPoint* theManualPoint )//private
-{
- _lstPoints.push_back( theManualPoint );
-}
-
-std::vector<manualContourModel*> manualContourModel::ExploseModel( )
-{
- std::vector<manualContourModel*> lstTmp;
- lstTmp.push_back(this);
- return lstTmp;
-}
-
-
-// ---------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-//int manualViewPoint::range=1;
-
-
-manualViewPoint::manualViewPoint(wxVtkBaseView *wxvtkbaseview){
- _selected = false;
- _posibleSelected = false;
- _pts = NULL;
- _pd = NULL;
- _pointVtkActor = NULL;
- _bboxMapper = NULL;
- _wxvtkbaseview = wxvtkbaseview;
- _spc[0] = 1;
- _spc[1] = 1;
- _spc[2] = 1;
-
- _widthline = 1;
-
-}
-// ----------------------------------------------------------------------------
-manualViewPoint::~manualViewPoint(){
- DeleteVtkObjects();
-}
-
-// ----------------------------------------------------------------------------
-void manualViewPoint::SetWidthLine( double width)
-{
- _widthline = width;
-}
-
-// ----------------------------------------------------------------------------
-void manualViewPoint::SetSelected(bool selected){
- _selected=selected;
-}
-// ----------------------------------------------------------------------------
-void manualViewPoint::SetPosibleSelected(bool posibleSelected){
- _posibleSelected=posibleSelected;
-}
-// ----------------------------------------------------------------------------
-bool manualViewPoint::GetSelected(){
- return _selected;
-}
-// ----------------------------------------------------------------------------
-bool manualViewPoint::GetPosibleSelected(){
- return _posibleSelected;
-}
-// ----------------------------------------------------------------------------
-void manualViewPoint::DeleteVtkObjects(){
- if (_pointVtkActor !=NULL) { _pointVtkActor->Delete(); }
- if (_bboxMapper !=NULL) { _bboxMapper ->Delete(); }
- if (_pts !=NULL) { _pts ->Delete(); }
- if (_pd !=NULL) { _pd ->Delete(); }
- _pointVtkActor = NULL;
- _bboxMapper = NULL;
- _pts = NULL;
- _pd = NULL;
-}
-
-
-
-// ----------------------------------------------------------------------------
-vtkActor* manualViewPoint::CreateVtkPointActor()
-{
- DeleteVtkObjects();
-
- _pts = vtkPoints::New();
- _pts->SetNumberOfPoints(8);
-
- _pts->SetPoint(0, -1000 , -1000 , 0 );
- _pts->SetPoint(1, 1000 , -1000 , 0 );
- _pts->SetPoint(2, 1000 , 1000 , 0 );
- _pts->SetPoint(3, -1000 , 1000 , 0 );
- _pts->SetPoint(4, -1000 , 1000 , 0 );
- _pts->SetPoint(5, -1000 , 1000 , 0 );
- _pts->SetPoint(6, -1000 , 1000 , 0 );
- _pts->SetPoint(7, -1000 , 1000 , 0 );
-
- vtkCellArray *lines = vtkCellArray::New();
- lines->InsertNextCell(17);
- lines->InsertCellPoint(0);
- lines->InsertCellPoint(1);
- lines->InsertCellPoint(2);
- lines->InsertCellPoint(3);
- lines->InsertCellPoint(0);
- lines->InsertCellPoint(4);
- lines->InsertCellPoint(5);
- lines->InsertCellPoint(6);
- lines->InsertCellPoint(7);
- lines->InsertCellPoint(4);
- lines->InsertCellPoint(0);
- lines->InsertCellPoint(3);
- lines->InsertCellPoint(7);
- lines->InsertCellPoint(6);
- lines->InsertCellPoint(2);
- lines->InsertCellPoint(1);
- lines->InsertCellPoint(5);
-
- _pd = vtkPolyData::New();
- _pd->SetPoints( _pts );
- _pd->SetLines( lines );
-// lines->Delete(); //do not delete lines ??
-
- _pointVtkActor = vtkActor::New();
- _bboxMapper = vtkPolyDataMapper::New();
-
- _bboxMapper->SetInput(_pd);
-// _bboxMapper->ImmediateModeRenderingOn();
- _pointVtkActor->SetMapper(_bboxMapper);
-// _pointVtkActor->GetProperty()->BackfaceCullingOn();
- UpdateColorActor();
-// _pd->ComputeBounds();
-
- return _pointVtkActor;
-}
-// ----------------------------------------------------------------------------
-vtkActor* manualViewPoint::GetVtkActor(){
- return _pointVtkActor;
-}
-// ----------------------------------------------------------------------------
-void manualViewPoint::SetPositionXY(double x, double y,double i_range,double posZ)
-{
-// double range=0.2; // i_range;
-// double range=(double)manualViewPoint::range;
-
- double range=i_range;
-
-//EED 27 sep 2006
- x = x * _spc[0];
- y = y * _spc[1];
- posZ = posZ * _spc[2];
-
- if (_pts!=NULL){
- _pts->SetPoint(0, x-range, y+range, posZ-range);
- _pts->SetPoint(1, x+range, y+range, posZ-range);
- _pts->SetPoint(2, x+range, y-range, posZ-range);
- _pts->SetPoint(3, x-range, y-range, posZ-range);
- _pts->SetPoint(4, x-range, y+range, posZ+range);
- _pts->SetPoint(5, x+range, y+range, posZ+range);
- _pts->SetPoint(6, x+range, y-range, posZ+range);
- _pts->SetPoint(7, x-range, y-range, posZ+range);
- }
-}
-
-
-// ----------------------------------------------------------------------------
-void manualViewPoint::UpdateColorActor()
-{
- if (_pointVtkActor!=NULL){
-//EED03
- _pointVtkActor->GetProperty()->SetLineWidth( _widthline );
- _pointVtkActor->GetProperty()->SetDiffuseColor(1,0,0);
- if (_posibleSelected==true){
- _pointVtkActor->GetProperty()->SetDiffuseColor(1,1,0);
- }
- }
-}
-// ----------------------------------------------------------------------------
-void manualViewPoint::GetSpacing(double spc[3])
-{
- spc[0] = _spc[0];
- spc[1] = _spc[1];
- spc[2] = _spc[2];
-}
-// ----------------------------------------------------------------------------
-void manualViewPoint::SetSpacing(double spc[3])
-{
- _spc[0] = spc[0];
- _spc[1] = spc[1];
- _spc[2] = spc[2];
-}
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-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;
- TransfromeCoordViewWorld(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;
- TransfromeCoordViewWorld(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;
-
- TransfromeCoordViewWorld(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();
-}
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-manualView3VContour::manualView3VContour(int type)
-{
- _type=type;
-// JSTG 25-02-08 ------------------------------
- //_manContModel= new manualContourModel();
-//---------------------------------------------
-}
-// ----------------------------------------------------------------------------
-manualView3VContour::~manualView3VContour()
-{
-}
-
-
-
-// ----------------------------------------------------------------------------
-manualView3VContour * manualView3VContour :: Clone()
-{
- manualView3VContour * clone = new manualView3VContour( GetType() );
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualView3VContour::CopyAttributesTo( manualView3VContour * cloneObject)
-{
- // Fathers object
- manualViewContour::CopyAttributesTo(cloneObject);
-}
-
-int manualView3VContour::GetType()
-{
- return _type;
-}
-
-// ----------------------------------------------------------------------------
-void manualView3VContour::FilterCordinateXYZ(double &x,double &y,double &z)
-{
- if (_type==0)
- {
- x=-1000;
- }
- if (_type==1)
- {
- y=500;
- }
- if (_type==2)
- {
- z=-1000;
- }
-}
-// ----------------------------------------------------------------------------
-
-void manualView3VContour::RefreshContour() // virtula
-{
- manualViewContour::RefreshContour();
- int i;
- double pp[3];
-// JSTG 25-02-08 ----------------------------------------
- //int nps = GetNumberOfPointsSpline();
- int nps = _manContModel->GetNumberOfPointsSpline();
-//-------------------------------------------------------
- for( i = 0; i < nps; i++ )
- {
- _pts->GetPoint( i, pp );
- FilterCordinateXYZ(pp[0],pp[1],pp[2]);
-
-//EED 27 sep 2006
- _pts->SetPoint( i, pp[0] , pp[1] ,pp[2] );
- }
-
-}
-
-// ----------------------------------------------------------------------------
-
-void manualView3VContour::UpdateViewPoint(int id){ // virtual
- double x,y,z;
- manualPoint *mp = _manContModel->GetManualPoint(id);
- x=mp->GetX();
- y=mp->GetY();
- z=mp->GetZ();
-
- FilterCordinateXYZ(x,y,z);
- _lstViewPoints[id]->SetPositionXY( x , y ,GetRange(), z );
-}
-
-// ----------------------------------------------------------------------------
-
-int manualView3VContour::GetIdPoint(int x, int y, int z) // virtual
-{
- int ii=-1;
- if (_manContModel!=NULL){
- double xx=x;
- double yy=y;
- double zz=z;
- TransfromeCoordViewWorld(xx,yy,zz,-1);
- ii=_manContModel->GetIdPoint(xx,yy,zz,GetRange(),_type);
- }
- return ii;
-}
-
-// ----------------------------------------------------------------------------
-bool manualView3VContour::ifTouchContour(int x,int y,int z){ // virtual
- bool result=false;
- double xx=x;
- double yy=y;
- double zz=z;
- double ppA[3];
- double ppB[3];
- double d1,d2,d3;
- TransfromeCoordViewWorld(xx,yy,zz,-1);
-
-//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;
- }
- FilterCordinateXYZ(xx,yy,zz);
-
- for( i = 0; i < nps_t; i++ ) {
- _pts->GetPoint(i%nps, ppA);
- _pts->GetPoint((i+1)%nps, ppB);
- FilterCordinateXYZ(ppA[0],ppA[1],ppA[2]);
- FilterCordinateXYZ(ppB[0],ppB[1],ppB[2]);
- 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;
-}
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualView3DContour::manualView3DContour()
-{
-}
-// ----------------------------------------------------------------------------
-manualView3DContour::~manualView3DContour()
-{
-}
-
-// ----------------------------------------------------------------------------
-manualView3DContour * manualView3DContour :: Clone()
-{
- manualView3DContour * clone = new manualView3DContour();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualView3DContour::CopyAttributesTo( manualView3DContour * cloneObject)
-{
- // Fathers object
- manualViewContour::CopyAttributesTo(cloneObject);
-
- cloneObject->SetDimensions ( _w , _h , _d );
-}
-// ----------------------------------------------------------------------------
-void manualView3DContour::SetDimensions(int w, int h, int d)
-{
- _w = w;
- _h = h;
- _d = d;
-}
-// ----------------------------------------------------------------------------
-void manualView3DContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type)
-{
- X = _vtkmprbasedata->GetX();
- Y = _vtkmprbasedata->GetY();
- Z = _vtkmprbasedata->GetZ();
-}
-// ----------------------------------------------------------------------------
-void manualView3DContour::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
-{
- _vtkmprbasedata = vtkmprbasedata;
-}
-// ----------------------------------------------------------------------------
-int manualView3DContour::GetIdPoint2(int x, int y)
-{
- int id = -1;
- double p[3],pA[3],pB[3];
-
- double pickPoint[ 3 ], cameraPos[ 3 ];
- vtkPointPicker* picker = vtkPointPicker::New( );
- vtkRenderer *pRenderer = this->GetWxVtkBaseView()->GetRenderer();
- picker->Pick( x, y, 0.0, pRenderer );
- pRenderer->GetActiveCamera( )->GetPosition( cameraPos );
- picker->GetPickPosition( pickPoint );
- picker->Delete( );
-
- UtilVtk3DGeometriSelection utilVtk3Dgeometriselection;
- utilVtk3Dgeometriselection.SetDimentions(_w,_h,_d);
-
- if( utilVtk3Dgeometriselection.FindCubePointsFromPoints( pA, pB, pickPoint, cameraPos ) )
- {
- double dist,distMin=999999999;
- int i,size=this->_manContModel->GetSizeLstPoints();
- for (i=0;i<size;i++)
- {
- manualPoint *mp = this->_manContModel->GetManualPoint(i);
- p[0] = mp->GetX();
- p[1] = mp->GetY();
- p[2] = mp->GetZ();
- dist=utilVtk3Dgeometriselection.DistanceMinPointToLine(p,pA,pB);
- if ( (dist<=2*GetRange()) && (dist<distMin) )
- {
- distMin = dist;
- id = i;
- }
- }
- }
- return id;
-}
-// ----------------------------------------------------------------------------
-int manualView3DContour::SelectPosiblePoint ( int x, int y, int z )// virtual
-{
- SelectAllPossibleSelected(false);
- int id=GetIdPoint2(x,y);
- if (id!=-1)
- {
- SetPointPosibleSelected(id,true);
- }
- return id;
-}
-
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualViewBullEyeSector::manualViewBullEyeSector()
-{
-}
-
-// ----------------------------------------------------------------------------
-void manualViewBullEyeSector::RefreshContour()
-{
-//EED004
- int i,nps;
- double x,y,z;
-//----------------------------------
-
- _manContModel->UpdateSpline();
- nps = _manContModel->GetNumberOfPointsSpline();
-
- if ( _pts!=NULL )
- {
- for( i = 0; i < nps; i++ )
- {
- _manContModel->GetSpline_i_Point(i,&x,&y,&z);
- _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );
- }// for
- }
-
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-manualViewBullEye::manualViewBullEye()
-{
-}
-
-// ----------------------------------------------------------------------------
-manualViewBullEye::~manualViewBullEye()
-{
- // BullEye(s)
- int i,size=lstSectorBullEye.size();
- for (i=0;i<size;i++)
- {
- delete lstSectorBullEye[i];
- }
- lstSectorBullEye.clear();
-}
-
-
-// ----------------------------------------------------------------------------
-manualViewBullEye * manualViewBullEye :: Clone()
-{
- manualViewBullEye * clone = new manualViewBullEye();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualViewBullEye::CopyAttributesTo( manualViewBullEye * cloneObject)
-{
- // Fathers object
- manualViewBaseContour::CopyAttributesTo(cloneObject);
-}
-
-
-// ----------------------------------------------------------------------------
-int manualViewBullEye::GetType() // virtual
-{
- return 4;
-}
-
-
-// ----------------------------------------------------------------------------
-void manualViewBullEye::RefreshContour() // virtual
-{
- // External Rectangle
- manualViewRoi::RefreshContour();
-
- _manContModel->UpdateSpline();
- int np = GetNumberOfPoints( );
- // Refres sectors of BullEye(s)
-
- if (np>=2 )
- {
- int i,size = lstSectorBullEye.size();
- for (i=0;i<size;i++)
- {
- lstSectorBullEye[i]->RefreshContour();
- } // for
- } // if
-
-
-}
-
-// ----------------------------------------------------------------------------
-void manualViewBullEye::ConstructVTKObjects() // virtual
-{
- manualViewRoi::ConstructVTKObjects();
-
- double spc[3];
- this->GetSpacing(spc);
- manualViewBullEyeSector *mvbc;
- manualContourModelBullEye *mcmbe = (manualContourModelBullEye*)this->_manContModel;
- int i,size = mcmbe->GetSizeOfSectorLst();
- for ( i=0 ; i<size ; i++ )
- {
- mvbc = new manualViewBullEyeSector();
- mvbc->SetModel( mcmbe->GetModelSector(i) );
- mvbc->SetWxVtkBaseView( this->GetWxVtkBaseView() );
- mvbc->SetRange( 2 );
- mvbc->SetZ( 1000 );
- mvbc->SetSpacing(spc);
- mvbc->SetColorNormalContour(1, 0, 0);
-// mvbc->SetColorEditContour(0.5, 0.5, 0.5);
-// mvbc->SetColorSelectContour(1, 0.8, 0);
- mvbc->SetWidthLine( this->GetWidthLine() );
-//EED004
- mvbc->ConstructVTKObjects();
- lstSectorBullEye.push_back( mvbc );
- }
-
-
-}
-
-// ----------------------------------------------------------------------------
-void manualViewBullEye::AddSplineActor() // virtual
-{
- manualViewRoi::AddSplineActor();
- int i,size=lstSectorBullEye.size();
- for (i=0;i<size;i++)
- {
- lstSectorBullEye[i]->AddSplineActor();
- }
-}
-
-// ----------------------------------------------------------------------------
-void manualViewBullEye::RemoveSplineActor() // virtual
-{
- manualViewRoi::RemoveSplineActor();
- int i,size=lstSectorBullEye.size();
- for (i=0;i<size;i++)
- {
- lstSectorBullEye[i]->RemoveSplineActor();
- }
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-manualViewRoi::manualViewRoi()
-{
- _sizePointsContour=5;
-}
-// ----------------------------------------------------------------------------
-manualViewRoi::~manualViewRoi()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualViewRoi * manualViewRoi :: Clone()
-{
- manualViewRoi * clone = new manualViewRoi();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualViewRoi::CopyAttributesTo( manualViewRoi * cloneObject)
-{
- // Fathers object
- manualViewBaseContour::CopyAttributesTo(cloneObject);
-}
-
-// ----------------------------------------------------------------------------
-void manualViewRoi::RefreshContour() // virtual
-{
- unsigned int i,ii, np;
- np = GetNumberOfPoints( );
-//EED01
- if ( np > 0)
- {
- if (np>=2)
- {
- manualPoint *mp;
- for( i = 0; i < np+1; i++ ) {
- ii=i%np;
- mp = _manContModel->GetManualPoint(ii);
-
- //EEDx6
- double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
- // wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
- // wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
-
- //EED 27 sep 2007
- // _pts->SetPoint(i, XX,YY,ZZ );
- _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
- } // rof
-
- } else {
- _pts->SetPoint(0, 0 , 0 , 0);
- _pts->SetPoint(1, 0 , 0 , 0);
- } // if
- }
-}
-
-// ----------------------------------------------------------------------------
-int manualViewRoi::GetType() // virtual
-{
- return 2;
-}
-
-// ----------------------------------------------------------------------------
-
-void manualViewRoi::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
-{
- double pp[3];
- manualPoint *mp;
- unsigned int i;
-
- minX=99999;
- minY=99999;
- maxX=-99999;
- maxY=-99999;
-
- unsigned int size=(unsigned int) _manContModel->GetSizeLstPoints();
-
- for( i = 0; i < size; i++ )
- {
-
- mp=_manContModel->GetManualPoint(i);
- pp[0]=mp->GetX();
- pp[1]=mp->GetY();
-
- // 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 ( size<1 )
- {
- minX=0;
- maxX=0;
- minY=0;
- maxY=0;
- }
-}
-
-// ----------------------------------------------------------------------------
-
-
-bool manualViewRoi::ifTouchContour(int x,int y, int z) // virtual
-{
- bool result=false;
- double px1=99999,py1=99999,px2=-99999,py2=-99999;
-
- GetMinMax(px1,py1, px2, py2);
-
- double xx=x;
- double yy=y;
- double zz=z;
- TransfromeCoordViewWorld(xx,yy,zz);
-
- bool ok1=false;
- bool ok2=false;
- double ddx=GetRange();
- double ddy=GetRange();
-
- if ((xx>px1-ddx)&&(xx<px2+ddx) && (yy>py1-ddy)&&(yy<py2+ddy))
- {
- ok1=true;
- }
-
- if ((xx>px1+ddx)&&(xx<px2-ddx) && (yy>py1+ddy)&&(yy<py2-ddy))
- {
- ok2=true;
- }
-
- if ((ok1==true) && (ok2==false))
- {
- result=true;
- }
-
- return result;
-}
-
-// ----------------------------------------------------------------------------
-
-void manualViewRoi::InitMove(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- if (_manContModel->GetSizeLstPoints()==4){
- mp = _manContModel->GetManualPoint(0);
- _dp0[0]= mp->GetX() - XX;
- _dp0[1]= mp->GetY() - YY;
- _dp0[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(1);
- _dp1[0]= mp->GetX() - XX;
- _dp1[1]= mp->GetY() - YY;
- _dp1[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(2);
- _dp2[0]= mp->GetX() - XX;
- _dp2[1]= mp->GetY() - YY;
- _dp2[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(3);
- _dp3[0]= mp->GetX() - XX;
- _dp3[1]= mp->GetY() - YY;
- _dp3[2]= mp->GetZ();
- }
-}
-
-// ----------------------------------------------------------------------------
-
-void manualViewRoi::MoveContour(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- mp = _manContModel->GetManualPoint(0);
- mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
-
- mp = _manContModel->GetManualPoint(1);
- mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
-
- mp = _manContModel->GetManualPoint(2);
- mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
-
- mp = _manContModel->GetManualPoint(3);
- mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
-
- UpdateViewPoint(0);
- UpdateViewPoint(1);
- UpdateViewPoint(2);
- UpdateViewPoint(3);
-
-}
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// EED08
-
-manualViewCircle::manualViewCircle()
-{
-// _sizePointsContour=5; // default 100
-}
-// ----------------------------------------------------------------------------
-manualViewCircle::~manualViewCircle()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualViewCircle * manualViewCircle :: Clone()
-{
- manualViewCircle * clone = new manualViewCircle();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualViewCircle::CopyAttributesTo( manualViewCircle * cloneObject)
-{
- // Fathers object
- manualViewBaseContour::CopyAttributesTo(cloneObject);
-}
-
-
-// ----------------------------------------------------------------------------
-/*
-void manualViewCircle::RefreshContour(){ // virtual
-
- manualPoint *mpA,*mpB;
- unsigned int i, np,nps;
- double angle,radio;
- double difX,difY;
- double XX,YY,ZZ;
- np = GetNumberOfPoints( );
- nps = _manContModel->GetNumberOfPointsSpline();
- double deltaAngle=(3.14159265*2)/(nps-1);
- if ( np > 0)
- {
- if (np==2)
- {
- mpA = _manContModel->GetManualPoint(0);
- mpB = _manContModel->GetManualPoint(1);
- difX = mpA->GetX() - mpB->GetX();
- difY = mpA->GetY() - mpB->GetY();
- radio = sqrt( difX*difX + difY*difY );
- manualContourModelCircle *manContModelCir = (manualContourModelCircle*)_manContModel;
- manContModelCir->SetRadio(radio);
-
- for( i = 0; i < nps; i++ ) {
- manContModelCir->GetSpline_i_Point(i, &XX, &YY, &ZZ);
-// angle = deltaAngle*i;
-// XX = cos(angle)*radio+mpA->GetX();
-// YY = sin(angle)*radio+mpA->GetY();
- ZZ = mpA->GetZ();
- _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
- } // rof
- } else {
- _pts->SetPoint(0, 0 , 0 , 0);
- _pts->SetPoint(1, 0 , 0 , 0);
- } // if
- }
-}
-*/
-
-// ----------------------------------------------------------------------------
-int manualViewCircle::GetType() // virtual
-{
- return 3;
-}
-
-// ----------------------------------------------------------------------------
-
-void manualViewCircle::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
-{
- manualPoint *mpA,*mpB;
- unsigned int np;
- double radio;
- double difX,difY;
- np = GetNumberOfPoints( );
- if (np==2)
- {
- mpA = _manContModel->GetManualPoint(0);
- mpB = _manContModel->GetManualPoint(1);
- difX = mpA->GetX() - mpB->GetX();
- difY = mpA->GetY() - mpB->GetY();
- radio = sqrt( difX*difX + difY*difY );
- minX=mpA->GetX()-radio;
- minY=mpA->GetY()-radio;
- maxX=mpA->GetX()+radio;
- maxY=mpA->GetY()+radio;
- } else {
- minX=0;
- maxX=0;
- minY=0;
- maxY=0;
- }
-}
-
-/*
-// ----------------------------------------------------------------------------
-bool manualViewCircle::ifTouchContour(int x,int y, int z) // virtual
-{
- bool result=false;
- double px1=99999,py1=99999,px2=-9999,py2=-99999;
-
- GetMinMax(px1,py1, px2, py2);
-
- double xx=x;
- double yy=y;
- double zz=z;
- TransfromeCoordViewWorld(xx,yy,zz);
-
- bool ok1=false;
- bool ok2=false;
- double ddx=GetRange();
- double ddy=GetRange();
-
- if ((xx>px1-ddx)&&(xx<px2+ddx) && (yy>py1-ddy)&&(yy<py2+ddy))
- {
- ok1=true;
- }
-
- if ((xx>px1+ddx)&&(xx<px2-ddx) && (yy>py1+ddy)&&(yy<py2-ddy))
- {
- ok2=true;
- }
-
- if ((ok1==true) && (ok2==false))
- {
- result=true;
- }
-
- return result;
-}
-*/
-
-// ----------------------------------------------------------------------------
-
-void manualViewCircle::InitMove(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- if (_manContModel->GetSizeLstPoints()==2){
- mp = _manContModel->GetManualPoint(0);
- _dp0[0]= mp->GetX() - XX;
- _dp0[1]= mp->GetY() - YY;
- _dp0[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(1);
- _dp1[0]= mp->GetX() - XX;
- _dp1[1]= mp->GetY() - YY;
- _dp1[2]= mp->GetZ();
-/*
- mp = _manContModel->GetManualPoint(2);
- _dp2[0]= mp->GetX() - XX;
- _dp2[1]= mp->GetY() - YY;
- _dp2[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(3);
- _dp3[0]= mp->GetX() - XX;
- _dp3[1]= mp->GetY() - YY;
- _dp3[2]= mp->GetZ();
-*/
- }
-}
-
-
-// ----------------------------------------------------------------------------
-void manualViewCircle::MoveContour(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- mp = _manContModel->GetManualPoint(0);
- mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
-
- mp = _manContModel->GetManualPoint(1);
- mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
-
-// mp = _manContModel->GetManualPoint(2);
-// mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
-
-// mp = _manContModel->GetManualPoint(3);
-// mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
-
- UpdateViewPoint(0);
- UpdateViewPoint(1);
-// UpdateViewPoint(2);
-// UpdateViewPoint(3);
-
-}
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// AD:02-09
-
-manualViewLine::manualViewLine()
-{
- _sizePointsContour=20;
-}
-// ----------------------------------------------------------------------------
-manualViewLine::~manualViewLine()
-{
-}
-
-
-// ----------------------------------------------------------------------------
-manualViewLine * manualViewLine :: Clone()
-{
- manualViewLine * clone = new manualViewLine();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualViewLine::CopyAttributesTo( manualViewLine * cloneObject)
-{
- // Fathers object
- manualViewBaseContour::CopyAttributesTo(cloneObject);
-}
-
-// ----------------------------------------------------------------------------
-int manualViewLine::GetType() // virtual
-{
- return 6;
-}
-
-
-// ----------------------------------------------------------------------------
-
-void manualViewLine::InitMove(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- if (_manContModel->GetSizeLstPoints()==2)
- {
- mp = _manContModel->GetManualPoint(0);
- _dp0[0]= mp->GetX() - XX;
- _dp0[1]= mp->GetY() - YY;
- _dp0[2]= mp->GetZ();
-
- mp = _manContModel->GetManualPoint(1);
- _dp1[0]= mp->GetX() - XX;
- _dp1[1]= mp->GetY() - YY;
- _dp1[2]= mp->GetZ();
-
- }
-}
-
-
-// ----------------------------------------------------------------------------
-void manualViewLine::MoveContour(int x, int y, int z) // virtual
-{
- manualPoint *mp;
- double XX=x;
- double YY=y;
- double ZZ=z;
- TransfromeCoordViewWorld(XX,YY,ZZ);
-
- mp = _manContModel->GetManualPoint(0);
- mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
-
- mp = _manContModel->GetManualPoint(1);
- mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
-
-
- UpdateViewPoint(0);
- UpdateViewPoint(1);
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-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;
- TransfromeCoordViewWorld(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::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type) // Virtual
-{
- _wxvtkbaseview->TransfromeCoordScreenToWorld(X, Y, Z, 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];
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// _type = 0 Sagital
-// _type = 1 Coronal
-// _type = 2 Axial
-// _type = -1 View 3D
-
-manualContour3VControler::manualContour3VControler(int type)
-{
- _type=type;
-
-//EEDhh
-// _manViewBaseCont1 = NULL;
-// _manViewBaseCont2 = NULL;
-// _manViewBaseCont3 = NULL;
-}
-//----------------------------------------------------------------------------
-manualContour3VControler::~manualContour3VControler()
-{
-}
-
-// ----------------------------------------------------------------------------
-manualContour3VControler * manualContour3VControler :: Clone() // virtual
-{
- manualContour3VControler * clone = new manualContour3VControler( this->GetType() );
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualContour3VControler::CopyAttributesTo( manualContour3VControler * cloneObject)
-{
- // Fathers object
- manualContourControler::CopyAttributesTo(cloneObject);
-
- cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
-
- // Remember to add ManualViewBaseContour with "AddManualViewBaseContour"
-
-}
-// ----------------------------------------------------------------------------
-int manualContour3VControler::GetType()
-{
- return _type;
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::AddPoint_Others()
-{
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->AddPoint();
- }
-
-// EEDhh
-// if (_manViewBaseCont1!=NULL){
-// _manViewBaseCont1->AddPoint();
-// _manViewBaseCont2->AddPoint();
-// _manViewBaseCont3->AddPoint();
-// this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-// }
-
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::AddPoint( int x, int y, int z ) // virtual
-{
-
- z=(int)_vtkmprbasedata->GetZ();
- if (GetManualContourModel()!=NULL){
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
-
- if (_type==0)
- {
- xx=_vtkmprbasedata->GetX();
- }
-
- if (_type==1)
- {
- yy=_vtkmprbasedata->GetY();
- }
-
-
- /*int id = */ GetManualContourModel()->AddPoint(xx,yy,zz); // JPRx
- GetManualViewBaseContour()->AddPoint();
- AddPoint_Others();
-
- }
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::InsertPoint_Others(int id)
-{
-
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->InsertPoint(id);
- }
-
-/*EEDhh
- if (_manViewBaseCont1!=NULL){
- _manViewBaseCont1->InsertPoint(id);
- _manViewBaseCont2->InsertPoint(id);
- _manViewBaseCont3->InsertPoint(id);
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
- }
-*/
-
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::InsertPoint(int x, int y, int z)
-{
- int id=-1;
- if (GetManualContourModel()!=NULL){
- if (GetManualContourModel()->GetSizeLstPoints()>1){
- z=(int)_vtkmprbasedata->GetZ();
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
- if (_type==0)
- {
- xx=_vtkmprbasedata->GetX();
- }
-
- if (_type==1)
- {
- yy=_vtkmprbasedata->GetY();
- }
-
- id = GetManualContourModel()->InsertPoint(xx,yy,zz);
-
- GetManualViewBaseContour()->InsertPoint(id);
- InsertPoint_Others(0);
-
- } else {
- AddPoint(x,y,z);
- }
- }
-}
-// ----------------------------------------------------------------------------
-
-// EEDhh
-/*
-void manualContour3VControler::SetModelView ( manualContourModel *manContModel,
- manualViewBaseContour *manViewBaseCont0,
- manualViewBaseContour *manViewBaseCont1,
- manualViewBaseContour *manViewBaseCont2,
- manualViewBaseContour *manViewBaseCont3)
-{
- manualContourControler::SetModelView(manContModel,manViewBaseCont0);
- _manViewBaseCont1 = manViewBaseCont1;
- _manViewBaseCont2 = manViewBaseCont2;
- _manViewBaseCont3 = manViewBaseCont3;
-}
-*/
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::AddManualViewBaseContour( manualViewBaseContour *manViewBaseCont )
-{
- _lstManualViewBaseContour.push_back( manViewBaseCont );
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
-{
- _vtkmprbasedata=vtkmprbasedata;
-}
-// ----------------------------------------------------------------------------
-vtkMPRBaseData *manualContour3VControler::GetVtkMPRBaseData()
-{
- return _vtkmprbasedata;
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::SetPoint( int id ,int x ,int y ,int z ) // virtual
-{
- z=(int)_vtkmprbasedata->GetZ();
- if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
-
- if (_type==0)
- {
- xx=_vtkmprbasedata->GetX();
- }
- if (_type==1)
- {
- yy=_vtkmprbasedata->GetY();
- }
-
- manualPoint *mp = GetManualContourModel()->GetManualPoint(id);
- mp->SetPoint(xx,yy,zz);
-
- }
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::DeleteActualMousePoint_Others(int id)
-{
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->DeletePoint(id);
- mvbc->Refresh();
- }
-
-/*
- if (_manViewBaseCont1!=NULL){
- _manViewBaseCont1->DeletePoint(id);
- _manViewBaseCont2->DeletePoint(id);
- _manViewBaseCont3->DeletePoint(id);
-
- _manViewBaseCont1->Refresh();
- _manViewBaseCont2->Refresh();
- _manViewBaseCont3->Refresh();
-
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
- }
-*/
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::DeleteActualMousePoint(int x, int y)// virtual
-{
- int id=GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
- if (id!=-1){
- manualContourBaseControler::DeleteActualMousePoint( x , y );
- DeleteActualMousePoint_Others( id );
- }
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::MouseMove_Others(int id) // virtual
-{
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->SelectAllPossibleSelected(false);
- if (id!=-1)
- {
- mvbc->SetPointPosibleSelected(id,true);
- }
- mvbc->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
- mvbc->Refresh();
- }
-
-// EEDhh
-/*
- if (_manViewBaseCont1!=NULL){
- _manViewBaseCont1->SelectAllPossibleSelected(false);
- _manViewBaseCont2->SelectAllPossibleSelected(false);
- _manViewBaseCont3->SelectAllPossibleSelected(false);
- if (id!=-1){
- _manViewBaseCont1->SetPointPosibleSelected(id,true);
- _manViewBaseCont2->SetPointPosibleSelected(id,true);
- _manViewBaseCont3->SetPointPosibleSelected(id,true);
- }
- _manViewBaseCont1->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
- _manViewBaseCont2->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
- _manViewBaseCont3->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
-
- _manViewBaseCont1->Refresh();
- _manViewBaseCont2->Refresh();
- _manViewBaseCont3->Refresh();
-
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
- }
-*/
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::MouseMove(int x, int y) // virtual
-{
- manualContourControler::MouseMove( x , y );
- int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
- MouseMove_Others( id );
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::OnChar_Others()
-{
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->Refresh();
- }
-// EEDhh
-/*
- _manViewBaseCont1->Refresh();
- _manViewBaseCont2->Refresh();
- _manViewBaseCont3->Refresh();
-*/
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-}
-// ----------------------------------------------------------------------------
-bool manualContour3VControler::OnChar()
-{
- manualContourControler::OnChar();
- OnChar_Others();
- return true;
-}
-// ----------------------------------------------------------------------------
-void manualContour3VControler::ResetContour() // virtual
-{
- manualContourControler::ResetContour();
- ResetContour_Others();
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3VControler::ResetContour_Others()
-{
- manualViewBaseContour *mvbc;
- int i,size=this->_lstManualViewBaseContour.size();
- for ( i = 0 ; i < size ; i++ )
- {
- mvbc = _lstManualViewBaseContour[i];
- mvbc->DeleteContour();
- mvbc->CreateNewContour();
- }
-
-// EEDhh
-/*
- _manViewBaseCont1->DeleteContour();
- _manViewBaseCont2->DeleteContour();
- _manViewBaseCont3->DeleteContour();
- _manViewBaseCont1->CreateNewContour();
- _manViewBaseCont2->CreateNewContour();
- _manViewBaseCont3->CreateNewContour();
-*/
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualContour3DControler::manualContour3DControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualContour3DControler::~manualContour3DControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualContour3DControler * manualContour3DControler :: Clone() // virtual
-{
- manualContour3DControler * clone = new manualContour3DControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualContour3DControler::CopyAttributesTo( manualContour3DControler * cloneObject)
-{
- // Fathers object
- manualContourControler::CopyAttributesTo(cloneObject);
-
- cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
-}
-
-// ----------------------------------------------------------------------------
-bool manualContour3DControler::OnLeftButtonDown()
-{
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X,Y);
- MouseClickLeft(X,Y);
- return true;
-}
-// ----------------------------------------------------------------------------
-void manualContour3DControler::ResetOrientationPlane()
-{
- double p[3],rp[3],rn[3];
- p[0] = this->GetVtkMPRBaseData()->GetX( );
- p[1] = this->GetVtkMPRBaseData()->GetY( );
- p[2] = this->GetVtkMPRBaseData()->GetZ( );
- this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
- this->GetVtkMPRBaseData()->SetNormal(rn[0],rn[1],rn[2]);
-}
-// ----------------------------------------------------------------------------
-void manualContour3DControler::MouseClickLeft(int x, int y) // virtual
-{
- manualView3DContour *manualview3Dcontour=(manualView3DContour*)GetManualViewBaseContour();
- int id=manualview3Dcontour->GetIdPoint2(x,y);
- if ( (GetState()==0) && (id!=-1) )
- {
- manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
-
- this->GetVtkMPRBaseData()->SetX( mp->GetX() );
- this->GetVtkMPRBaseData()->SetY( mp->GetY() );
- this->GetVtkMPRBaseData()->SetZ( mp->GetZ() );
- ResetOrientationPlane();
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
- }
-
-
- manualContourControler::MouseClickLeft(x,y);
-
-}
-// ----------------------------------------------------------------------------
-bool manualContour3DControler::OnChar()
-{
- bool ok=true;
- manualContourControler::OnChar();
- char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
- if (keyCode==32){
- ok=false;
- ResetOrientationPlane();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
- return ok;
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3DControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
-{
- _vtkmprbasedata=vtkmprbasedata;
-}
-// ----------------------------------------------------------------------------
-vtkMPRBaseData *manualContour3DControler::GetVtkMPRBaseData()
-{
- return _vtkmprbasedata;
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3DControler::InsertPoint(int x, int y, int z ) // virtual
-{
- manualContourControler::InsertPoint( x, y, z );
- ResetOrientationPlane();
-}
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-manualContour3V3DControler::manualContour3V3DControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualContour3V3DControler::~manualContour3V3DControler()
-{
-}
-
-// ----------------------------------------------------------------------------
-manualContour3V3DControler * manualContour3V3DControler :: Clone() // virtual
-{
- manualContour3V3DControler * clone = new manualContour3V3DControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualContour3V3DControler::CopyAttributesTo( manualContour3V3DControler * cloneObject)
-{
- // Fathers object
- manualContour3DControler::CopyAttributesTo(cloneObject);
-
- cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
-}
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::InsertPoint(int x, int y, int z ) // virtual
-{
- manualContour3DControler::InsertPoint( x, y, z );
- _manualcontour3Vcontroler->InsertPoint_Others(0);
-}
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::AddPoint( int x, int y, int z )
-{
- manualContour3DControler::AddPoint( x, y, z );
- _manualcontour3Vcontroler->AddPoint_Others();
-}
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::DeleteActualMousePoint(int x, int y)
-{
- int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
- manualContour3DControler::DeleteActualMousePoint( x , y );
- _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
-}
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::MouseMove( int x, int y )
-{
- int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
- if ((this->GetState()!=7) && (ss!=1)){
- manualContour3DControler::MouseMove( x , y );
- int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
- _manualcontour3Vcontroler->MouseMove_Others(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
-{
- _manualcontour3Vcontroler = manualcontour3Vcontroler;
-}
-// ----------------------------------------------------------------------------
-manualContour3VControler *manualContour3V3DControler::GetManualContour3VControler()
-{
- return _manualcontour3Vcontroler;
-}
-// ----------------------------------------------------------------------------
-bool manualContour3V3DControler::OnChar() // virtual
-{
- if (manualContour3DControler::OnChar()==false )
- {
- _manualcontour3Vcontroler->OnChar_Others();
- }
- return true;
-}
-
-// ----------------------------------------------------------------------------
-void manualContour3V3DControler::ResetContour() // virtual
-{
- manualContourControler::ResetContour();
- _manualcontour3Vcontroler->ResetContour_Others();
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// _state = 0 // ..nothing..
-// _state = 1 // move with add point
-// _state = 5 // move
-// _state = 6 // move with insert point
-// _state = 7 // move with non selection
-
-manualContourControler::manualContourControler()
-{
- _easyCreation = true;
-
-}
-// ----------------------------------------------------------------------------
-manualContourControler::~manualContourControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualContourControler * manualContourControler :: Clone() // virtual
-{
- manualContourControler * clone = new manualContourControler();
- CopyAttributesTo(clone);
- return clone;
-}
-// ---------------------------------------------------------------------------
-void manualContourControler::CopyAttributesTo( manualContourControler * cloneObject)
-{
- // Fathers object
- manualContourBaseControler::CopyAttributesTo(cloneObject);
- cloneObject->SetEasyCreation( this->GetEasyCreation() );
-}
-
-// ----------------------------------------------------------------------------
-void manualContourControler::Configure() //virtual
-{
- // this->_manContModel->SetNumberOfPointsSpline(100);
-}
-
-// ----------------------------------------------------------------------------
-void manualContourControler::MouseClickLeft(int x, int y){
-
-
- bool ok = false;
- int z = GetZ();
- int size= GetManualViewBaseContour()->GetNumberOfPoints();
-
- // Insert a Control Point with shift+ClickLeft
- // int tt = GetState(); // JPRx
- vtkRenderWindowInteractor *vtkrenderwindowinteractor = _vtkInteractorStyleBaseView->GetInteractor();
-//EED3131
- if( IsEditable() )
- {
- if ( (_vtkInteractorStyleBaseView!=NULL) && (GetState()==0) && ( (vtkrenderwindowinteractor!=NULL) && (vtkrenderwindowinteractor->GetShiftKey()==1) ) )
- {
- ok=true;
- InsertPoint(x,y,z);
- size++;
- }
- // Start to Insert Control Points with ClickLeft (Empty contour)
- if ((GetState()==0) && (size==0) && (_easyCreation==true) )
- {
- ok=true;
- SetState(1);
- AddPoint(x,y,z);
- }
- // Continuie to Insert Control Points with ClickLeft (After being empty the contour)
- if ((GetState()==1) && (_easyCreation==true) )
- {
- ok=true;
- AddPoint(x,y,z);
- _bakIdPoint=GetNumberOfPointsManualContour() - 1;
- }
- // Insert Control Points IF Contour si Selected
- if ((GetState()==0) && GetManualViewBaseContour()->GetPosibleSelected() )
- {
- ok=true;
- InsertPoint(x,y,z);
- _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(6);
- }
- // Chose id of Control Point to be move
- if ( (GetState()==0 || GetState()==6) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) )
- {
- ok=true;
- _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
- // If nothing selected _state=7
- if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)==-1 ) )
- {
- //ok=true;
- _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(7);
- }
- }else{
- SetPosibleToMove( true );
- GetManualViewBaseContour()->SetSelected( GetManualViewBaseContour()->GetPosibleSelected() );
- } // IsEditable
-
- if ( GetState() == 0 && GetManualViewBaseContour()->GetPosibleSelected() )
- {
- SetMoving( true );
- ok=true;
- GetManualViewBaseContour()->InitMove(x,y,z);
- SetState(6);
- }
- if (ok==true)
- {
- GetManualViewBaseContour()->Refresh();
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourControler::MouseMove(int x, int y) // virtual
-{
- int z=GetZ();
- GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
- GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
- if (GetState()==1){ SetPoint( _bakIdPoint , x , y ,z); }
- if (GetState()==5){ SetPoint( _bakIdPoint , x , y ,z); }
- if ( GetState()==6 && !IsEditable() && GetPosibleToMove() &&IsMoving() )
- {
- GetManualViewBaseContour()->MoveContour(x,y,z);
- }
- if (GetState()!=7 || GetManualViewBaseContour()->GetPosibleSelected() ){
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
- if (!IsEditable())
- {
- GetManualViewBaseContour()->RemoveControlPoints();
-// GetManualViewBaseContour()->RemoveTextActor();
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
-
-}
-
-// ----------------------------------------------------------------------------
-void manualContourControler::MouseDLeft( int x, int y)//virtual
-{
- manualContourBaseControler::MouseDLeft( x, y);
- if ( IsEditable() )
- {
- GetManualViewBaseContour()->AddControlPoints();
- GetManualViewBaseContour()->AddTextActor();
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourControler::SetEasyCreation(bool easyCreation)
-{
- _easyCreation=easyCreation;
-}
-// ----------------------------------------------------------------------------
-bool manualContourControler::GetEasyCreation()
-{
- return _easyCreation;
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-manualContourPerpPlaneControler::manualContourPerpPlaneControler()
-{
- _flagMouseMove = true;
-}
-// ----------------------------------------------------------------------------
-manualContourPerpPlaneControler::~manualContourPerpPlaneControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualContourPerpPlaneControler * manualContourPerpPlaneControler :: Clone() // virtual
-{
- manualContourPerpPlaneControler * clone = new manualContourPerpPlaneControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualContourPerpPlaneControler::CopyAttributesTo( manualContourPerpPlaneControler * cloneObject)
-{
- // Fathers object
- manualContourControler::CopyAttributesTo(cloneObject);
-
- cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
- cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
- cloneObject->SetVtkInteractorStylePlane2D( this->GetVtkInteractorStylePlane2D() );
-}
-
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
-{
- _vtkmprbasedata = vtkmprbasedata;
-}
-
-// ----------------------------------------------------------------------------
-vtkMPRBaseData *manualContourPerpPlaneControler::GetVtkMPRBaseData()
-{
- return _vtkmprbasedata;
-}
-
-
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::InsertPoint(int x, int y, int z ) // virtual
-{
- manualContourControler::InsertPoint( x, y, z );
- _manualcontour3Vcontroler->InsertPoint_Others(0);
-}
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::AddPoint( int x, int y, int z )
-{
- manualContourControler::AddPoint( x, y, z );
- _manualcontour3Vcontroler->AddPoint_Others();
-}
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::DeleteActualMousePoint(int x, int y)
-{
- int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
- manualContourControler::DeleteActualMousePoint( x , y );
- _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
-}
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::MouseMove( int x, int y )
-{
- _flagMouseMove = true;
- int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
- if ((this->GetState()!=7) && (ss!=1)){
- manualContourControler::MouseMove( x , y );
- int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
- if (id!=-1)
- {
- _manualcontour3Vcontroler->MouseMove_Others(id);
- _flagMouseMove = false;
- }
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
-{
- _manualcontour3Vcontroler = manualcontour3Vcontroler;
-}
-// ----------------------------------------------------------------------------
-manualContour3VControler * manualContourPerpPlaneControler::GetManualContour3VControler()
-{
- return _manualcontour3Vcontroler;
-}
-// ----------------------------------------------------------------------------
-bool manualContourPerpPlaneControler::OnChar() // virtual
-{
- if (manualContourControler::OnChar()==false )
- {
- _manualcontour3Vcontroler->OnChar_Others();
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourPerpPlaneControler::OnMouseMove() // virtual
-{
- manualContourControler::OnMouseMove();
- return _flagMouseMove;
-}
-// ----------------------------------------------------------------------------
-bool manualContourPerpPlaneControler::OnLeftDClick() // virtual
-{
- manualContourControler::OnLeftDClick();
- return _flagMouseDClick;
-}
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::ResetContour() // virtual
-{
- manualContourControler::ResetContour();
- _manualcontour3Vcontroler->ResetContour_Others();
-}
-
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::MouseDLeft( int x, int y) // virtual
-{
- _flagMouseDClick=true;
- manualContourControler::MouseDLeft(x,y);
-
- if (GetManualViewBaseContour()->ifTouchContour(x,y,0)==true)
- {
- _flagMouseDClick = false;
- _vtkinteractorstyleplane2D->OnLeftDClick();
- ResetOrientationPlane();
- this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
- }
-
-// int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
-// if ( (GetState()==0) && (id!=-1) )
-// {
-// manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
-// _vtkmprbasedata->SetX( mp->GetX() );
-// _vtkmprbasedata->SetY( mp->GetY() );
-// _vtkmprbasedata->SetZ( mp->GetZ() );
-// ResetOrientationPlane();
-// this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
-// }
-}
-
-
-
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::ResetOrientationPlane()
-{
- double p[3],rp[3],rn[3];
- p[0] = _vtkmprbasedata->GetX( );
- p[1] = _vtkmprbasedata->GetY( );
- p[2] = _vtkmprbasedata->GetZ( );
- this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
-
- _vtkmprbasedata->SetNormal(rn[0],rn[1],rn[2]);
-}
-
-// ----------------------------------------------------------------------------
-void manualContourPerpPlaneControler::SetVtkInteractorStylePlane2D(InteractorStyleMaracas *vtkinteractorstyleplane2D)
-{
- _vtkinteractorstyleplane2D = vtkinteractorstyleplane2D;
-}
-// ----------------------------------------------------------------------------
-InteractorStyleMaracas * manualContourPerpPlaneControler::GetVtkInteractorStylePlane2D()
-{
- return _vtkinteractorstyleplane2D;
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// _state = 0 // ..nothing..
-// _state = 5 // move point
-// _state = 6 // move all
-// _state = 7 // Empty mouse drag
-
-manualRoiControler::manualRoiControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualRoiControler::~manualRoiControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualRoiControler * manualRoiControler :: Clone() // virtual
-{
- manualRoiControler * clone = new manualRoiControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualRoiControler::CopyAttributesTo( manualRoiControler * cloneObject)
-{
- // Fathers object
- manualContourBaseControler::CopyAttributesTo(cloneObject);
-}
-
-// ----------------------------------------------------------------------------
-void manualRoiControler::Configure() //virtual
-{
- this->GetManualContourModel()->SetNumberOfPointsSpline(5);
-}
-
-// ----------------------------------------------------------------------------
-
-void manualRoiControler::MouseClickLeft(int x, int y){
- int z = GetZ();
-
- if( IsEditable() )
- { // move control point
- if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
- } // IsEditable
-
- // Move contour
- if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
- GetManualViewBaseContour()->InitMove(x,y,z);
- SetState(6);
- }
-
- // if the firs time create 4 control points and move one point
- int size=GetManualViewBaseContour()->GetNumberOfPoints();
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(1);
- }
- }
-
-/*EED 21 Avril 2009
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- } else {
- SetPoint(0,x,y,z);
- SetPoint(1,x,y,z);
- SetPoint(2,x,y,z);
- SetPoint(3,x,y,z);
- }
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
-*/
-
- GetManualViewBaseContour()->Refresh();
-}
-
-// ----------------------------------------------------------------------------
-void manualRoiControler::MouseMove(int x, int y) // virtual
-{
- int z=GetZ();
-
-// this->_vtkInteractorStyleBaseView->
-
-
- GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
- GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
-
-
- if ( (GetState()==5) || (GetState()==1) ){
- SetPoint( bakIdPoint , x , y ,z);
- if (bakIdPoint==0)
- {
- SetPointX( 1 , x );
- SetPointY( 3 , y );
- }
- if (bakIdPoint==1)
- {
- SetPointX( 0 , x );
- SetPointY( 2 , y );
- }
- if (bakIdPoint==2)
- {
- SetPointX( 3 , x );
- SetPointY( 1 , y );
- }
- if (bakIdPoint==3)
- {
- SetPointX( 2 , x );
- SetPointY( 0 , y );
- }
- }
- if (GetState()==6){
- GetManualViewBaseContour()->MoveContour(x,y,z);
- }
- GetManualViewBaseContour()->Refresh();
-}
-// ----------------------------------------------------------------------------
-void manualRoiControler::DeleteActualMousePoint(int x, int y) // virtual
-{
-}
-// ----------------------------------------------------------------------------
-void manualRoiControler::InitRoi(int ww, int hh, double porcentage)
-{
- int zz;
- manualPoint *mp;
-
- if (GetManualContourModel()->GetSizeLstPoints() ==0)
- {
- zz = GetZ();
- AddPoint(0,0,zz);
- AddPoint(0,0,zz);
- AddPoint(0,0,zz);
- AddPoint(0,0,zz);
- }
-
- double pp1=porcentage;
- double pp2=1-porcentage;
-
- mp = GetManualContourModel()->GetManualPoint(2);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp1,hh*pp1,zz);
-
- mp = GetManualContourModel()->GetManualPoint(1);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp1,zz);
-
- mp = GetManualContourModel()->GetManualPoint(0);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp2,zz);
-
- mp = GetManualContourModel()->GetManualPoint(3);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp1,hh*pp2,zz);
-
- GetManualViewBaseContour() ->UpdateViewPoint(0);
- GetManualViewBaseContour() ->UpdateViewPoint(1);
- GetManualViewBaseContour() ->UpdateViewPoint(2);
- GetManualViewBaseContour() ->UpdateViewPoint(3);
-
- SetState(0);
- GetManualViewBaseContour()->Refresh();
-}
-
-// ----------------------------------------------------------------------------
-void manualRoiControler::SetRoi(int x1, int y1,int x2, int y2)
-{
- manualPoint *mp;
- InitRoi( 0 , 0 , 0.2 );
- mp = GetManualContourModel()->GetManualPoint(2);
- mp->SetPointX(x1);
- mp->SetPointY(y1);
-
- mp = GetManualContourModel()->GetManualPoint(1);
- mp->SetPointX(x2);
- mp->SetPointY(y1);
-
- mp = GetManualContourModel()->GetManualPoint(0);
- mp->SetPointX(x2);
- mp->SetPointY(y2);
-
- mp = GetManualContourModel()->GetManualPoint(3);
- mp->SetPointX(x1);
- mp->SetPointY(y2);
-
- GetManualViewBaseContour() ->UpdateViewPoint(0);
- GetManualViewBaseContour() ->UpdateViewPoint(1);
- GetManualViewBaseContour() ->UpdateViewPoint(2);
- GetManualViewBaseContour() ->UpdateViewPoint(3);
-}
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// EED08
-
-// _state = 0 // ..nothing..
-// _state = 5 // move point
-// _state = 6 // move all
-// _state = 7 // Empty mouse drag
-
-manualCircleControler::manualCircleControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualCircleControler::~manualCircleControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualCircleControler * manualCircleControler :: Clone() // virtual
-{
- manualCircleControler * clone = new manualCircleControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualCircleControler::CopyAttributesTo( manualCircleControler * cloneObject)
-{
- // Fathers object
- manualContourBaseControler::CopyAttributesTo(cloneObject);
-}
-
-// ----------------------------------------------------------------------------
-void manualCircleControler::Configure() //virtual
-{
-// this->GetManualContourModel()->SetNumberOfPointsSpline(5);
-}
-
-// ----------------------------------------------------------------------------
-void manualCircleControler::MouseClickLeft(int x, int y){
- int z = GetZ();
-
- if( IsEditable() )
- { // move control point
- if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
- }// IsEditable
-
- // move contour
- if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
- GetManualViewBaseContour()->InitMove(x,y,z);
- SetState(6);
- }
-
- // firstime create 2 control points and move one control point
- int size=GetManualViewBaseContour()->GetNumberOfPoints();
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(1);
- }
- }
-
-/*EED 21 Avril 2009
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- } else {
- SetPoint(0,x,y,z);
- SetPoint(1,x,y,z);
- }
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
-*/
-
- GetManualViewBaseContour()->Refresh();
-}
-// ----------------------------------------------------------------------------
-
-void manualCircleControler::MouseMove(int x, int y) // virtual
-{
- int z=GetZ();
-// this->_vtkInteractorStyleBaseView->
-
- GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
- GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
-
- if (GetState()==1){ SetPoint( bakIdPoint , x , y ,z); }
- if (GetState()==5){ SetPoint( bakIdPoint , x , y ,z); }
-
- if (GetState()==6){
- GetManualViewBaseContour()->MoveContour(x,y,z);
- }
- GetManualViewBaseContour()->Refresh();
-}
-
-
-// ----------------------------------------------------------------------------
-void manualCircleControler::DeleteActualMousePoint(int x, int y) // virtual
-{
-}
-// ----------------------------------------------------------------------------
-
-void manualCircleControler::InitRoi(int ww, int hh, double porcentage)
-{
- int zz;
- manualPoint *mp;
-
- if (GetManualContourModel()->GetSizeLstPoints() ==0)
- {
- zz = GetZ();
- AddPoint(0,0,zz);
- AddPoint(0,0,zz);
-// AddPoint(0,0,zz);
-// AddPoint(0,0,zz);
- }
-
- double pp1=porcentage;
- double pp2=1-porcentage;
-
-// mp = GetManualContourModel()->GetManualPoint(2);
-// zz=(int)mp->GetZ();
-// mp->SetPoint(ww*pp1,hh*pp1,zz);
-
- mp = GetManualContourModel()->GetManualPoint(1);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp1,zz);
-
- mp = GetManualContourModel()->GetManualPoint(0);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp2,zz);
-
-// mp = GetManualContourModel()->GetManualPoint(3);
-// zz=(int)mp->GetZ();
-// mp->SetPoint(ww*pp1,hh*pp2,zz);
-
- GetManualViewBaseContour() ->UpdateViewPoint(0);
- GetManualViewBaseContour() ->UpdateViewPoint(1);
-// GetManualViewBaseContour() ->UpdateViewPoint(2);
-// GetManualViewBaseContour() ->UpdateViewPoint(3);
-
- SetState(0);
- GetManualViewBaseContour()->Refresh();
-}
-
-// ----------------------------------------------------------------------------
-/*
-void manualCircleControler::SetRoi(int x1, int y1,int x2, int y2)
-{
- manualPoint *mp;
- InitRoi( 0 , 0 , 0.2 );
- mp = GetManualContourModel()->GetManualPoint(2);
- mp->SetPointX(x1);
- mp->SetPointY(y1);
-
- mp = GetManualContourModel()->GetManualPoint(1);
- mp->SetPointX(x2);
- mp->SetPointY(y1);
-
- mp = GetManualContourModel()->GetManualPoint(0);
- mp->SetPointX(x2);
- mp->SetPointY(y2);
-
- mp = GetManualContourModel()->GetManualPoint(3);
- mp->SetPointX(x1);
- mp->SetPointY(y2);
-
- GetManualViewBaseContour() ->UpdateViewPoint(0);
- GetManualViewBaseContour() ->UpdateViewPoint(1);
- GetManualViewBaseContour() ->UpdateViewPoint(2);
- GetManualViewBaseContour() ->UpdateViewPoint(3);
-}
-*/
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// AD:02-09
-
-// _state = 0 // ..nothing..
-// _state = 5 // move point
-// _state = 6 // move all
-// _state = 7 // Empty mouse drag
-
-manualLineControler::manualLineControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualLineControler::~manualLineControler()
-{
-}
-// ----------------------------------------------------------------------------
-manualLineControler * manualLineControler :: Clone() // virtual
-{
- manualLineControler * clone = new manualLineControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-void manualLineControler::CopyAttributesTo( manualLineControler * cloneObject)
-{
- // Fathers object
- manualContourBaseControler::CopyAttributesTo(cloneObject);
-}
-
-
-// ----------------------------------------------------------------------------
-void manualLineControler::MouseClickLeft(int x, int y){
- int z = GetZ();
-
- if( IsEditable() )
- { // move control point
- if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
- } //IsEditable
-
- // move contour
- if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
- GetManualViewBaseContour()->InitMove(x,y,z);
- SetState(6);
- }
-
- // fist time create 2 control points and move a control point
- int size=GetManualViewBaseContour()->GetNumberOfPoints();
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(1);
- }
- }
-
-
-/*EED 21 Avril 2009
- if (GetState()==0) {
- if (size==0){
- AddPoint(x,y,z);
- AddPoint(x,y,z);
- } else {
- SetPoint(0,x,y,z);
- SetPoint(1,x,y,z);
- }
- bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
- SetState(5);
- }
-*/
-
- GetManualViewBaseContour()->Refresh();
-}
-// ----------------------------------------------------------------------------
-
-void manualLineControler::MouseMove(int x, int y) // virtual
-{
- int z=GetZ();
-
- GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
- GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
-
- if (GetState()==1) { SetPoint( bakIdPoint , x , y ,z); }
- if (GetState()==5) { SetPoint( bakIdPoint , x , y ,z); }
-
- if (GetState()==6)
- {
- GetManualViewBaseContour()->MoveContour(x,y,z);
- }
- GetManualViewBaseContour()->Refresh();
-}
-
-
-// ----------------------------------------------------------------------------
-void manualLineControler::DeleteActualMousePoint(int x, int y) // virtual
-{
-}
-// ----------------------------------------------------------------------------
-
-void manualLineControler::InitRoi(int ww, int hh, double porcentage)
-{
- int zz;
- manualPoint *mp;
-
- if (GetManualContourModel()->GetSizeLstPoints() ==0)
- {
- zz = GetZ();
- AddPoint(0,0,zz);
- AddPoint(0,0,zz);
- }
-
- double pp1=porcentage;
- double pp2=1-porcentage;
-
- mp = GetManualContourModel()->GetManualPoint(0);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp2,zz);
-
- mp = GetManualContourModel()->GetManualPoint(1);
- zz=(int)mp->GetZ();
- mp->SetPoint(ww*pp2,hh*pp1,zz);
-
- GetManualViewBaseContour() ->UpdateViewPoint(0);
- GetManualViewBaseContour() ->UpdateViewPoint(1);
-
- SetState(0);
- GetManualViewBaseContour()->Refresh();
-}
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-manualContourBaseControler::manualContourBaseControler()
-{
- _manViewBaseCont = NULL;
- _manContModel = NULL;
- _state = 0;
- _z = 900;
- _editable = true;
- _posibleToMove = true;
- _moving = false;
- _created = false;
- _keyBoardMoving = false;
-}
-// ----------------------------------------------------------------------------
-manualContourBaseControler::~manualContourBaseControler()
-{
-}
-
-// ----------------------------------------------------------------------------
-manualContourBaseControler * manualContourBaseControler :: Clone() // virtual
-{
- manualContourBaseControler * clone = new manualContourBaseControler();
- CopyAttributesTo(clone);
- return clone;
-}
-
-// ---------------------------------------------------------------------------
-
-void manualContourBaseControler::CopyAttributesTo( manualContourBaseControler * cloneObject)
-{
- // Fathers object
- InteractorStyleMaracas::CopyAttributesTo(cloneObject);
- cloneObject->SetZ( this->GetZ() );
- cloneObject->SetState( this->GetState() );
- cloneObject->SetEditable( this->IsEditable() );
- cloneObject->SetPosibleToMove( this->GetPosibleToMove() );
- cloneObject->SetMoving( this->IsMoving() );
- cloneObject->SetCompleteCreation( this->GetIfCompleteCreation() );
- cloneObject->SetKeyBoardMoving( this->GetKeyBoardMoving() );
-}
-
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::Configure() //virtual
-{
-}
-
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnChar()
-{
- if ( _vtkInteractorStyleBaseView!=NULL )
- {
- char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
-
- int X,Y;
- wxVTKRenderWindowInteractor *_wxVTKiren;
- _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- _wxVTKiren->GetEventPosition(X, Y);
- //int Z = GetZ(); // JPRx
- // Delete Point
- if ((keyCode==8) || (keyCode==127))
- {
-
- if (!GetManualViewBaseContour()->GetPosibleSelected()==true)
- {
- DeleteActualMousePoint(X,Y);
- }
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
- else
- {
- // Magnet
- if (keyCode==32)
- {
- Magnet(X,Y);
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
- else if( !IsEditable() )
- {
- if ( keyCode == 'L' )
- {
- GetManualViewBaseContour()->MoveContour( -1, 0 );
- SetKeyBoardMoving( true );
- }
- else if ( keyCode == 'R' )
- {
- GetManualViewBaseContour()->MoveContour( 1, 0 );
- SetKeyBoardMoving( true );
- }
- else if ( keyCode == 'U' )
- {
- GetManualViewBaseContour()->MoveContour( 0, -1 );
- SetKeyBoardMoving( true );
- }
- else if ( keyCode == 'D' )
- {
- GetManualViewBaseContour()->MoveContour( 0, 1 );
- SetKeyBoardMoving( true );
- }
- else if ( keyCode == 'W' )//Diagonal left down
- {
- GetManualViewBaseContour()->MoveContour( -1, 1 );
- SetKeyBoardMoving( true );
- }
- else if ( keyCode == 'Q' )//Diagonal left up
- {
- GetManualViewBaseContour()->MoveContour( -1, -1 );
- SetKeyBoardMoving( true );
- }
- else if( keyCode == 'P' )//Diagonal right up
- {
- GetManualViewBaseContour()->MoveContour( 1, -1 );
- SetKeyBoardMoving( true );
- }
- else if( keyCode == 'M' )//Diagonal right down
- {
- GetManualViewBaseContour()->MoveContour( 1, 1 );
- SetKeyBoardMoving( true );
- }
- if( GetKeyBoardMoving() )
- {
- GetManualViewBaseContour()->Refresh();
- this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
- }
- }
- }
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnMouseMove()
-{
-
- if ( _vtkInteractorStyleBaseView!=NULL)
- {
- int X,Y;
- wxVTKRenderWindowInteractor *_wxVTKiren;
- _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- _wxVTKiren->GetEventPosition( X , Y );
-
-
- if ( (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) &&
- (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) ) {
- MouseMove(X,Y);
- }
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnLeftButtonDown()
-{
- SetKeyBoardMoving( false );
- if ( _vtkInteractorStyleBaseView!=NULL )
- {
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X,Y);
-
- MouseClickLeft(X,Y);
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnLeftButtonUp()
-{
- if ( _vtkInteractorStyleBaseView!=NULL )
- {
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X,Y);
- MouseReleaseLeft(X,Y);
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnLeftDClick()
-{
- if ( _vtkInteractorStyleBaseView!=NULL )
- {
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X,Y);
-
- this->MouseDLeft(X,Y);
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnMiddleButtonDown()
-{
-// SetKeyBoardMoving( false );
- if ( _vtkInteractorStyleBaseView!=NULL )
- {
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X,Y);
- GetManualViewBaseContour()->InitMove( X, Y,GetZ());
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnMiddleButtonUp()
-{
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnRightButtonDown()
-{
- if( _vtkInteractorStyleBaseView!= NULL )
- {
- int X,Y;
- wxVTKRenderWindowInteractor *wxVTKiren;
- wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
- wxVTKiren->GetEventPosition(X, Y);
-
- SetCompleteCreation( true );
- SetKeyBoardMoving( false );
- MouseClickRight(X,Y);
- }
- return true;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::OnRightButtonUp()
-{
- return true;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetModelView(manualContourModel *manContModel, manualViewBaseContour *manViewBaseCont){
- _manContModel = manContModel;
- _manViewBaseCont = manViewBaseCont;
- _manViewBaseCont->SetEditable( &_editable );
-}
-// ----------------------------------------------------------------------------
-manualContourModel* manualContourBaseControler::GetManualContourModel()
-{
- return _manContModel;
-}
-// ----------------------------------------------------------------------------
-manualViewBaseContour* manualContourBaseControler::GetManualViewBaseContour()
-{
- return _manViewBaseCont;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::MouseClickLeft(int x, int y) // virtual
-{
-
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::MouseClickRight(int x, int y)
-{
-// if (_state==1)
-// {
-// _state=0;
-// }
- SetEditable( false );
- SetPosibleToMove( false );
- _state = 0;
-
-//EED 24Avril2009 _state=7;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::MouseReleaseLeft(int x, int y)
-{
- if (_state==5){ _state = 0; }
- if (_state==6){ _state = 0; }
- if (_state==7){ _state = 0; }
- SetMoving( false );
- GetManualViewBaseContour()->SelectPosibleContour(x,y,GetZ());
- if( GetIfCompleteCreation() && IsEditable() && !GetManualViewBaseContour()->GetPosibleSelected() && (GetManualViewBaseContour()->GetIdPoint(x,y,GetZ())==-1) )
- {
- SetEditable( false );
- SetPosibleToMove( false );
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::MouseDLeft(int x, int y )
-{
- if (_state==0)
- {
- int z=GetZ();
- GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
- GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
- if ( GetManualViewBaseContour()->GetPosibleSelected() )
- {
- _editable = true;
- }
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::MouseMove(int x, int y) // virtual
-{
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetState(int state)
-{
- _state=state;
-}
-// ----------------------------------------------------------------------------
-int manualContourBaseControler::GetState()
-{
- return _state;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::IsEditable( )
-{
- return _editable;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetEditable( bool condition )
-{
- if (GetManualViewBaseContour()!=NULL) {
- if( !condition )
- {
- GetManualViewBaseContour()->RemoveControlPoints();
- }
- GetManualViewBaseContour()->SetSelected( condition );
- }
- _editable = condition;
-}
-
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::GetPosibleToMove()
-{
- return _posibleToMove;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetPosibleToMove( bool condition )
-{
- _posibleToMove = condition;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::IsMoving()
-{
- return _moving;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetMoving( bool condition )
-{
- _moving = condition;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetCompleteCreation( bool condition )
-{
- _created = condition;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::GetIfCompleteCreation ( )
-{
- return _created;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetKeyBoardMoving( bool condition )
-{
- _keyBoardMoving = condition;
-}
-// ----------------------------------------------------------------------------
-bool manualContourBaseControler::GetKeyBoardMoving( )
-{
- return _keyBoardMoving;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::CreateNewManualContour(){
- _manViewBaseCont->CreateNewContour();
-}
-// ----------------------------------------------------------------------------
-int manualContourBaseControler::GetNumberOfPointsManualContour(){
- return _manViewBaseCont->GetNumberOfPoints();
-}
-// ----------------------------------------------------------------------------
-
-//JSTG - 25-02-08 -------------------------------------------------------------
-int manualContourBaseControler::GetNumberOfPointsSplineManualContour(){
- //return _manViewBaseCont->GetNumberOfPointsSpline();
- return _manContModel->GetNumberOfPointsSpline();
-}
-// ----------------------------------------------------------------------------
-
-double* manualContourBaseControler::GetVectorPointsXManualContour(){
- return _manViewBaseCont->GetVectorPointsXManualContour();
-}
-// ----------------------------------------------------------------------------
-double* manualContourBaseControler::GetVectorPointsYManualContour(){
- return _manViewBaseCont->GetVectorPointsYManualContour();
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::DeleteContour(){
- _manViewBaseCont->DeleteContour();
- _manContModel->DeleteAllPoints();
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::DeleteActualMousePoint(int x, int y)// virtual
-{
- if ((_manContModel!=NULL) && (_manViewBaseCont!=NULL) )
- {
- int id=_manViewBaseCont->GetIdPoint(x,y,GetZ());
- if ((id!=-1) && (_manContModel->GetSizeLstPoints()>2) ){
- _manContModel->DeletePoint(id);
- _manViewBaseCont->DeletePoint(id);
- }
- }
- _state = 0;
-}
-
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::Magnet(int x, int y)
-{
- if( IsEditable())
- {
- /*int id= */ _manViewBaseCont->GetIdPoint(x,y,GetZ()); // JPRx
- if (GetManualContourModel()!=NULL){
- double xx = x;
- double yy = y;
- double zz = GetZ();
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- int id = GetManualContourModel()->GetIdPoint(xx,yy,zz,32000,-1);
- if (id!=-1)
- {
- manualPoint *mp = GetManualContourModel()->GetManualPoint(id);
- mp->SetPoint(xx,yy,zz);
- }
- // GetManualViewBaseContour()->UpdateViewPoint(id);
- }
- _state = 0;
- }
-}
-
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetZ(int z)
-{
- _z=z;
-}
-// ----------------------------------------------------------------------------
-int manualContourBaseControler::GetZ()
-{
- return _z;
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::AddPoint(int x, int y, int z) // virtual
-{
- if (GetManualContourModel()!=NULL){
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- /*int id =*/ GetManualContourModel()->AddPoint(xx,yy,zz); // JPRx
- GetManualViewBaseContour()->AddPoint();
-// GetManualViewBaseContour()->UpdateViewPoint(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::InsertPoint(int x,int y,int z) // virtual
-{
-//EEDzz
- int id=-1;
- if (GetManualContourModel()!=NULL){
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- if (GetManualContourModel()->GetSizeLstPoints()>1){
- id = GetManualContourModel()->InsertPoint(xx,yy,zz);
- GetManualViewBaseContour()->InsertPoint(id);
-// GetManualViewBaseContour()->UpdateViewPoint(id);
- } else {
- GetManualContourModel()->AddPoint(xx,yy,zz);
- GetManualViewBaseContour()->AddPoint();
-// AddPoint(x,y,z);
-// GetManualViewBaseContour()->UpdateViewPoint(id);
- }
- }
-}
-
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetPoint( int id ,int x , int y , int z){ // virtual
- if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
- double xx = x;
- double yy = y;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- manualPoint *mp = _manContModel->GetManualPoint(id);
- mp->SetPoint(xx,yy,zz);
- GetManualViewBaseContour()->UpdateViewPoint(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetPointX( int id ,int x ){
- if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
- double xx = x;
- double yy = 0;
- double zz = 0;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- manualPoint *mp = _manContModel->GetManualPoint(id);
- mp->SetPointX(xx);
- GetManualViewBaseContour()->UpdateViewPoint(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetPointY( int id ,int y ){
- if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
- double xx = 0;
- double yy = y;
- double zz = 0;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- manualPoint *mp = _manContModel->GetManualPoint(id);
- mp->SetPointY(yy);
- GetManualViewBaseContour()->UpdateViewPoint(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::SetPointZ( int id ,int z ){
- if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
- double xx = 0;
- double yy = 0;
- double zz = z;
- GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
- manualPoint *mp = _manContModel->GetManualPoint(id);
- mp->SetPointZ(zz);
- GetManualViewBaseContour()->UpdateViewPoint(id);
- }
-}
-// ----------------------------------------------------------------------------
-void manualContourBaseControler::ResetContour() // virtual
-{
- this->DeleteContour();
- GetManualViewBaseContour()->CreateNewContour();
- this->SetState(0);
-}
-
+++ /dev/null
-
-#ifndef MANUAL_CONTOUR_H
-#define MANUAL_CONTOUR_H
-
-
-//--
-/* // EEDxx include
-#include <vtkProperty.h>
-#include "vtkActor.h"
-#include "vtkPoints.h"
-#include "vtkImageViewer2.h"
-#include "vtkImageData.h"
-*/
-
-#include "vtkRenderWindow.h"
-
-#include "vtkRenderer.h"
-#include "vtkRenderWindowInteractor.h" //extremely important with VC++ don't remove !
-#include "vtkCommand.h"
-#include "vtkPolyData.h"
-#include "vtkCellArray.h"
-#include "vtkPolyDataMapper.h"
-#include "vtkInteractorObserver.h"
-#include "vtkInteractorStyleImage.h"
-#include <vtkKochanekSpline.h>
-
-#include <vtkCellPicker.h>
-
-
-#include <vtkCamera.h>
-#include <vtkPolyLine.h>
-#include <vtkDataSetMapper.h>
-#include <vtkUnstructuredGrid.h>
-
-#include "wxVTKRenderWindowInteractor.h"
-
-#include "InteractorStyleMaracas.h"
-//--
-
-#include <vector>
-
-
-#include "wxVtkBaseView.h"
-#include "marTypes.h"
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-class manualPoint{
-public:
- manualPoint();
- virtual ~manualPoint();
- void SetPoint(double x,double y,double z);
- void SetPointX(double x);
- void SetPointY(double y);
- void SetPointZ(double z);
- double GetX();
- double GetY();
- double GetZ();
- virtual manualPoint * Clone();
-private:
- double _x;
- double _y;
- double _z;
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualContourModel{
-public:
- manualContourModel();
- virtual ~manualContourModel();
-
- virtual manualContourModel * Clone();
- void CopyAttributesTo( manualContourModel *cloneObject );
- virtual void Open(FILE *ff); // virtual
- virtual void Save(FILE *ff); // virtual
- virtual int GetTypeModel(); // virtual
-
- int AddPoint(double x,double y,double z);
- int InsertPoint(double x,double y,double z);
-//JSTG 25-04-08 -------------------------------------------------------
- void InsertPoint_id(int id, double x,double y,double z);
-//---------------------------------------------------------------------
- void AddManualPoint( manualPoint* theManualPoint );
-
- void DeletePoint(int i);
- void DeleteAllPoints();
-
- void MovePoint(int i,double dx,double dy,double dz);
- void MoveLstPoints(double dx,double dy,double dz);
- void MoveAllPoints(double dx,double dy,double dz);
-
- int GetIdPoint(double x, double y, double z, int i_range,int type);
- manualPoint* GetManualPoint(int id);
- int GetSizeLstPoints();
- int GetNumberOfPointsSpline();
- void SetNumberOfPointsSpline(int size);
-
- virtual void UpdateSpline();
- void SetCloseContour(bool closeContour);
- bool IfCloseContour();
-//JSTG 25-02-08 -----------------------------------------------------------------
- //void GetSplinePoint(double t, double &x, double &y, double &z); //Method Original
- //void GetSplineiPoint(int i, double &x, double &y, double &z); //Method Original
-//-------------------------------------------------------------------------------
- double GetPathSize();
- double GetPathArea();
-
- void GetNearestPointAndNormal(double *p, double *rp, double *rn);
-
-// JSTG 25-02-08 -----------------------------------------------------------------
- virtual void GetSpline_i_Point(int i, double *x, double *y, double *z);
- void GetSpline_t_Point(double t, double *x, double *y, double *z);
-//--------------------------------------------------------------------------------
-
- virtual std::vector<manualContourModel*> ExploseModel( );
-
-
-private:
- int _sizePointsContour;
- std::vector<manualPoint*> _lstPoints;
- bool _closeContour;
- vtkKochanekSpline *_cntSplineX;
- vtkKochanekSpline *_cntSplineY;
- vtkKochanekSpline *_cntSplineZ;
-
-//JSTG 25-02-08 ----------------------------------------
- double _delta_JSTG;
-//------------------------------------------------------
-
-};
-
-
-//--------------------------------------------------------
-
-class creaMaracasVisu_EXPORT manualContourModelCircle : public manualContourModel
-{
-public:
- manualContourModelCircle();
- virtual ~manualContourModelCircle();
- virtual manualContourModelCircle *Clone();
- void CopyAttributesTo( manualContourModelCircle *cloneObject);
- virtual void GetSpline_i_Point(int i, double *x, double *y, double *z);
-private:
- double _deltaAngle;
- double _radio;
- double _centerX;
- double _centerY;
- double _centerZ;
-
- virtual int GetTypeModel();
- virtual void UpdateSpline();
-};
-
-//--------------------------------------------------------
-
-class creaMaracasVisu_EXPORT manualContourModelLine : public manualContourModel
-{
-public:
- manualContourModelLine();
- virtual ~manualContourModelLine();
- virtual manualContourModelLine *Clone();
- void CopyAttributesTo( manualContourModelLine *cloneObject);
-// virtual void GetSpline_i_Point(int i, double *x, double *y, double *z);
-private:
- virtual int GetTypeModel();
-};
-
-//--------------------------------------------------------
-
-class manualContourModelBullEyeSector : public manualContourModel
-{
-public:
- manualContourModelBullEyeSector();
- virtual ~manualContourModelBullEyeSector();
- virtual manualContourModelBullEyeSector *Clone();
- void CopyAttributesTo( manualContourModelBullEyeSector *cloneObject);
- void SetSector( double radioA,
- double radioB,
- double ang,
- double angDelta);
- void GetSector( double *radioA,
- double *radioB,
- double *ang,
- double *angDelta);
- void SetSize(double ww,double hh);
- void SetCenter(double cx,double cy);
- virtual void GetSpline_i_Point(int i, double *x, double *y, double *z);
- virtual void Save(FILE *ff);
- virtual void Open(FILE *ff);
-
-private:
- double _radioA;
- double _radioB;
- double _ang;
- double _angDelta;
- double _ww;
- double _hh;
- double _cx;
- double _cy;
-
- virtual int GetTypeModel();
-};
-
-
-//--------------------------------------------------------
-//eed004
-class creaMaracasVisu_EXPORT manualContourModelBullEye : public manualContourModel
-{
-public:
- manualContourModelBullEye();
- virtual ~manualContourModelBullEye();
- virtual manualContourModelBullEye *Clone();
- void CopyAttributesTo( manualContourModelBullEye *cloneObject);
- virtual void Save(FILE *ff);
- virtual void Open(FILE *ff);
-
- int GetNumberOfPointsSplineSectorBulleEje();
- void SetNumberOfPointsSplineSectorBulleEje(int);
- void AddSector( double radioA,
- double radioB,
- double ang,
- double angDelta);
- void GetSector( int id,
- double *radioA,
- double *radioB,
- double *ang,
- double *angDelta);
- manualContourModelBullEyeSector * GetModelSector(int id);
-
- void ResetSectors();
- int GetSizeOfSectorLst();
- virtual void UpdateSpline(); // virtual
- virtual std::vector<manualContourModel*> ExploseModel( );
-
-
-
-private:
- int _numberPointsSlineBySector;
- std::vector<manualContourModelBullEyeSector *> _lstModelBullEyeSector;
-
-/* Borrame Eduardo
- std::vector<double> _lstRadioA;
- std::vector<double> _lstRadioB;
- std::vector<double> _lstAng;
- std::vector<double> _lstAngDelta;
-*/
-
- virtual int GetTypeModel();
-};
-
-
-
-//--------------------------------------------------------
-
-//JSTG 25-02-08 ------------------------------------------
-class creaMaracasVisu_EXPORT manualContourModelRoi : public manualContourModel
-{
- public:
- manualContourModelRoi();
- virtual ~manualContourModelRoi();
- virtual manualContourModelRoi *Clone();
- void CopyAttributesTo( manualContourModelRoi *cloneObject);
-private:
- virtual int GetTypeModel();
-};
-//--------------------------------------------------------
-
-
-class manualViewPoint{
-public:
-
-// static int range;
-
- manualViewPoint(wxVtkBaseView *wxvtkbaseview);
- ~manualViewPoint();
- void SetSelected(bool selected);
- void SetPosibleSelected(bool posibleSelected);
- bool GetSelected();
- bool GetPosibleSelected();
- void DeleteVtkObjects();
- vtkActor* CreateVtkPointActor();
- void SetPositionXY(double x, double y, double range, double posZ);
- vtkActor* GetVtkActor();
- void UpdateColorActor();
- void GetSpacing(double spc[3]);
- void SetSpacing(double spc[3]);
- void SetWidthLine( double width);
-
-
-private:
- bool _selected;
- bool _posibleSelected;
- vtkPoints *_pts;
- vtkPolyData *_pd;
- vtkActor *_pointVtkActor;
- vtkPolyDataMapper *_bboxMapper;
- wxVtkBaseView *_wxvtkbaseview;
- double _widthline;
-protected:
- double _spc[3];
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualViewBaseContour{
-public:
- manualViewBaseContour();
- virtual ~manualViewBaseContour();
-
- virtual int GetType();
- virtual void Save(FILE *pFile);
- virtual void Open(FILE *pFile);
-
- void AddPoint();
- void AddPoint( manualViewPoint * manualViewPoint );
- void InsertPoint(int id);
- void DeleteContour();
- void DeletePoint(int x, int y,int z);
- virtual void DeletePoint(int id);
-
- virtual void UpdateViewPoint(int id);
- virtual void UpdateViewPoints();
-
- void SetSelected(bool selected);
- void SetPosibleSelected(bool posibleSelected);
- bool GetSelected();
- bool GetPosibleSelected();
- void DeleteSelectedPoints();
- bool GetEditable();
- void SetEditable( bool * condition );
-
-
-
- virtual int GetIdPoint(int x, int y, int z);
-
- void SelectPoint(int i,bool select);
- void SelectLstPoints();
- void SelectAllPoints(bool select);
- virtual int SelectPosiblePoint(int x, int y ,int z);
- bool SelectPosibleContour(int x, int y ,int z);
- void SelectAllPossibleSelected(bool select);
- void SetPointSelected(int id,bool select);
- void SetPointPosibleSelected(int id,bool select);
- void SetIfViewControlPoints(bool ifShow);
- bool GetIfViewControlPoints();
-
- void UnSelectPoint(int i);
- void UnSelectLstPoints();
- void UnSelectAllPoints();
-
- void SetModel(manualContourModel *manContModel);
- void SetWxVtkBaseView(wxVtkBaseView *wxvtkbaseview);
-
- virtual void Refresh();
- int GetNumberOfPoints(); // ???
- //int GetNumberOfPointsSpline(); //JSTG 25-02-08 In ContourModel is the same method
- //void SetNumberOfPointsSpline(int size); //JSTG 25-02-08 In ContourModel is the same method
-
- void CreateNewContour();
- double* GetVectorPointsXManualContour();
- double* GetVectorPointsYManualContour();
- double* GetVectorPointsZManualContour();
-
- virtual bool ifTouchContour(int x,int y, int z);
- void UpdateColorActor();
-
- void SetRange(int range);
- int GetRange();
- void SetZ(int z);
- int GetZ();
-
- wxVtkBaseView *GetWxVtkBaseView();
-
- virtual void InitMove(int x, int y, int z);
- virtual void MoveContour(int x, int y, int z);
- virtual void MoveContour(int horizontalUnits, int verticalUnits );
- virtual void GetMinMax( double &minX,double &minY, double &minZ, double &maxX, double &maxY, double &maxZ );
- virtual void TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type=2);
-
- void ClearContour();
- virtual void ClearPoint(int id);
-
- void SetVisible(bool ok);
- void SetShowText(bool ok);
-
- void GetSpacing(double spc[3]);
- void SetSpacing(double spc[3]);
-
- void SetColorNormalContour(double r, double g, double b);
- void GetColorNormalContour(double &r, double &g, double &b);
- void SetColorEditContour(double r, double g, double b);
- void GetColorEditContour(double &r, double &g, double &b);
- void SetColorSelectContour(double r, double g, double b);
- void GetColorSelectContour(double &r, double &g, double &b);
-
- //Addinging and removing from visualization specific actors included in the viewer contour
- void AddCompleteContourActor( bool ifControlPoints = false);
- void RemoveCompleteContourActor();
- virtual void AddSplineActor();
- virtual void RemoveSplineActor();
- void AddControlPoints();
- void RemoveControlPoints();
- void AddTextActor();
- void RemoveTextActor();
-
- virtual manualViewBaseContour * Clone();
- void CopyAttributesTo( manualViewBaseContour *cloneObject );
- virtual void RefreshContour();
- void SetWidthLine(double width);
- double GetWidthLine();
-
- virtual void ConstructVTKObjects();
-
-private:
- int _range;
-
- wxVtkBaseView *_wxvtkbaseview;
- bool _selected;
- bool *_editable;
- bool _posibleSelected;
- bool _viewControlPoints;
-
-
- vtkPolyData *_pd;
- vtkActor *_contourVtkActor;
- vtkPolyDataMapper *_bboxMapper;
-
- double _coulorEdit_r;
- double _coulorEdit_g;
- double _coulorEdit_b;
- double _coulorNormal_r;
- double _coulorNormal_g;
- double _coulorNormal_b;
- double _coulorSelection_r;
- double _coulorSelection_g;
- double _coulorSelection_b;
- double _widthline;
-
- void DeleteVtkObjects();
- virtual void RefreshText();
-
-
-protected:
-
- // text
- bool _show_text;
- int _id_viewPoint_for_text;
- vtkTextActor *_textActor;
- manualContourModel *_manContModel;
- vtkPoints *_pts;
-// JSTG 25-02-08 --------------------------------------------
- int _sizePointsContour;
-//-----------------------------------------------------------
- std::vector<manualViewPoint*> _lstViewPoints;
- double _spc[3];
-
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualViewContour: public manualViewBaseContour
-{
-public:
- manualViewContour();
- virtual ~manualViewContour();
- virtual manualViewContour * Clone();
- void CopyAttributesTo( manualViewContour *cloneObject );
-
- virtual int GetType();
- virtual void Save(FILE *pFile);
- virtual void Open(FILE *pFile);
-
-
- virtual void RefreshContour();
- virtual bool ifTouchContour(int x,int y, int z);
- virtual void InitMove(int x, int y, int z);
- virtual void MoveContour(int x, int y, int z);
- virtual void MoveContour(int horizontalUnits, int verticalUnits );
- virtual void DeletePoint(int id);
- virtual void ClearPoint(int id);
- void SetMesureScale(double mesureScale);
-private:
- double _mesureScale;
- std::vector< std::vector<double> > _initialMovingPoints;
- manualContourModel * _initialConoturModel;
-
- virtual void RefreshText();
-protected:
-
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-class manualView3VContour: public manualViewContour
-{
-public:
- manualView3VContour(int type);
- virtual ~manualView3VContour();
- virtual manualView3VContour * Clone();
- void CopyAttributesTo( manualView3VContour *cloneObject );
-
- virtual void RefreshContour();
- virtual int GetIdPoint(int x, int y, int z);
- virtual void UpdateViewPoint(int id);
- virtual bool ifTouchContour(int x,int y,int z);
- int GetType();
-
-protected:
-private:
- int _type;
- void FilterCordinateXYZ(double &x,double &y,double &z);
-
-// JSTG 25-02-08 -------------------------------------
- //manualContourModel *_manContModel;
-//----------------------------------------------------
-
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-class manualView3DContour: public manualViewContour
-{
-public:
- manualView3DContour();
- virtual ~manualView3DContour();
- virtual manualView3DContour * Clone();
- void CopyAttributesTo( manualView3DContour *cloneObject );
-
- virtual void TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type);
- void SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata);
-
- virtual int SelectPosiblePoint ( int x, int y, int z );
- void SetDimensions(int w, int h, int d);
-
- int GetIdPoint2(int x, int y);
-
-protected:
- vtkMPRBaseData *_vtkmprbasedata;
-private:
- int _w;
- int _h;
- int _d;
-
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualViewRoi: public manualViewContour
-{
-public:
- manualViewRoi();
- virtual ~manualViewRoi();
-
- virtual int GetType();
- virtual manualViewRoi * Clone();
- void CopyAttributesTo( manualViewRoi *cloneObject );
-
- virtual void RefreshContour();
- virtual bool ifTouchContour(int x,int y, int z);
- virtual void InitMove(int x, int y, int z);
- virtual void MoveContour(int x, int y, int z);
- void GetMinMax(double &minX,double &minY, double &maxX, double &maxY);
-
-private:
- double _dp0[3];
- double _dp1[3];
- double _dp2[3];
- double _dp3[3];
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-class creaMaracasVisu_EXPORT manualViewBullEyeSector: public manualViewContour
-{
-public:
- manualViewBullEyeSector();
- virtual void RefreshContour();
-};
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-//EED004
-class creaMaracasVisu_EXPORT manualViewBullEye: public manualViewRoi
-{
-public:
- manualViewBullEye();
- virtual ~manualViewBullEye();
-
- virtual int GetType();
- virtual manualViewBullEye * Clone();
- void CopyAttributesTo( manualViewBullEye *cloneObject );
-
-// void UpdateColorActorBullEye();
-// void DeleteVtkObjectsBullEye();
- virtual void RemoveSplineActor();
- virtual void AddSplineActor();
- virtual void ConstructVTKObjects();
- virtual void RefreshContour();
-
-private:
-
-/*EED Borrame
- std::vector<sectorBullEye* > lstSectorBullEye;
-*/
-
- std::vector<manualViewBaseContour* > lstSectorBullEye;
-
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// EED08
-class creaMaracasVisu_EXPORT manualViewCircle: public manualViewContour
-{
-public:
- manualViewCircle();
- virtual ~manualViewCircle();
-
- virtual int GetType();
- virtual manualViewCircle * Clone();
- void CopyAttributesTo( manualViewCircle *cloneObject );
-
- virtual void InitMove(int x, int y, int z);
- virtual void MoveContour(int x, int y, int z);
- void GetMinMax(double &minX,double &minY, double &maxX, double &maxY);
-
-private:
- double _dp0[3];
- double _dp1[3];
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// AD:02-09
-class creaMaracasVisu_EXPORT manualViewLine: public manualViewContour
-{
-public:
- manualViewLine();
- virtual ~manualViewLine();
-
- virtual int GetType();
- virtual manualViewLine * Clone();
- void CopyAttributesTo( manualViewLine *cloneObject );
-
- virtual void InitMove(int x, int y, int z);
- virtual void MoveContour(int x, int y, int z);
-
-private:
- double _dp0[3];
- double _dp1[3];
-};
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-class creaMaracasVisu_EXPORT manualContourBaseControler: public InteractorStyleMaracas
-{
-public:
- manualContourBaseControler();
- virtual ~manualContourBaseControler();
-
- virtual manualContourBaseControler * Clone();
- void CopyAttributesTo( manualContourBaseControler *cloneObject );
-
- virtual bool OnChar();
- virtual bool OnMouseMove();
- virtual bool OnLeftButtonDown();
- virtual bool OnLeftButtonUp();
- virtual bool OnLeftDClick();
- virtual bool OnMiddleButtonDown();
- virtual bool OnMiddleButtonUp();
- virtual bool OnRightButtonDown();
- virtual bool OnRightButtonUp();
-
- void SetModelView(manualContourModel *manContModel, manualViewBaseContour *manViewBaseCont);
- manualContourModel * GetManualContourModel();
- manualViewBaseContour * GetManualViewBaseContour();
-
-
- virtual void MouseClickLeft(int x, int y);
- virtual void MouseClickRight(int x, int y);
- virtual void MouseDLeft(int x, int y);
-
- virtual void MouseMove(int x, int y);
- virtual void MouseReleaseLeft(int x, int y);
-
- void SetState(int state);
- int GetState();
- bool IsEditable();
- void SetEditable( bool condition );
- bool GetPosibleToMove();
- void SetPosibleToMove( bool condition );
- bool IsMoving();
- void SetMoving( bool condition );
- void SetCompleteCreation( bool condition );
- bool GetIfCompleteCreation ( );
- void SetKeyBoardMoving( bool condition );
- bool GetKeyBoardMoving( );
-
- void CreateNewManualContour();
- int GetNumberOfPointsManualContour();
- int GetNumberOfPointsSplineManualContour();
- void DeleteContour();
- virtual void DeleteActualMousePoint(int x, int y );
- double* GetVectorPointsXManualContour();
- double* GetVectorPointsYManualContour();
-
-
- void SetZ(int z);
- virtual int GetZ();
-
- virtual void AddPoint(int x, int y, int z);
- virtual void InsertPoint(int x, int y, int z);
-
- virtual void SetPoint( int id ,int x ,int y ,int z);
- void SetPointX( int id ,int x );
- void SetPointY( int id ,int y );
- void SetPointZ( int id ,int z );
-
- void Magnet(int x, int y);
- virtual void ResetContour();
-
- virtual void Configure();
-
-
-//EED Borrame
-// virtual manualContourBaseControler * Clone( manualViewBaseContour * cloneView = NULL, manualContourModel * cloneModel = NULL );
-
-
-private:
- manualViewBaseContour *_manViewBaseCont;
- manualContourModel *_manContModel;
-
- int _z;
- int _state;
- bool _editable;
- bool _posibleToMove;
- bool _moving;
- bool _created;
- bool _keyBoardMoving;
-
-};
-
-
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualContourControler: public manualContourBaseControler
-{
-public:
- manualContourControler();
- virtual ~manualContourControler();
- virtual manualContourControler * Clone();
- void CopyAttributesTo( manualContourControler *cloneObject );
-
- virtual void MouseClickLeft(int x, int y);
- virtual void MouseMove(int x, int y);
- virtual void MouseDLeft( int x, int y);
- void SetEasyCreation(bool easyCreation);
- bool GetEasyCreation();
-
- virtual void Configure();
-
-protected:
- int _bakIdPoint;
-private:
- bool _easyCreation;
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-
-
-class creaMaracasVisu_EXPORT manualContour3VControler: public manualContourControler
-{
-public:
- manualContour3VControler(int type);
- virtual ~manualContour3VControler();
- virtual manualContour3VControler * Clone();
- void CopyAttributesTo( manualContour3VControler *cloneObject );
-
- virtual bool OnChar();
- virtual void AddPoint(int x, int y, int z);
- virtual void InsertPoint(int x, int y, int z);
- virtual void MouseMove(int x, int y);
- virtual void ResetContour();
-
- void AddManualViewBaseContour( manualViewBaseContour *manViewBaseCont );
-
- vtkMPRBaseData *GetVtkMPRBaseData();
- void SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata );
- virtual void SetPoint( int id ,int x ,int y ,int z );
-
- virtual void DeleteActualMousePoint(int x, int y);
-
- void AddPoint_Others();
- void DeleteActualMousePoint_Others(int id);
- void MouseMove_Others(int id);
- void InsertPoint_Others(int id);
- void OnChar_Others();
- void ResetContour_Others();
- int GetType();
-
-private:
- int _type;
-
- vtkMPRBaseData *_vtkmprbasedata;
-
- std::vector< manualViewBaseContour* > _lstManualViewBaseContour;
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualContour3DControler: public manualContourControler
-{
-public:
- manualContour3DControler();
- virtual ~manualContour3DControler();
- virtual manualContour3DControler * Clone();
- void CopyAttributesTo( manualContour3DControler *cloneObject );
-
- virtual bool OnLeftButtonDown();
- virtual bool OnChar();
- virtual void InsertPoint(int x, int y, int z);
- virtual void MouseClickLeft(int x, int y);
- void ResetOrientationPlane();
-
- vtkMPRBaseData *GetVtkMPRBaseData();
- void SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata );
-
-
-protected:
-private:
- vtkMPRBaseData *_vtkmprbasedata;
-
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-class creaMaracasVisu_EXPORT manualContour3V3DControler: public manualContour3DControler
-{
-public:
- manualContour3V3DControler();
- virtual ~manualContour3V3DControler();
- virtual manualContour3V3DControler * Clone();
- void CopyAttributesTo( manualContour3V3DControler *cloneObject );
-
- void SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler);
- manualContour3VControler *GetManualContour3VControler();
-
- virtual bool OnChar();
- virtual void AddPoint( int x, int y, int z );
- virtual void DeleteActualMousePoint(int x, int y);
- virtual void MouseMove(int x, int y);
- virtual void InsertPoint(int x, int y, int z);
- virtual void ResetContour();
-
-
-protected:
-private:
- manualContour3VControler *_manualcontour3Vcontroler;
-
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-class creaMaracasVisu_EXPORT manualContourPerpPlaneControler: public manualContourControler
-{
-public:
- manualContourPerpPlaneControler();
- virtual ~manualContourPerpPlaneControler();
- virtual manualContourPerpPlaneControler * Clone();
- void CopyAttributesTo( manualContourPerpPlaneControler *cloneObject );
-
- void SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata);
- vtkMPRBaseData *GetVtkMPRBaseData();
-
- virtual bool OnChar();
- virtual bool OnMouseMove();
- virtual bool OnLeftDClick();
- virtual void AddPoint( int x, int y, int z );
- virtual void DeleteActualMousePoint(int x, int y);
- virtual void MouseMove(int x, int y);
- virtual void InsertPoint(int x, int y, int z);
- virtual void ResetContour();
-
- void SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler);
- manualContour3VControler *GetManualContour3VControler();
-
- virtual void MouseDLeft( int x, int y);
- void ResetOrientationPlane();
- void SetVtkInteractorStylePlane2D(InteractorStyleMaracas *vtkinteractorstyleplane2D);
- InteractorStyleMaracas * GetVtkInteractorStylePlane2D();
-
-private:
- bool _flagMouseMove;
- bool _flagMouseDClick;
- InteractorStyleMaracas *_vtkinteractorstyleplane2D;
-
-protected:
- vtkMPRBaseData *_vtkmprbasedata;
- manualContour3VControler *_manualcontour3Vcontroler;
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-
-class creaMaracasVisu_EXPORT manualRoiControler: public manualContourControler
-{
-public:
- manualRoiControler();
- virtual ~manualRoiControler();
- virtual manualRoiControler * Clone();
- void CopyAttributesTo( manualRoiControler *cloneObject );
-
- virtual void MouseClickLeft(int x, int y);
- virtual void MouseMove(int x, int y );
- virtual void DeleteActualMousePoint(int x, int y);
- void InitRoi(int ww, int hh, double porcentage);
- void SetRoi(int x1, int y1,int x2, int y2);
- virtual void Configure();
-
-
-private:
- int bakIdPoint;
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// EED08
-class creaMaracasVisu_EXPORT manualCircleControler: public manualContourControler
-{
-public:
- manualCircleControler();
- virtual ~manualCircleControler();
- virtual manualCircleControler * Clone();
- void CopyAttributesTo( manualCircleControler *cloneObject );
-
- virtual void MouseClickLeft(int x, int y);
- virtual void MouseMove(int x, int y );
- virtual void DeleteActualMousePoint(int x, int y);
- void InitRoi(int ww, int hh, double porcentage);
-// void SetRoi(int x1, int y1,int x2, int y2);
- virtual void Configure();
-
-
-private:
- int bakIdPoint;
-};
-
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-
-// AD:02-09
-class creaMaracasVisu_EXPORT manualLineControler: public manualContourControler
-{
-public:
- manualLineControler();
- virtual ~manualLineControler();
- virtual manualLineControler * Clone();
- void CopyAttributesTo( manualLineControler *cloneObject );
-
- virtual void MouseClickLeft(int x, int y);
- virtual void MouseMove(int x, int y );
- virtual void DeleteActualMousePoint(int x, int y);
- void InitRoi(int ww, int hh, double porcentage);
-
-
-
-private:
- int bakIdPoint;
-};
-
-
-
-
-#endif // MANUAL_CONTOUR_H
-
git://git.creatis.insa-lyon.fr / creaMaracasVisu.git / commitdiff