3 #include <vtkProperty.h>
5 #include <vtkCellArray.h>
6 #include <vtkRenderer.h>
7 #include <vtkCoordinate.h>
8 #include <vtkTextProperty.h>
9 #include <vtkTextActor.h>
10 #include <vtkProperty2D.h>
11 #include <vtkPointPicker.h>
12 #include "widgets/UtilVtk3DGeometriSelection.h"
15 #include "manualContour.h"
18 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
20 // ----------------------------------------------------------------------------
22 manualPoint::manualPoint(){
24 // ----------------------------------------------------------------------------
25 manualPoint::~manualPoint(){
27 // ----------------------------------------------------------------------------
28 void manualPoint::SetPoint(double x,double y,double z){
33 // ----------------------------------------------------------------------------
34 void manualPoint::SetPointX(double x){
37 // ----------------------------------------------------------------------------
38 void manualPoint::SetPointY(double y){
41 // ----------------------------------------------------------------------------
42 void manualPoint::SetPointZ(double z){
45 // ----------------------------------------------------------------------------
46 double manualPoint::GetX(){
49 // ----------------------------------------------------------------------------
50 double manualPoint::GetY(){
53 // ----------------------------------------------------------------------------
54 double manualPoint::GetZ(){
57 // ----------------------------------------------------------------------------
58 manualPoint * manualPoint :: Clone()
60 manualPoint * clone = new manualPoint();
61 clone->SetPoint( GetX(), GetY(), GetZ());
66 // ----------------------------------------------------------------------------
67 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
70 manualContourModelCircle::manualContourModelCircle()
71 : manualContourModel()
75 manualContourModelCircle::~manualContourModelCircle()
80 // ----------------------------------------------------------------------------
81 manualContourModelCircle * manualContourModelCircle :: Clone() // virtual
83 manualContourModelCircle * clone = new manualContourModelCircle();
84 CopyAttributesTo(clone);
88 // ---------------------------------------------------------------------------
90 void manualContourModelCircle::CopyAttributesTo( manualContourModelCircle * cloneObject)
93 manualContourModel::CopyAttributesTo(cloneObject);
96 //----------------------------------------------------------------
97 int manualContourModelCircle::GetTypeModel() //virtual
102 //----------------------------------------------------------------
103 void manualContourModelCircle::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
105 double angle = _deltaAngle*i;
106 *x = _radio*cos(angle) + _centerX;
107 *y = _radio*sin(angle) + _centerY;
112 // ---------------------------------------------------------------------------
113 void manualContourModelCircle::UpdateSpline() // virtal
115 manualPoint *mpA,*mpB;
117 int np = GetSizeLstPoints( );
118 int nps = GetNumberOfPointsSpline();
119 _deltaAngle=(3.14159265*2)/(nps-1);
122 mpA = GetManualPoint(0);
123 mpB = GetManualPoint(1);
124 difX = mpA->GetX() - mpB->GetX();
125 difY = mpA->GetY() - mpB->GetY();
126 _radio = sqrt( difX*difX + difY*difY );
127 _centerX = mpA->GetX();
128 _centerY = mpA->GetY();
129 _centerZ = mpA->GetZ();
138 // ----------------------------------------------------------------------------
139 // ----------------------------------------------------------------------------
140 // ----------------------------------------------------------------------------
144 manualContourModelLine::manualContourModelLine()
145 : manualContourModel()
147 SetNumberOfPointsSpline(2);
150 manualContourModelLine::~manualContourModelLine()
155 // ----------------------------------------------------------------------------
156 manualContourModelLine * manualContourModelLine :: Clone() // virtual
158 manualContourModelLine * clone = new manualContourModelLine();
159 CopyAttributesTo(clone);
163 // ---------------------------------------------------------------------------
165 void manualContourModelLine::CopyAttributesTo( manualContourModelLine * cloneObject)
167 manualContourModel::CopyAttributesTo(cloneObject);
170 //----------------------------------------------------------------
171 int manualContourModelLine::GetTypeModel() //virtual
176 //----------------------------------------------------------------
177 void manualContourModelLine::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
179 int np = GetSizeLstPoints();
189 mp = GetManualPoint(0);
200 mp = GetManualPoint(0);
204 mp = GetManualPoint(1);
215 int np = GetSizeLstPoints( );
216 int nps = GetNumberOfPointsSpline();
217 // _deltaAngle=(3.14159265*2)/(nps-1);
218 _deltaAngle = 100/nps;
223 mp = GetManualPoint(0);
225 mp = GetManualPoint(1);
242 // ----------------------------------------------------------------------------
243 // ----------------------------------------------------------------------------
244 // ----------------------------------------------------------------------------
245 manualContourModelBullEye::manualContourModelBullEye()
246 : manualContourModel()
248 _numberPointsSlineBySector=101; // impaire
251 manualContourModelBullEye::~manualContourModelBullEye()
256 // ----------------------------------------------------------------------------
257 manualContourModelBullEye * manualContourModelBullEye :: Clone() // virtual
259 manualContourModelBullEye * clone = new manualContourModelBullEye();
260 CopyAttributesTo(clone);
264 // ---------------------------------------------------------------------------
266 void manualContourModelBullEye::CopyAttributesTo( manualContourModelBullEye * cloneObject)
269 manualContourModel::CopyAttributesTo(cloneObject);
272 //----------------------------------------------------------------
273 int manualContourModelBullEye::GetTypeModel() //virtual
278 //----------------------------------------------------------------
279 int manualContourModelBullEye::GetNumberOfPointsSplineSectorBulleEje()
281 return _numberPointsSlineBySector;
284 //----------------------------------------------------------------
285 void manualContourModelBullEye::SetNumberOfPointsSplineSectorBulleEje(int numpoints)
287 this->_numberPointsSlineBySector = numpoints;
290 //----------------------------------------------------------------
291 void manualContourModelBullEye::AddSector( double radioA,
296 manualContourModelBullEyeSector *modelSector = new manualContourModelBullEyeSector();
297 modelSector->SetSector(radioA,radioB,ang,angDelta);
298 modelSector->SetNumberOfPointsSpline( this->GetNumberOfPointsSplineSectorBulleEje() );
299 _lstModelBullEyeSector.push_back(modelSector);
302 //----------------------------------------------------------------
303 manualContourModelBullEyeSector * manualContourModelBullEye::GetModelSector(int id)
305 return _lstModelBullEyeSector[id];
308 //----------------------------------------------------------------
309 void manualContourModelBullEye::GetSector(int id,
315 _lstModelBullEyeSector[id]->GetSector(radioA,radioB,ang,angDelta);
318 void manualContourModelBullEye::UpdateSpline() // virtual
320 manualContourModel::UpdateSpline();
322 if (this->GetSizeLstPoints()>2){
325 manualPoint *mpA = GetManualPoint(0);
326 manualPoint *mpB = GetManualPoint(2);
327 cx = (mpA->GetX() + mpB->GetX()) / 2.0;
328 cy = (mpA->GetY() + mpB->GetY()) / 2.0;
329 ww = fabs( mpA->GetX() - mpB->GetX() )/2.0;
330 hh = fabs( mpA->GetY() - mpB->GetY() )/2.0;
331 int i,size = _lstModelBullEyeSector.size();
334 _lstModelBullEyeSector[i]->SetCenter(cx,cy);
335 _lstModelBullEyeSector[i]->SetSize(ww,hh);
341 //----------------------------------------------------------------
342 void manualContourModelBullEye::ResetSectors()
344 int i,size=_lstModelBullEyeSector.size();
347 delete _lstModelBullEyeSector[i];
349 _lstModelBullEyeSector.clear();
352 //----------------------------------------------------------------
353 int manualContourModelBullEye::GetSizeOfSectorLst()
355 return _lstModelBullEyeSector.size();
358 //----------------------------------------------------------------
359 void manualContourModelBullEye::Save(FILE *ff) // virtual
361 manualContourModel::Save(ff);
362 int i,size = GetSizeOfSectorLst();
363 fprintf(ff,"numberOfSections %d \n",size);
364 for ( i=0 ; i<size ; i++ )
366 _lstModelBullEyeSector[i]->Save(ff);
370 //----------------------------------------------------------------
371 void manualContourModelBullEye::Open(FILE *ff) // virtual
373 manualContourModel::Open(ff);
379 int numberOfSections;
380 // double radioA,radioB,ang,deltaAng;
382 fscanf(ff,"%s",tmp); // NumberOfSections
383 fscanf(ff,"%s",tmp); // ##
384 numberOfSections = atoi(tmp);
385 for (i=0;i<numberOfSections;i++)
388 _lstModelBullEyeSector[i]->Open(ff);
393 // ----------------------------------------------------------------------------
394 std::vector<manualContourModel*> manualContourModelBullEye::ExploseModel( )
397 std::vector<manualContourModel*> lstTmp;
398 int i,iSize=_lstModelBullEyeSector.size();
399 for (i=0;i<iSize;i++)
401 lstTmp.push_back( _lstModelBullEyeSector[i] );
407 // ----------------------------------------------------------------------------
408 // ----------------------------------------------------------------------------
409 // ----------------------------------------------------------------------------
410 manualContourModelBullEyeSector::manualContourModelBullEyeSector()
411 : manualContourModel()
415 manualContourModelBullEyeSector::~manualContourModelBullEyeSector()
420 // ----------------------------------------------------------------------------
421 manualContourModelBullEyeSector * manualContourModelBullEyeSector :: Clone() // virtual
423 manualContourModelBullEyeSector * clone = new manualContourModelBullEyeSector();
424 CopyAttributesTo(clone);
428 // ---------------------------------------------------------------------------
430 void manualContourModelBullEyeSector::CopyAttributesTo( manualContourModelBullEyeSector * cloneObject)
433 manualContourModel::CopyAttributesTo(cloneObject);
436 //----------------------------------------------------------------
437 int manualContourModelBullEyeSector::GetTypeModel() //virtual
443 //----------------------------------------------------------------
444 void manualContourModelBullEyeSector::SetSector( double radioA,
451 _ang = ang*3.14159265/180.0;
452 _angDelta = angDelta*3.14159265/180.0;
455 //----------------------------------------------------------------
456 void manualContourModelBullEyeSector::GetSector(
465 *angDelta = _angDelta;
468 // ----------------------------------------------------------------------------
469 void manualContourModelBullEyeSector::SetCenter(double cx,double cy)
475 //----------------------------------------------------------------
476 void manualContourModelBullEyeSector::SetSize(double ww,double hh)
482 //----------------------------------------------------------------
483 void manualContourModelBullEyeSector::GetSpline_i_Point(int i, double *x, double *y, double *z)
489 double ang,angcos, angsin;
492 nps = GetNumberOfPointsSpline() - 3;
494 if (i==GetNumberOfPointsSpline()-1)
507 ang = ((double)ii/(nps/2))*_angDelta + _ang;
511 *x = _ww*radio*angcos + _cx;
512 *y = _hh*radio*angsin + _cy;
516 //----------------------------------------------------------------
517 void manualContourModelBullEyeSector::Save(FILE *ff) // virtual
519 manualContourModel::Save(ff);
520 fprintf(ff,"rA= %f rB= %f ang= %f deltaAng= %f\n", _radioA,_radioB, _ang , _angDelta);
523 //----------------------------------------------------------------
524 void manualContourModelBullEyeSector::Open(FILE *ff) // virtual
527 fscanf(ff,"%s",tmp); // TypeModel
528 fscanf(ff,"%s",tmp); // ##
530 manualContourModel::Open(ff);
533 fscanf(ff,"%s",tmp); // radioA=
534 fscanf(ff,"%s",tmp); // radioA
537 fscanf(ff,"%s",tmp); // radioB=
538 fscanf(ff,"%s",tmp); // radioB
541 fscanf(ff,"%s",tmp); // ang=
542 fscanf(ff,"%s",tmp); // ang
545 fscanf(ff,"%s",tmp); // deltaAng=
546 fscanf(ff,"%s",tmp); // deltaAng
547 _angDelta = atof(tmp);
552 // ---------------------------------------------------------------------------
553 // ---------------------------------------------------------------------------
554 // ---------------------------------------------------------------------------
555 // ---------------------------------------------------------------------------
557 //JSTG 25-02-08 --------------------------------------------------
558 manualContourModelRoi::manualContourModelRoi()
559 : manualContourModel()
561 SetNumberOfPointsSpline(5);
564 manualContourModelRoi::~manualContourModelRoi()
569 // ----------------------------------------------------------------------------
570 manualContourModelRoi * manualContourModelRoi :: Clone() // virtual
572 manualContourModelRoi * clone = new manualContourModelRoi();
573 CopyAttributesTo(clone);
577 // ---------------------------------------------------------------------------
579 void manualContourModelRoi::CopyAttributesTo( manualContourModelRoi * cloneObject)
582 manualContourModel::CopyAttributesTo(cloneObject);
585 //----------------------------------------------------------------
586 int manualContourModelRoi::GetTypeModel() //virtual
591 //----------------------------------------------------------------
594 // ----------------------------------------------------------------------------
595 // ----------------------------------------------------------------------------
596 // ----------------------------------------------------------------------------
598 manualContourModel::manualContourModel()
600 _cntSplineX = vtkKochanekSpline::New( );
601 _cntSplineY = vtkKochanekSpline::New( );
602 _cntSplineZ = vtkKochanekSpline::New( );
604 this->SetCloseContour(true);
606 _cntSplineX->SetDefaultTension( 0 );
607 _cntSplineX->SetDefaultBias( 0 );
608 _cntSplineX->SetDefaultContinuity( 0 );
610 _cntSplineY->SetDefaultTension( 0 );
611 _cntSplineY->SetDefaultBias( 0 );
612 _cntSplineY->SetDefaultContinuity( 0 );
614 _cntSplineZ->SetDefaultTension( 0 );
615 _cntSplineZ->SetDefaultBias( 0 );
616 _cntSplineZ->SetDefaultContinuity( 0 );
618 //JSTG 25-02-08 -------------------------------------------------------------------------------------------------
620 // this parameter is reset in the VIRTUAL manualContourBaseControler::Configure
621 _sizePointsContour = 100; //JSTG 25-02-08 The change in the inisialization of these variable is critical.
624 //---------------------------------------------------------------------------------------------------------------
627 // ----------------------------------------------------------------------------
628 manualContourModel::~manualContourModel()
630 int i,size=_lstPoints.size();
631 for (i=0;i<size; i++){
632 delete _lstPoints[i];
636 _cntSplineX->Delete();
637 _cntSplineY->Delete();
638 _cntSplineZ->Delete();
640 // ----------------------------------------------------------------------------
641 int manualContourModel::AddPoint(double x,double y,double z)
643 manualPoint *mp = new manualPoint();
648 return _lstPoints.size()-1;
650 // ----------------------------------------------------------------------------
651 int manualContourModel::InsertPoint(double x,double y,double z)
653 double dd,ddmin=9999999;
658 int i,ii,iii,size=_lstPoints.size();
659 double j,MaxDivisions=20,porcentage;
662 if (_closeContour==false)
669 for ( i=0 ; i<size ; i++ )
673 x1=_lstPoints[ii]->GetX();
674 y1=_lstPoints[ii]->GetY();
675 z1=_lstPoints[ii]->GetZ();
676 x2=_lstPoints[iii]->GetX();
677 y2=_lstPoints[iii]->GetY();
678 z2=_lstPoints[iii]->GetZ();
679 for (j=0; j<=MaxDivisions; j++)
681 porcentage=(j/MaxDivisions);
682 xx=(x2-x1)*porcentage+x1;
683 yy=(y2-y1)*porcentage+y1;
684 zz=(z2-z1)*porcentage+z1;
685 dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
695 if (_closeContour==false)
697 if ( (ibak==1) && (jbak==0) )
701 if ( ( ibak==size ) && ( jbak==MaxDivisions ) )
708 //JSTG - 25-04-08 ----------------------------------------------------------
709 //manualPoint *mp = new manualPoint();
710 //mp->SetPoint(x,y,z);
711 //std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + ibak;
712 //_lstPoints.insert(itNum,mp);
713 InsertPoint_id(ibak,x,y,z);
714 //----------------------------------------------------------------------------
718 // ----------------------------------------------------------------------------
719 void manualContourModel::InsertPoint_id(int id, double x, double y, double z)
721 manualPoint *mp = new manualPoint();
723 std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + id;
724 _lstPoints.insert(itNum,mp);
726 // ----------------------------------------------------------------------------
728 void manualContourModel::DeletePoint(int i)
730 std::vector<manualPoint*>::iterator itNum = _lstPoints.begin() + i;
731 _lstPoints.erase(itNum);
733 // ----------------------------------------------------------------------------
734 void manualContourModel::DeleteAllPoints()
736 int i,size=_lstPoints.size();
737 for (i=0;i<size;i++){
738 _lstPoints.erase( _lstPoints.begin() );
740 this->UpdateSpline();
742 // ----------------------------------------------------------------------------
744 void manualContourModel::MovePoint(int i,double dx,double dy,double dz)
746 manualPoint *mp=_lstPoints[i];
747 double x=mp->GetX()+dx;
748 double y=mp->GetY()+dy;
749 double z=mp->GetZ()+dz;
752 // ----------------------------------------------------------------------------
753 void manualContourModel::MoveLstPoints(double dx,double dy,double dz)
757 // ----------------------------------------------------------------------------
758 void manualContourModel::MoveAllPoints(double dx,double dy,double dz)
760 int i,size=_lstPoints.size();
761 for (i=0;i<size;i++){
762 MovePoint(i,dx,dy,dz);
767 // ----------------------------------------------------------------------------
773 int manualContourModel::GetIdPoint(double x, double y, double z, int i_range,int type)
775 double range = i_range+1;
777 double xx,yy,zz,dd,ddmin=9999999;
779 int i,size=_lstPoints.size();
780 for (i=0;i<size;i++){
781 manualPoint *mp=_lstPoints[i];
788 if ((fabs(xx-x)<range) && (fabs(yy-y)<range) && (fabs(zz-z)<range)) {
789 dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) + (zz-z)*(zz-z) );
798 if ((fabs(yy-y)<range) && (fabs(zz-z)<range)) {
799 dd=sqrt( (yy-y)*(yy-y) + (zz-z)*(zz-z) );
808 if ((fabs(xx-x)<range) && (fabs(zz-z)<range)) {
809 dd=sqrt( (xx-x)*(xx-x) + (zz-z)*(zz-z) );
818 if ((fabs(xx-x)<range) && (fabs(yy-y)<range) ) {
819 dd=sqrt( (xx-x)*(xx-x) + (yy-y)*(yy-y) );
829 // ----------------------------------------------------------------------------
830 manualPoint* manualContourModel::GetManualPoint(int id)
832 return _lstPoints[id];
834 // ----------------------------------------------------------------------------
835 int manualContourModel::GetSizeLstPoints()
837 return _lstPoints.size();
839 //----------------------------------------------------------------------------
840 int manualContourModel::GetNumberOfPointsSpline()
842 return _sizePointsContour;
844 //----------------------------------------------------------------------------
845 void manualContourModel::SetNumberOfPointsSpline(int size)
847 _sizePointsContour = size;
851 // ----------------------------------------------------------------------------
853 void manualContourModel::SetCloseContour(bool closeContour)
855 _closeContour = closeContour;
856 if (_closeContour==true)
858 _cntSplineX->ClosedOn();
859 _cntSplineY->ClosedOn();
860 _cntSplineZ->ClosedOn();
862 _cntSplineX->ClosedOff();
863 _cntSplineY->ClosedOff();
864 _cntSplineZ->ClosedOff();
868 // ----------------------------------------------------------------------------
869 bool manualContourModel::IfCloseContour()
871 return _closeContour;
874 // ----------------------------------------------------------------------------
876 void manualContourModel::UpdateSpline() // virtual
879 np = _lstPoints.size();
881 _cntSplineX->RemoveAllPoints();
882 _cntSplineY->RemoveAllPoints();
883 _cntSplineZ->RemoveAllPoints();
884 for( i = 0; i < np; i++ ) {
885 mp = GetManualPoint(i);
886 _cntSplineX->AddPoint( i, mp->GetX() );
887 _cntSplineY->AddPoint( i, mp->GetY() );
888 _cntSplineZ->AddPoint( i, mp->GetZ() );
891 //JSTG 25-02-08 ---------------------------------------------------------------------------------------------
892 if (this->_closeContour==true)
894 _delta_JSTG = (double) (np) / double (_sizePointsContour - 1); //Without the -1 the curve is not close
896 _delta_JSTG = (double) (np-1) / double (_sizePointsContour ); //Without the -1 the curve is not close
898 //-----------------------------------------------------------------------------------------------------------
901 //---------------------------------------------------------------------------------
903 /*void manualContourModel::GetSplineiPoint(int i, double &x, double &y, double &z)
905 double delta=(double)(_lstPoints.size()) / (double)(_sizePointsContour);
906 double t = delta*(double)i;
907 GetSplinePoint(t, x, y, z);
910 //-----------------------------------------------------------------------------
912 //JSTG 25-02-08 ---------------------------------------------------------------
913 void manualContourModel::GetSpline_i_Point(int i, double *x, double *y, double *z) // virtal
915 GetSpline_t_Point(i*_delta_JSTG,x,y,z);
918 // ----------------------------------------------------------------------------
920 //JSTG 25-02-08 ---------------------------------------------------------------
921 void manualContourModel::GetSpline_t_Point(double t, double *x, double *y, double *z)
923 if (_lstPoints.size()==0)
929 if (_lstPoints.size()==1)
932 mp = GetManualPoint(0);
937 if (_lstPoints.size()>=2)
939 *x = _cntSplineX->Evaluate(t);
940 *y = _cntSplineY->Evaluate(t);
941 *z = _cntSplineZ->Evaluate(t);
945 // ----------------------------------------------------------------------------
948 /*void manualContourModel::GetSplinePoint(double t, double &x, double &y, double &z)
950 if (_lstPoints.size()==0)
956 if (_lstPoints.size()==1)
959 mp = GetManualPoint(0);
964 if (_lstPoints.size()>=2)
966 x = _cntSplineX->Evaluate(t);
967 y = _cntSplineY->Evaluate(t);
968 z = _cntSplineZ->Evaluate(t);
971 // ----------------------------------------------------------------------------
972 double manualContourModel::GetPathSize()
978 // JSTG 25-02-08 -----------------------------
982 //--------------------------------------------
984 if (_lstPoints.size()==2)
986 x1=_lstPoints[0]->GetX();
987 y1=_lstPoints[0]->GetY();
988 z1=_lstPoints[0]->GetZ();
989 x2=_lstPoints[1]->GetX();
990 y2=_lstPoints[1]->GetY();
991 z2=_lstPoints[1]->GetZ();
992 result = sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
994 if (_lstPoints.size()>2)
997 // JSTG 25-02-08 ------------------------------------------
998 //np = _lstPoints.size( );
1000 //delta=( double ) ( np ) / ( double ) ( nps );
1002 //GetSplinePoint(0,x1,y1,z1);
1003 GetSpline_i_Point(0,&x1,&y1,&z1);
1005 //for( i = 1; i < nps; i++ )
1006 for( i = 1; i < GetNumberOfPointsSpline(); i++ )
1008 //t = delta * (double)i;
1009 //GetSplinePoint(t,x2,y2,z2);
1010 GetSpline_i_Point(i,&x2,&y2,&z2);
1011 //---------------------------------------------------------
1012 result=result + sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) + (z2-z1)*(z2-z1) );
1021 // ----------------------------------------------------------------------------
1022 double manualContourModel::GetPathArea()
1024 double result = 555;
1025 if ((_lstPoints.size()>=3) && IfCloseContour()==true )
1028 //JSTG 25-02-08 ---------------------------------------------
1030 //-----------------------------------------------------------
1036 // This uses Green's theorem:
1037 // A = 1/2 * sum( xiyi+1 - xi+1yi); pO == pN
1038 // A < 0 -> A = |A| (a negative value could raise because points are
1039 // given in clockwise order).
1041 //JSTG 25-02-08 -------------------------------------------------
1042 //int np = _lstPoints.size( );
1044 int nps = GetNumberOfPointsSpline();
1045 //double delta=( double ) ( np ) / ( double ) ( nps );
1047 for( i = 0, area = 0.0; i < nps; i++ )
1049 j = ( i + 1 ) % nps;
1050 //ti = delta * (double)i;
1051 //tj = delta * (double)j;
1052 //GetSplinePoint(ti,x1,y1,z1);
1053 //GetSplinePoint(tj,x2,y2,z2);
1054 GetSpline_i_Point(i,&x1,&y1,&z1);
1055 GetSpline_i_Point(j,&x2,&y2,&z2);
1056 //----------------------------------------------------------------
1066 area = fabs( area );
1069 for( i = 0, area = 0.0; i < _lstPoints.size(); i++ )
1071 j = ( i + 1 ) % _lstPoints.size();
1074 (_lstPoints[i]->GetX() * _lstPoints[j]->GetY() ) -
1075 ( _lstPoints[j]->GetX() * _lstPoints[i]->GetY() );
1076 if (_lstPoints[0]->GetZ()!=_lstPoints[i]->GetZ())
1082 area = fabs( area );
1098 // ----------------------------------------------------------------------------
1099 // p[x,y,z] : data in
1100 // rp[x,y,z] : data out result point
1101 // rn[x,y,z] : data out result normal
1103 void manualContourModel::GetNearestPointAndNormal(double *p, double *rp, double *rn)
1105 double distMin=999999999;
1106 double dist,dx,dy,dz;
1111 //JSTG 25-02-08 -------------------
1115 //---------------------------------
1117 np = _lstPoints.size( );
1120 // JSTG 25-02-08 ------------------------------------------
1122 nps = GetNumberOfPointsSpline();
1123 //delta = ( double ) ( np ) / ( double ) ( nps );
1125 //GetSplinePoint(0,x1,y1,z1);
1126 GetSpline_i_Point(0,&x1,&y1,&z1);
1127 for( i = 0; i < nps; i++ )
1129 //t = delta * (double)i;
1130 //GetSplinePoint(t,x1,y1,z1);
1131 GetSpline_i_Point(i,&x1,&y1,&z1);
1132 //----------------------------------------------------------
1136 dist = sqrt( dx*dx + dy*dy + dz*dz );
1154 // JSTG 25-02-08 ------------------------------------------
1158 //t = delta * (double)1.0;
1159 //GetSplinePoint(t,x1,y1,z1);
1160 GetSpline_i_Point(i,&x1,&y1,&z1);
1161 //----------------------------------------------------------
1178 // ----------------------------------------------------------------------------
1179 manualContourModel * manualContourModel :: Clone() // virtual
1181 manualContourModel * clone = new manualContourModel();
1182 CopyAttributesTo(clone);
1186 // ----------------------------------------------------------------------------
1187 void manualContourModel::Open(FILE *ff) // virtual
1191 int numberOfControlPoints;
1194 fscanf(ff,"%s",tmp); // NumberOfControlPoints
1195 fscanf(ff,"%s",tmp); // ##
1196 numberOfControlPoints = atoi(tmp);
1197 for (i=0;i<numberOfControlPoints;i++)
1199 fscanf(ff,"%s",tmp); // X
1201 fscanf(ff,"%s",tmp); // Y
1203 fscanf(ff,"%s",tmp); // Z
1210 // ----------------------------------------------------------------------------
1211 int manualContourModel::GetTypeModel() //virtual
1223 // ----------------------------------------------------------------------------
1224 void manualContourModel::Save(FILE *ff) // virtual
1226 int i,size=_lstPoints.size();
1227 fprintf(ff,"TypeModel %d\n", GetTypeModel() );
1228 fprintf(ff,"NumberOfControlPoints %d\n",size);
1229 for (i=0;i<size;i++)
1231 manualPoint *mp=_lstPoints[i];
1232 fprintf(ff,"%f %f %f\n", mp->GetX(), mp->GetY(), mp->GetZ() );
1237 // ---------------------------------------------------------------------------
1239 void manualContourModel::CopyAttributesTo( manualContourModel * cloneObject)
1242 //XXXX::CopyAttributesTo(cloneObject);
1244 cloneObject->SetCloseContour( this->IfCloseContour() );
1245 int i, size = GetSizeLstPoints();
1246 for( i=0; i<size; i++ )
1248 cloneObject->AddManualPoint( GetManualPoint( i )->Clone() );
1250 cloneObject->SetNumberOfPointsSpline( GetNumberOfPointsSpline () );
1251 cloneObject->SetCloseContour( _closeContour );
1252 cloneObject->UpdateSpline();
1256 // ---------------------------------------------------------------------------
1257 void manualContourModel::AddManualPoint( manualPoint* theManualPoint )//private
1259 _lstPoints.push_back( theManualPoint );
1262 std::vector<manualContourModel*> manualContourModel::ExploseModel( )
1264 std::vector<manualContourModel*> lstTmp;
1265 lstTmp.push_back(this);
1270 // ---------------------------------------------------------------------------
1271 // ----------------------------------------------------------------------------
1272 // ----------------------------------------------------------------------------
1274 //int manualViewPoint::range=1;
1277 manualViewPoint::manualViewPoint(wxVtkBaseView *wxvtkbaseview){
1279 _posibleSelected = false;
1282 _pointVtkActor = NULL;
1284 _wxvtkbaseview = wxvtkbaseview;
1292 // ----------------------------------------------------------------------------
1293 manualViewPoint::~manualViewPoint(){
1297 // ----------------------------------------------------------------------------
1298 void manualViewPoint::SetWidthLine( double width)
1303 // ----------------------------------------------------------------------------
1304 void manualViewPoint::SetSelected(bool selected){
1307 // ----------------------------------------------------------------------------
1308 void manualViewPoint::SetPosibleSelected(bool posibleSelected){
1309 _posibleSelected=posibleSelected;
1311 // ----------------------------------------------------------------------------
1312 bool manualViewPoint::GetSelected(){
1315 // ----------------------------------------------------------------------------
1316 bool manualViewPoint::GetPosibleSelected(){
1317 return _posibleSelected;
1319 // ----------------------------------------------------------------------------
1320 void manualViewPoint::DeleteVtkObjects(){
1321 if (_pointVtkActor !=NULL) { _pointVtkActor->Delete(); }
1322 if (_bboxMapper !=NULL) { _bboxMapper ->Delete(); }
1323 if (_pts !=NULL) { _pts ->Delete(); }
1324 if (_pd !=NULL) { _pd ->Delete(); }
1325 _pointVtkActor = NULL;
1333 // ----------------------------------------------------------------------------
1334 vtkActor* manualViewPoint::CreateVtkPointActor()
1338 _pts = vtkPoints::New();
1339 _pts->SetNumberOfPoints(8);
1340 _pts->SetPoint(0, -1000 , -1000 , 0 );
1341 _pts->SetPoint(1, 1000 , -1000 , 0 );
1342 _pts->SetPoint(2, 1000 , 1000 , 0 );
1343 _pts->SetPoint(3, -1000 , 1000 , 0 );
1344 _pts->SetPoint(4, -1000 , 1000 , 0 );
1345 _pts->SetPoint(5, -1000 , 1000 , 0 );
1346 _pts->SetPoint(6, -1000 , 1000 , 0 );
1347 _pts->SetPoint(7, -1000 , 1000 , 0 );
1349 vtkCellArray *lines = vtkCellArray::New();
1350 lines->InsertNextCell(17);
1351 lines->InsertCellPoint(0);
1352 lines->InsertCellPoint(1);
1353 lines->InsertCellPoint(2);
1354 lines->InsertCellPoint(3);
1355 lines->InsertCellPoint(0);
1356 lines->InsertCellPoint(4);
1357 lines->InsertCellPoint(5);
1358 lines->InsertCellPoint(6);
1359 lines->InsertCellPoint(7);
1360 lines->InsertCellPoint(4);
1361 lines->InsertCellPoint(0);
1362 lines->InsertCellPoint(3);
1363 lines->InsertCellPoint(7);
1364 lines->InsertCellPoint(6);
1365 lines->InsertCellPoint(2);
1366 lines->InsertCellPoint(1);
1367 lines->InsertCellPoint(5);
1369 _pd = vtkPolyData::New();
1370 _pd->SetPoints( _pts );
1371 _pd->SetLines( lines );
1372 lines->Delete(); //do not delete lines ??
1374 _pointVtkActor = vtkActor::New();
1375 _bboxMapper = vtkPolyDataMapper::New();
1377 _bboxMapper->SetInput(_pd);
1378 _bboxMapper->ImmediateModeRenderingOn();
1379 _pointVtkActor->SetMapper(_bboxMapper);
1380 _pointVtkActor->GetProperty()->BackfaceCullingOn();
1382 _pd->ComputeBounds();
1384 return _pointVtkActor;
1386 // ----------------------------------------------------------------------------
1387 vtkActor* manualViewPoint::GetVtkActor(){
1388 return _pointVtkActor;
1390 // ----------------------------------------------------------------------------
1391 void manualViewPoint::SetPositionXY(double x, double y,double i_range,double posZ)
1393 // double range=0.2; // i_range;
1394 // double range=(double)manualViewPoint::range;
1396 double range=i_range;
1401 posZ = posZ * _spc[2];
1404 _pts->SetPoint(0, x-range, y+range, posZ-range);
1405 _pts->SetPoint(1, x+range, y+range, posZ-range);
1406 _pts->SetPoint(2, x+range, y-range, posZ-range);
1407 _pts->SetPoint(3, x-range, y-range, posZ-range);
1408 _pts->SetPoint(4, x-range, y+range, posZ+range);
1409 _pts->SetPoint(5, x+range, y+range, posZ+range);
1410 _pts->SetPoint(6, x+range, y-range, posZ+range);
1411 _pts->SetPoint(7, x-range, y-range, posZ+range);
1416 // ----------------------------------------------------------------------------
1417 void manualViewPoint::UpdateColorActor()
1419 if (_pointVtkActor!=NULL){
1421 _pointVtkActor->GetProperty()->SetLineWidth( _widthline );
1422 _pointVtkActor->GetProperty()->SetDiffuseColor(1,0,0);
1423 if (_posibleSelected==true){
1424 _pointVtkActor->GetProperty()->SetDiffuseColor(1,1,0);
1428 // ----------------------------------------------------------------------------
1429 void manualViewPoint::GetSpacing(double spc[3])
1435 // ----------------------------------------------------------------------------
1436 void manualViewPoint::SetSpacing(double spc[3])
1445 // ----------------------------------------------------------------------------
1446 // ----------------------------------------------------------------------------
1447 // ----------------------------------------------------------------------------
1449 manualViewContour::manualViewContour()
1451 _id_viewPoint_for_text = 0;
1453 _initialConoturModel = new manualContourModel();
1455 // ----------------------------------------------------------------------------
1456 manualViewContour::~manualViewContour()
1458 delete _initialConoturModel;
1460 // ----------------------------------------------------------------------------
1462 // ----------------------------------------------------------------------------
1463 manualViewContour * manualViewContour :: Clone()
1465 manualViewContour * clone = new manualViewContour();
1466 CopyAttributesTo(clone);
1470 // ---------------------------------------------------------------------------
1472 void manualViewContour::CopyAttributesTo( manualViewContour * cloneObject)
1474 // Call to Fathers object
1475 manualViewBaseContour::CopyAttributesTo(cloneObject);
1477 cloneObject->SetMesureScale(_mesureScale);
1480 // ---------------------------------------------------------------------------
1482 int manualViewContour::GetType() // virtual
1487 // ----------------------------------------------------------------------------
1489 void manualViewContour::Save(FILE *pFile)
1491 manualViewBaseContour::Save(pFile);
1494 // ----------------------------------------------------------------------------
1496 void manualViewContour::Open(FILE *pFile)
1502 // ----------------------------------------------------------------------------
1503 void manualViewContour::RefreshContour() // virtual
1508 //JSTG 25-02-08 --------------------
1509 //double t,delta, x,y,z;
1511 //----------------------------------
1513 _manContModel->UpdateSpline();
1514 np = GetNumberOfPoints( );
1515 //nps = GetNumberOfPointsSpline();
1516 nps = _manContModel->GetNumberOfPointsSpline();
1517 //delta=( double ) ( np ) / ( double ) ( nps-1 ); //JSTG 25-02-08
1519 //printf ("EED manualViewContour::RefreshContour>> %d %d \n", np,nps);
1525 for( i = 0; i < nps; i++ )
1527 //JSTG 25-02-08 ------------------------------------------------
1528 //t = delta * (double)i;
1529 //_manContModel->GetSplinePoint(t,x,y,z);
1530 _manContModel->GetSpline_i_Point(i,&x,&y,&z);
1531 //--------------------------------------------------------------
1533 // _pts->SetPoint(i, x,y,z );
1534 _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );
1537 // printf ("EED manualViewContour::RefreshContour>> %d : %f %f %f \n", i,x,y,z);
1545 _pts->SetPoint(0, 0 , 0 , 0);
1546 _pts->SetPoint(1, 0 , 0 , 0);
1551 // ----------------------------------------------------------------------------
1552 void manualViewContour::RefreshText() // virtual
1555 if ((_textActor!=NULL) && ( _textActor->GetProperty()->GetOpacity()!=0 )){
1556 int size = GetNumberOfPoints();
1558 char resultText[50];
1559 strcpy(resultText," ");
1562 strcpy(resultText,"L= ");
1563 gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1564 strcat(resultText,text);
1568 if (_manContModel->IfCloseContour()==true)
1570 strcpy(resultText,"P= ");
1571 gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1572 strcat(resultText,text);
1573 gcvt ( _mesureScale * _mesureScale * this->_manContModel->GetPathArea() , 5, text );
1574 strcat(resultText," A= ");
1575 strcat(resultText,text);
1577 strcpy(resultText,"L= ");
1578 gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
1579 strcat(resultText,text);
1583 _textActor -> SetInput(resultText);
1588 for (i=0; i<size; i++)
1590 if (_lstViewPoints[i]->GetPosibleSelected()==true)
1592 _id_viewPoint_for_text = i;
1596 int id = _id_viewPoint_for_text;
1597 double px = _manContModel->GetManualPoint(id)->GetX();
1598 double py = _manContModel->GetManualPoint(id)->GetY();
1604 _textActor->SetPosition(px+GetRange()+1,py);
1610 // ----------------------------------------------------------------------------
1611 bool manualViewContour::ifTouchContour(int x,int y,int z){
1619 TransfromeCoordViewWorld(xx,yy,zz);
1626 unsigned int i, nps,nps_t;
1627 nps = _sizePointsContour;
1628 if (this->_manContModel->IfCloseContour()==true)
1636 printf("\n>%d ",nps_t);
1638 for( i = 0; i < nps_t; i++ )
1640 _pts->GetPoint(i%nps, ppA);
1641 _pts->GetPoint((i+1)%nps, ppB);
1642 d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
1643 d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
1644 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]));
1647 printf("%d %f %f %f - ", i,d1,d2,d3);
1649 if ( ((d1+d2)>=d3) && ((d1+d2)<=d3*1.3) )
1658 // ----------------------------------------------------------------------------
1659 void manualViewContour::DeletePoint(int id) // virtual
1661 if (_lstViewPoints.size()>2)
1663 manualViewBaseContour::DeletePoint( id );
1666 // ----------------------------------------------------------------------------
1668 void manualViewContour::ClearPoint(int id)
1670 manualViewBaseContour::DeletePoint( id );
1673 //-------------------------------------------------------------------
1674 void manualViewContour::SetMesureScale(double mesureScale)
1676 _mesureScale = mesureScale;
1678 //-------------------------------------------------------------------
1679 void manualViewContour::InitMove(int x, int y, int z)
1681 _initialConoturModel->DeleteAllPoints();
1683 manualPoint *mp = NULL;
1687 TransfromeCoordViewWorld(XX,YY,ZZ);
1689 int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1690 for ( i=0; i<manualPointsSZ; i++ )
1692 mp = _manContModel->GetManualPoint( i );
1693 this->_initialConoturModel->AddPoint( mp->GetX() - XX, mp->GetY() - YY, mp->GetZ() );
1696 //-------------------------------------------------------------------
1697 void manualViewContour::MoveContour(int x, int y, int z)
1699 manualPoint *mpOrigin = NULL;
1700 manualPoint *mpMoving = NULL;
1705 TransfromeCoordViewWorld(XX,YY,ZZ);
1707 int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1708 for ( i=0; i<manualPointsSZ; i++ )
1710 mpOrigin = _manContModel->GetManualPoint( i );
1711 mpMoving = _initialConoturModel->GetManualPoint(i);
1712 mpOrigin->SetPoint( mpMoving->GetX()+XX, mpMoving->GetY() + YY, mpMoving->GetZ() );
1716 void manualViewContour::MoveContour(int horizontalUnits, int verticalUnits )
1718 manualPoint *mpOrigin = NULL;
1720 int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
1721 for ( i=0; i<manualPointsSZ; i++ )
1723 mpOrigin = _manContModel->GetManualPoint( i );
1724 mpOrigin->SetPoint( mpOrigin->GetX()+horizontalUnits, mpOrigin->GetY()+verticalUnits, mpOrigin->GetZ() );
1728 // ----------------------------------------------------------------------------
1729 // ----------------------------------------------------------------------------
1730 // ----------------------------------------------------------------------------
1733 manualView3VContour::manualView3VContour(int type)
1736 // JSTG 25-02-08 ------------------------------
1737 //_manContModel= new manualContourModel();
1738 //---------------------------------------------
1740 // ----------------------------------------------------------------------------
1741 manualView3VContour::~manualView3VContour()
1747 // ----------------------------------------------------------------------------
1748 manualView3VContour * manualView3VContour :: Clone()
1750 manualView3VContour * clone = new manualView3VContour( GetType() );
1751 CopyAttributesTo(clone);
1755 // ---------------------------------------------------------------------------
1757 void manualView3VContour::CopyAttributesTo( manualView3VContour * cloneObject)
1760 manualViewContour::CopyAttributesTo(cloneObject);
1763 int manualView3VContour::GetType()
1768 // ----------------------------------------------------------------------------
1769 void manualView3VContour::FilterCordinateXYZ(double &x,double &y,double &z)
1784 // ----------------------------------------------------------------------------
1786 void manualView3VContour::RefreshContour() // virtula
1788 manualViewContour::RefreshContour();
1791 // JSTG 25-02-08 ----------------------------------------
1792 //int nps = GetNumberOfPointsSpline();
1793 int nps = _manContModel->GetNumberOfPointsSpline();
1794 //-------------------------------------------------------
1795 for( i = 0; i < nps; i++ )
1797 _pts->GetPoint( i, pp );
1798 FilterCordinateXYZ(pp[0],pp[1],pp[2]);
1801 _pts->SetPoint( i, pp[0] , pp[1] ,pp[2] );
1806 // ----------------------------------------------------------------------------
1808 void manualView3VContour::UpdateViewPoint(int id){ // virtual
1810 manualPoint *mp = _manContModel->GetManualPoint(id);
1815 FilterCordinateXYZ(x,y,z);
1816 _lstViewPoints[id]->SetPositionXY( x , y ,GetRange(), z );
1819 // ----------------------------------------------------------------------------
1821 int manualView3VContour::GetIdPoint(int x, int y, int z) // virtual
1824 if (_manContModel!=NULL){
1828 TransfromeCoordViewWorld(xx,yy,zz,-1);
1829 ii=_manContModel->GetIdPoint(xx,yy,zz,GetRange(),_type);
1834 // ----------------------------------------------------------------------------
1835 bool manualView3VContour::ifTouchContour(int x,int y,int z){ // virtual
1843 TransfromeCoordViewWorld(xx,yy,zz,-1);
1850 unsigned int i, nps,nps_t;
1851 nps = _sizePointsContour;
1852 if (this->_manContModel->IfCloseContour()==true)
1858 FilterCordinateXYZ(xx,yy,zz);
1860 for( i = 0; i < nps_t; i++ ) {
1861 _pts->GetPoint(i%nps, ppA);
1862 _pts->GetPoint((i+1)%nps, ppB);
1863 FilterCordinateXYZ(ppA[0],ppA[1],ppA[2]);
1864 FilterCordinateXYZ(ppB[0],ppB[1],ppB[2]);
1865 d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
1866 d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
1867 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]));
1868 if ( ((d1+d2)>=d3) && ((d1+d2)<=d3*1.3) ) {
1875 // ----------------------------------------------------------------------------
1876 // ----------------------------------------------------------------------------
1877 // ----------------------------------------------------------------------------
1878 manualView3DContour::manualView3DContour()
1881 // ----------------------------------------------------------------------------
1882 manualView3DContour::~manualView3DContour()
1886 // ----------------------------------------------------------------------------
1887 manualView3DContour * manualView3DContour :: Clone()
1889 manualView3DContour * clone = new manualView3DContour();
1890 CopyAttributesTo(clone);
1894 // ---------------------------------------------------------------------------
1895 void manualView3DContour::CopyAttributesTo( manualView3DContour * cloneObject)
1898 manualViewContour::CopyAttributesTo(cloneObject);
1900 cloneObject->SetDimensions ( _w , _h , _d );
1902 // ----------------------------------------------------------------------------
1903 void manualView3DContour::SetDimensions(int w, int h, int d)
1909 // ----------------------------------------------------------------------------
1910 void manualView3DContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type)
1912 X = _vtkmprbasedata->GetX();
1913 Y = _vtkmprbasedata->GetY();
1914 Z = _vtkmprbasedata->GetZ();
1916 // ----------------------------------------------------------------------------
1917 void manualView3DContour::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
1919 _vtkmprbasedata = vtkmprbasedata;
1921 // ----------------------------------------------------------------------------
1922 int manualView3DContour::GetIdPoint2(int x, int y)
1925 double p[3],pA[3],pB[3];
1927 double pickPoint[ 3 ], cameraPos[ 3 ];
1928 vtkPointPicker* picker = vtkPointPicker::New( );
1929 vtkRenderer *pRenderer = this->GetWxVtkBaseView()->GetRenderer();
1930 picker->Pick( x, y, 0.0, pRenderer );
1931 pRenderer->GetActiveCamera( )->GetPosition( cameraPos );
1932 picker->GetPickPosition( pickPoint );
1935 UtilVtk3DGeometriSelection utilVtk3Dgeometriselection;
1936 utilVtk3Dgeometriselection.SetDimentions(_w,_h,_d);
1938 if( utilVtk3Dgeometriselection.FindCubePointsFromPoints( pA, pB, pickPoint, cameraPos ) )
1940 double dist,distMin=999999999;
1941 int i,size=this->_manContModel->GetSizeLstPoints();
1942 for (i=0;i<size;i++)
1944 manualPoint *mp = this->_manContModel->GetManualPoint(i);
1948 dist=utilVtk3Dgeometriselection.DistanceMinPointToLine(p,pA,pB);
1949 if ( (dist<=2*GetRange()) && (dist<distMin) )
1958 // ----------------------------------------------------------------------------
1959 int manualView3DContour::SelectPosiblePoint ( int x, int y, int z )// virtual
1961 SelectAllPossibleSelected(false);
1962 int id=GetIdPoint2(x,y);
1965 SetPointPosibleSelected(id,true);
1973 // ----------------------------------------------------------------------------
1974 // ----------------------------------------------------------------------------
1975 // ----------------------------------------------------------------------------
1980 // ----------------------------------------------------------------------------
1981 // ----------------------------------------------------------------------------
1982 // ----------------------------------------------------------------------------
1983 manualViewBullEyeSector::manualViewBullEyeSector()
1987 // ----------------------------------------------------------------------------
1988 void manualViewBullEyeSector::RefreshContour()
1993 //----------------------------------
1995 _manContModel->UpdateSpline();
1996 nps = _manContModel->GetNumberOfPointsSpline();
2000 for( i = 0; i < nps; i++ )
2002 _manContModel->GetSpline_i_Point(i,&x,&y,&z);
2003 _pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );
2009 // ----------------------------------------------------------------------------
2010 // ----------------------------------------------------------------------------
2011 // ----------------------------------------------------------------------------
2014 manualViewBullEye::manualViewBullEye()
2018 // ----------------------------------------------------------------------------
2019 manualViewBullEye::~manualViewBullEye()
2022 int i,size=lstSectorBullEye.size();
2023 for (i=0;i<size;i++)
2025 delete lstSectorBullEye[i];
2027 lstSectorBullEye.clear();
2031 // ----------------------------------------------------------------------------
2032 manualViewBullEye * manualViewBullEye :: Clone()
2034 manualViewBullEye * clone = new manualViewBullEye();
2035 CopyAttributesTo(clone);
2039 // ---------------------------------------------------------------------------
2041 void manualViewBullEye::CopyAttributesTo( manualViewBullEye * cloneObject)
2044 manualViewBaseContour::CopyAttributesTo(cloneObject);
2048 // ----------------------------------------------------------------------------
2049 int manualViewBullEye::GetType() // virtual
2055 // ----------------------------------------------------------------------------
2056 void manualViewBullEye::RefreshContour() // virtual
2058 // External Rectangle
2059 manualViewRoi::RefreshContour();
2061 _manContModel->UpdateSpline();
2062 int np = GetNumberOfPoints( );
2063 // Refres sectors of BullEye(s)
2067 int i,size = lstSectorBullEye.size();
2068 for (i=0;i<size;i++)
2070 lstSectorBullEye[i]->RefreshContour();
2077 // ----------------------------------------------------------------------------
2078 void manualViewBullEye::ConstructVTKObjects() // virtual
2080 manualViewRoi::ConstructVTKObjects();
2083 this->GetSpacing(spc);
2084 manualViewBullEyeSector *mvbc;
2085 manualContourModelBullEye *mcmbe = (manualContourModelBullEye*)this->_manContModel;
2086 int i,size = mcmbe->GetSizeOfSectorLst();
2087 for ( i=0 ; i<size ; i++ )
2089 mvbc = new manualViewBullEyeSector();
2090 mvbc->SetModel( mcmbe->GetModelSector(i) );
2091 mvbc->SetWxVtkBaseView( this->GetWxVtkBaseView() );
2092 mvbc->SetRange( 2 );
2094 mvbc->SetSpacing(spc);
2095 mvbc->SetColorNormalContour(1, 0, 0);
2096 // mvbc->SetColorEditContour(0.5, 0.5, 0.5);
2097 // mvbc->SetColorSelectContour(1, 0.8, 0);
2098 mvbc->SetWidthLine( this->GetWidthLine() );
2100 mvbc->ConstructVTKObjects();
2101 lstSectorBullEye.push_back( mvbc );
2107 // ----------------------------------------------------------------------------
2108 void manualViewBullEye::AddSplineActor() // virtual
2110 manualViewRoi::AddSplineActor();
2111 int i,size=lstSectorBullEye.size();
2112 for (i=0;i<size;i++)
2114 lstSectorBullEye[i]->AddSplineActor();
2118 // ----------------------------------------------------------------------------
2119 void manualViewBullEye::RemoveSplineActor() // virtual
2121 manualViewRoi::RemoveSplineActor();
2122 int i,size=lstSectorBullEye.size();
2123 for (i=0;i<size;i++)
2125 lstSectorBullEye[i]->RemoveSplineActor();
2130 // ----------------------------------------------------------------------------
2131 // ----------------------------------------------------------------------------
2132 // ----------------------------------------------------------------------------
2134 manualViewRoi::manualViewRoi()
2136 _sizePointsContour=5;
2138 // ----------------------------------------------------------------------------
2139 manualViewRoi::~manualViewRoi()
2144 // ----------------------------------------------------------------------------
2145 manualViewRoi * manualViewRoi :: Clone()
2147 manualViewRoi * clone = new manualViewRoi();
2148 CopyAttributesTo(clone);
2152 // ---------------------------------------------------------------------------
2154 void manualViewRoi::CopyAttributesTo( manualViewRoi * cloneObject)
2157 manualViewBaseContour::CopyAttributesTo(cloneObject);
2160 // ----------------------------------------------------------------------------
2161 void manualViewRoi::RefreshContour() // virtual
2163 unsigned int i,ii, np;
2164 np = GetNumberOfPoints( );
2170 for( i = 0; i < np+1; i++ ) {
2172 mp = _manContModel->GetManualPoint(ii);
2175 double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2176 // wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2177 // wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2180 // _pts->SetPoint(i, XX,YY,ZZ );
2181 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2185 _pts->SetPoint(0, 0 , 0 , 0);
2186 _pts->SetPoint(1, 0 , 0 , 0);
2191 // ----------------------------------------------------------------------------
2192 int manualViewRoi::GetType() // virtual
2197 // ----------------------------------------------------------------------------
2199 void manualViewRoi::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2210 unsigned int size=(unsigned int) _manContModel->GetSizeLstPoints();
2212 for( i = 0; i < size; i++ )
2215 mp=_manContModel->GetManualPoint(i);
2250 // ----------------------------------------------------------------------------
2252 bool manualViewRoi::ifTouchContour(int x,int y, int z) // virtual
2255 double px1=99999,py1=99999,px2=-9999,py2=-99999;
2257 GetMinMax(px1,py1, px2, py2);
2262 TransfromeCoordViewWorld(xx,yy,zz);
2266 double ddx=GetRange();
2267 double ddy=GetRange();
2269 if ((xx>px1-ddx)&&(xx<px2+ddx) && (yy>py1-ddy)&&(yy<py2+ddy))
2274 if ((xx>px1+ddx)&&(xx<px2-ddx) && (yy>py1+ddy)&&(yy<py2-ddy))
2279 if ((ok1==true) && (ok2==false))
2288 // ----------------------------------------------------------------------------
2290 void manualViewRoi::InitMove(int x, int y, int z) // virtual
2296 TransfromeCoordViewWorld(XX,YY,ZZ);
2298 if (_manContModel->GetSizeLstPoints()==4){
2299 mp = _manContModel->GetManualPoint(0);
2300 _dp0[0]= mp->GetX() - XX;
2301 _dp0[1]= mp->GetY() - YY;
2302 _dp0[2]= mp->GetZ();
2304 mp = _manContModel->GetManualPoint(1);
2305 _dp1[0]= mp->GetX() - XX;
2306 _dp1[1]= mp->GetY() - YY;
2307 _dp1[2]= mp->GetZ();
2309 mp = _manContModel->GetManualPoint(2);
2310 _dp2[0]= mp->GetX() - XX;
2311 _dp2[1]= mp->GetY() - YY;
2312 _dp2[2]= mp->GetZ();
2314 mp = _manContModel->GetManualPoint(3);
2315 _dp3[0]= mp->GetX() - XX;
2316 _dp3[1]= mp->GetY() - YY;
2317 _dp3[2]= mp->GetZ();
2321 // ----------------------------------------------------------------------------
2323 void manualViewRoi::MoveContour(int x, int y, int z) // virtual
2329 TransfromeCoordViewWorld(XX,YY,ZZ);
2331 mp = _manContModel->GetManualPoint(0);
2332 mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2334 mp = _manContModel->GetManualPoint(1);
2335 mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2337 mp = _manContModel->GetManualPoint(2);
2338 mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2340 mp = _manContModel->GetManualPoint(3);
2341 mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2352 // ----------------------------------------------------------------------------
2353 // ----------------------------------------------------------------------------
2354 // ----------------------------------------------------------------------------
2358 manualViewCircle::manualViewCircle()
2360 // _sizePointsContour=5; // default 100
2362 // ----------------------------------------------------------------------------
2363 manualViewCircle::~manualViewCircle()
2368 // ----------------------------------------------------------------------------
2369 manualViewCircle * manualViewCircle :: Clone()
2371 manualViewCircle * clone = new manualViewCircle();
2372 CopyAttributesTo(clone);
2376 // ---------------------------------------------------------------------------
2378 void manualViewCircle::CopyAttributesTo( manualViewCircle * cloneObject)
2381 manualViewBaseContour::CopyAttributesTo(cloneObject);
2385 // ----------------------------------------------------------------------------
2387 void manualViewCircle::RefreshContour(){ // virtual
2389 manualPoint *mpA,*mpB;
2390 unsigned int i, np,nps;
2394 np = GetNumberOfPoints( );
2395 nps = _manContModel->GetNumberOfPointsSpline();
2396 double deltaAngle=(3.14159265*2)/(nps-1);
2401 mpA = _manContModel->GetManualPoint(0);
2402 mpB = _manContModel->GetManualPoint(1);
2403 difX = mpA->GetX() - mpB->GetX();
2404 difY = mpA->GetY() - mpB->GetY();
2405 radio = sqrt( difX*difX + difY*difY );
2406 manualContourModelCircle *manContModelCir = (manualContourModelCircle*)_manContModel;
2407 manContModelCir->SetRadio(radio);
2409 for( i = 0; i < nps; i++ ) {
2410 manContModelCir->GetSpline_i_Point(i, &XX, &YY, &ZZ);
2411 // angle = deltaAngle*i;
2412 // XX = cos(angle)*radio+mpA->GetX();
2413 // YY = sin(angle)*radio+mpA->GetY();
2415 _pts->SetPoint(i, XX*_spc[0] , YY*_spc[1] , ZZ*_spc[2] );
2418 _pts->SetPoint(0, 0 , 0 , 0);
2419 _pts->SetPoint(1, 0 , 0 , 0);
2425 // ----------------------------------------------------------------------------
2426 int manualViewCircle::GetType() // virtual
2431 // ----------------------------------------------------------------------------
2433 void manualViewCircle::GetMinMax(double &minX,double &minY, double &maxX, double &maxY)
2435 manualPoint *mpA,*mpB;
2439 np = GetNumberOfPoints( );
2442 mpA = _manContModel->GetManualPoint(0);
2443 mpB = _manContModel->GetManualPoint(1);
2444 difX = mpA->GetX() - mpB->GetX();
2445 difY = mpA->GetY() - mpB->GetY();
2446 radio = sqrt( difX*difX + difY*difY );
2447 minX=mpA->GetX()-radio;
2448 minY=mpA->GetY()-radio;
2449 maxX=mpA->GetX()+radio;
2450 maxY=mpA->GetY()+radio;
2460 // ----------------------------------------------------------------------------
2461 bool manualViewCircle::ifTouchContour(int x,int y, int z) // virtual
2464 double px1=99999,py1=99999,px2=-9999,py2=-99999;
2466 GetMinMax(px1,py1, px2, py2);
2471 TransfromeCoordViewWorld(xx,yy,zz);
2475 double ddx=GetRange();
2476 double ddy=GetRange();
2478 if ((xx>px1-ddx)&&(xx<px2+ddx) && (yy>py1-ddy)&&(yy<py2+ddy))
2483 if ((xx>px1+ddx)&&(xx<px2-ddx) && (yy>py1+ddy)&&(yy<py2-ddy))
2488 if ((ok1==true) && (ok2==false))
2497 // ----------------------------------------------------------------------------
2499 void manualViewCircle::InitMove(int x, int y, int z) // virtual
2505 TransfromeCoordViewWorld(XX,YY,ZZ);
2507 if (_manContModel->GetSizeLstPoints()==2){
2508 mp = _manContModel->GetManualPoint(0);
2509 _dp0[0]= mp->GetX() - XX;
2510 _dp0[1]= mp->GetY() - YY;
2511 _dp0[2]= mp->GetZ();
2513 mp = _manContModel->GetManualPoint(1);
2514 _dp1[0]= mp->GetX() - XX;
2515 _dp1[1]= mp->GetY() - YY;
2516 _dp1[2]= mp->GetZ();
2518 mp = _manContModel->GetManualPoint(2);
2519 _dp2[0]= mp->GetX() - XX;
2520 _dp2[1]= mp->GetY() - YY;
2521 _dp2[2]= mp->GetZ();
2523 mp = _manContModel->GetManualPoint(3);
2524 _dp3[0]= mp->GetX() - XX;
2525 _dp3[1]= mp->GetY() - YY;
2526 _dp3[2]= mp->GetZ();
2532 // ----------------------------------------------------------------------------
2533 void manualViewCircle::MoveContour(int x, int y, int z) // virtual
2539 TransfromeCoordViewWorld(XX,YY,ZZ);
2541 mp = _manContModel->GetManualPoint(0);
2542 mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2544 mp = _manContModel->GetManualPoint(1);
2545 mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2547 // mp = _manContModel->GetManualPoint(2);
2548 // mp->SetPoint(_dp2[0]+XX,_dp2[1]+YY,_dp0[2]);
2550 // mp = _manContModel->GetManualPoint(3);
2551 // mp->SetPoint(_dp3[0]+XX,_dp3[1]+YY,_dp0[2]);
2555 // UpdateViewPoint(2);
2556 // UpdateViewPoint(3);
2562 // ----------------------------------------------------------------------------
2563 // ----------------------------------------------------------------------------
2564 // ----------------------------------------------------------------------------
2568 manualViewLine::manualViewLine()
2571 // ----------------------------------------------------------------------------
2572 manualViewLine::~manualViewLine()
2577 // ----------------------------------------------------------------------------
2578 manualViewLine * manualViewLine :: Clone()
2580 manualViewLine * clone = new manualViewLine();
2581 CopyAttributesTo(clone);
2585 // ---------------------------------------------------------------------------
2587 void manualViewLine::CopyAttributesTo( manualViewLine * cloneObject)
2590 manualViewBaseContour::CopyAttributesTo(cloneObject);
2593 // ----------------------------------------------------------------------------
2594 int manualViewLine::GetType() // virtual
2600 // ----------------------------------------------------------------------------
2602 void manualViewLine::InitMove(int x, int y, int z) // virtual
2608 TransfromeCoordViewWorld(XX,YY,ZZ);
2610 if (_manContModel->GetSizeLstPoints()==2)
2612 mp = _manContModel->GetManualPoint(0);
2613 _dp0[0]= mp->GetX() - XX;
2614 _dp0[1]= mp->GetY() - YY;
2615 _dp0[2]= mp->GetZ();
2617 mp = _manContModel->GetManualPoint(1);
2618 _dp1[0]= mp->GetX() - XX;
2619 _dp1[1]= mp->GetY() - YY;
2620 _dp1[2]= mp->GetZ();
2626 // ----------------------------------------------------------------------------
2627 void manualViewLine::MoveContour(int x, int y, int z) // virtual
2633 TransfromeCoordViewWorld(XX,YY,ZZ);
2635 mp = _manContModel->GetManualPoint(0);
2636 mp->SetPoint(_dp0[0]+XX,_dp0[1]+YY,_dp0[2]);
2638 mp = _manContModel->GetManualPoint(1);
2639 mp->SetPoint(_dp1[0]+XX,_dp1[1]+YY,_dp0[2]);
2647 // ----------------------------------------------------------------------------
2648 // ----------------------------------------------------------------------------
2649 // ----------------------------------------------------------------------------
2652 manualViewBaseContour::manualViewBaseContour()
2656 _manContModel = NULL;
2657 _wxvtkbaseview = NULL;
2659 _posibleSelected = false;
2660 _viewControlPoints = false;
2663 _contourVtkActor = NULL;
2666 _sizePointsContour = 100;
2675 _coulorNormal_r = 1;
2676 _coulorNormal_g = 0;
2677 _coulorNormal_b = 1;
2679 _coulorSelection_r = 0;
2680 _coulorSelection_g = 1;
2681 _coulorSelection_b = 0;
2686 // ----------------------------------------------------------------------------
2687 manualViewBaseContour::~manualViewBaseContour()
2689 int i,size=_lstViewPoints.size();
2690 for (i=0;i<size; i++){
2691 delete _lstViewPoints[i];
2693 _lstViewPoints.clear();
2695 // ----------------------------------------------------------------------------
2698 int manualViewBaseContour::GetType() // virtual
2701 //int manualViewBaseContour::GetType() 0;
2702 //int manualViewContour::GetType() 1;
2703 //int manualViewRoi::GetType() 2;
2704 //int manualViewCircle::GetType() 3;
2705 //int manualViewStar::GetType() 4;
2706 //int manualViewLine::GetType() 6;
2711 // ----------------------------------------------------------------------------
2713 void manualViewBaseContour::Save(FILE *pFile)
2715 fprintf(pFile,"TypeView %d\n", GetType() );
2718 // ----------------------------------------------------------------------------
2719 void manualViewBaseContour::Open(FILE *pFile)
2723 // ----------------------------------------------------------------------------
2724 void manualViewBaseContour :: AddCompleteContourActor( bool ifControlPoints )
2726 _viewControlPoints = ifControlPoints;
2727 /*vtkRenderer * theRenderer = */ _wxvtkbaseview->GetRenderer(); // JPRx ??
2732 //Adding each control point
2733 if( ifControlPoints )
2738 // ---------------------------------------------------------------------------
2740 void manualViewBaseContour :: RemoveCompleteContourActor()
2742 /*vtkRenderer * theRenderer =*/ _wxvtkbaseview->GetRenderer(); // JPRx ??
2743 //Removing the spline
2744 RemoveSplineActor();
2747 //Removing each point
2748 RemoveControlPoints();
2752 // ---------------------------------------------------------------------------
2753 manualViewBaseContour * manualViewBaseContour :: Clone( )//virtual
2755 manualViewBaseContour * clone = new manualViewBaseContour();
2756 CopyAttributesTo(clone);
2761 // ---------------------------------------------------------------------------
2763 void manualViewBaseContour::CopyAttributesTo( manualViewBaseContour * cloneObject)
2766 //XXXX::CopyAttributesTo(cloneObject);
2768 cloneObject-> SetWxVtkBaseView( this->_wxvtkbaseview );
2769 cloneObject-> SetSelected( this->GetSelected() );
2770 cloneObject-> SetPosibleSelected( this->GetPosibleSelected() );
2771 cloneObject-> SetIfViewControlPoints( this->GetIfViewControlPoints() );
2772 cloneObject-> SetRange( this->GetRange() );
2773 cloneObject-> SetZ( this->GetZ() );
2774 cloneObject-> SetSpacing( _spc );
2775 cloneObject-> SetColorNormalContour( _coulorNormal_r, _coulorNormal_g, _coulorNormal_b );
2776 cloneObject-> SetColorEditContour( _coulorEdit_r, _coulorEdit_g, _coulorEdit_b );
2777 cloneObject-> SetColorSelectContour( _coulorSelection_r, _coulorSelection_g, _coulorSelection_b );
2779 int i, size = _lstViewPoints.size();
2780 for ( i=0; i<size; i++ )
2782 cloneObject->AddPoint( );
2786 // ----------------------------------------------------------------------------
2787 void manualViewBaseContour :: AddSplineActor()
2789 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2790 if (_contourVtkActor!=NULL)
2791 theRenderer->AddActor( _contourVtkActor );
2793 // ----------------------------------------------------------------------------
2794 void manualViewBaseContour :: RemoveSplineActor() // virtual
2796 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2797 if (_contourVtkActor!=NULL)
2798 theRenderer->RemoveActor( _contourVtkActor );
2800 // ----------------------------------------------------------------------------
2801 void manualViewBaseContour :: RemoveControlPoints()
2803 if (_wxvtkbaseview!=NULL){
2804 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2805 int i,size=_lstViewPoints.size();
2806 for (i=0;i<size; i++)
2808 vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2809 theRenderer->RemoveActor( pointActor );
2812 SetIfViewControlPoints( false );
2814 // ----------------------------------------------------------------------------
2815 void manualViewBaseContour :: AddControlPoints()
2817 vtkRenderer * theRenderer = _wxvtkbaseview->GetRenderer();
2818 SetIfViewControlPoints( true );
2819 if( _viewControlPoints )
2821 int i,size=_lstViewPoints.size();
2822 for (i=0;i<size; i++)
2824 vtkActor * pointActor = _lstViewPoints[i]->GetVtkActor();
2825 theRenderer->AddActor( pointActor );
2829 // ----------------------------------------------------------------------------
2830 void manualViewBaseContour::AddTextActor()
2832 _wxvtkbaseview->GetRenderer()->AddActor2D( _textActor );
2834 // ----------------------------------------------------------------------------
2835 void manualViewBaseContour::RemoveTextActor()
2837 _wxvtkbaseview->GetRenderer()->RemoveActor2D( _textActor );
2839 // ----------------------------------------------------------------------------
2840 void manualViewBaseContour::DeleteVtkObjects()
2842 if ( _contourVtkActor != NULL ) { _contourVtkActor -> Delete(); }
2843 if ( _bboxMapper != NULL ) { _bboxMapper -> Delete(); }
2844 if ( _pts != NULL ) { _pts -> Delete(); }
2845 if ( _pd != NULL ) { _pd -> Delete(); }
2846 _contourVtkActor = NULL;
2853 // ----------------------------------------------------------------------------
2854 void manualViewBaseContour::SetWidthLine(double width)
2857 this->UpdateColorActor();
2859 // for the control points
2860 int id, size = _lstViewPoints.size();
2861 for( id=0; id<size; id++)
2863 this->_lstViewPoints[id]->SetWidthLine(_widthline);
2868 // ----------------------------------------------------------------------------
2869 double manualViewBaseContour::GetWidthLine()
2874 // ----------------------------------------------------------------------------
2875 void manualViewBaseContour::ConstructVTKObjects()
2877 //JSTG 29-02-08 -----------------------------------------------
2878 //int i , nps = _sizePointsContour;
2880 int nps = _manContModel->GetNumberOfPointsSpline();
2881 //-------------------------------------------------------------
2883 _pts = vtkPoints::New();
2884 _pts->SetNumberOfPoints(nps);
2886 for (i=0 ; i<nps ; i++){
2887 _pts->SetPoint(i, 0 , 0 , 0 );
2889 // This is for the boundaring inicialisation
2890 _pts->SetPoint(0, -1000 , -1000 , -1000 );
2891 _pts->SetPoint(1, 1000 , 1000 , 1000 );
2893 vtkCellArray *lines = vtkCellArray::New();
2894 lines->InsertNextCell( nps /* +1 */ );
2895 for ( i=0 ; i<nps+1 ; i++ ){
2896 lines->InsertCellPoint(i % nps );
2899 _pd = vtkPolyData::New();
2900 _pd->SetPoints( _pts );
2901 _pd->SetLines( lines );
2902 lines->Delete(); //do not delete lines ??
2904 _contourVtkActor = vtkActor::New();
2905 _bboxMapper = vtkPolyDataMapper::New();
2906 _bboxMapper->ScalarVisibilityOff( );
2908 _bboxMapper->SetInput(_pd);
2909 _bboxMapper->ImmediateModeRenderingOn();
2910 _contourVtkActor->SetMapper(_bboxMapper);
2911 _contourVtkActor->GetProperty()->BackfaceCullingOff();
2915 _pd->ComputeBounds();
2918 _textActor = vtkTextActor::New();
2919 // _textActor->SetDisplayPosition(200, 200);
2920 _textActor->SetInput("");
2921 // Set coordinates to match the old vtkScaledTextActor default value
2922 // _textActor->GetPosition2Coordinate()->SetCoordinateSystemToNormalizedViewport();
2923 // _textActor->GetPosition2Coordinate()->SetValue( 0.2 , 0.2 );
2924 _textActor->GetPositionCoordinate()->SetCoordinateSystemToWorld ();
2925 // _textActor->GetPositionCoordinate()->SetValue( 0.8 , 0.8 );
2927 vtkTextProperty *tprop = _textActor->GetTextProperty();
2928 tprop->SetFontSize(14);
2929 tprop->SetFontFamilyToArial();
2930 tprop->SetColor(0, 0, 1);
2932 // ----------------------------------------------------------------------------
2933 void manualViewBaseContour::CreateNewContour()
2935 ConstructVTKObjects();
2937 _wxvtkbaseview->GetRenderer()->AddActor( _contourVtkActor );
2938 _wxvtkbaseview->GetRenderer()->AddActor2D(_textActor);*/
2939 AddCompleteContourActor();
2941 // ----------------------------------------------------------------------------
2942 void manualViewBaseContour::UpdateViewPoint(int id) // virtual
2944 manualPoint *mp = _manContModel->GetManualPoint(id);
2947 double XX=mp->GetX(),YY=mp->GetY(),ZZ=mp->GetZ();
2948 // wxVtk2DBaseView *wxvtk2Dbasevie = (wxVtk2DBaseView*)this->GetWxVtkBaseView();
2949 // wxvtk2Dbasevie->TransformCoordinate_spacing_ModelToView(XX,YY,ZZ);
2951 _lstViewPoints[id]->SetPositionXY( XX , YY ,_range, ZZ );
2954 // ----------------------------------------------------------------------------
2955 void manualViewBaseContour :: UpdateViewPoints()
2957 int id, size = _lstViewPoints.size();
2958 for( id=0; id<size; id++)
2960 UpdateViewPoint( id );
2964 // ----------------------------------------------------------------------------
2965 void manualViewBaseContour::AddPoint()
2967 manualViewPoint *mvp = new manualViewPoint( this->GetWxVtkBaseView() );
2970 // ----------------------------------------------------------------------------
2971 void manualViewBaseContour::AddPoint( manualViewPoint * manualViewPoint )
2973 _lstViewPoints.push_back( manualViewPoint );
2976 manualViewPoint->SetSpacing(_spc);
2978 vtkActor *actor = manualViewPoint->CreateVtkPointActor();
2979 _wxvtkbaseview->GetRenderer()->AddActor( actor );
2982 // ----------------------------------------------------------------------------
2983 void manualViewBaseContour::InsertPoint(int id)
2985 manualViewPoint *mvp = new manualViewPoint( this->GetWxVtkBaseView() );
2988 mvp->SetSpacing(_spc);
2990 std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
2991 _lstViewPoints.insert(itNum,mvp);
2992 _wxvtkbaseview->GetRenderer()->AddActor( mvp->CreateVtkPointActor() );
2994 // ----------------------------------------------------------------------------
2995 void manualViewBaseContour::DeleteContour()
2997 RemoveCompleteContourActor();
2998 /*if (_contourVtkActor!=NULL){
2999 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3002 int i,size=_lstViewPoints.size();
3003 for (i=0;i<size;i++){
3004 manualViewBaseContour::DeletePoint(0);
3008 // ----------------------------------------------------------------------------
3009 void manualViewBaseContour::DeletePoint(int id) // virtual
3011 int size=_lstViewPoints.size();
3012 if ( (id>=0) && (id<size) ){
3013 manualViewPoint *mvp =_lstViewPoints[id];
3015 // _handlePicker->DeletePickList(mvp->GetVtkActor());
3016 _wxvtkbaseview->GetRenderer()->RemoveActor( mvp->GetVtkActor() );
3017 std::vector<manualViewPoint*>::iterator itNum = _lstViewPoints.begin() + id;
3018 _lstViewPoints.erase(itNum);
3023 // ----------------------------------------------------------------------------
3024 void manualViewBaseContour::DeletePoint(int x, int y, int z)
3026 int id=GetIdPoint(x,y,z);
3031 // ----------------------------------------------------------------------------
3032 void manualViewBaseContour::SetSelected(bool selected)
3036 // ----------------------------------------------------------------------------
3037 void manualViewBaseContour::SetPosibleSelected(bool posibleSelected)
3039 _posibleSelected=posibleSelected;
3041 // ----------------------------------------------------------------------------
3042 bool manualViewBaseContour::GetEditable()
3046 // ----------------------------------------------------------------------------
3047 void manualViewBaseContour::SetEditable( bool * condition )
3049 _editable = condition;
3051 // ----------------------------------------------------------------------------
3052 bool manualViewBaseContour::GetSelected()
3056 // ----------------------------------------------------------------------------
3057 bool manualViewBaseContour::GetPosibleSelected()
3059 return _posibleSelected;
3061 // ----------------------------------------------------------------------------
3062 void manualViewBaseContour::DeleteSelectedPoints()
3064 int i,size=_lstViewPoints.size();
3065 for (i=size-1;i>=0;i--){
3066 if (_lstViewPoints[i]->GetSelected()==true){
3072 // ----------------------------------------------------------------------------
3073 void manualViewBaseContour::SelectPoint(int i, bool select)
3075 _lstViewPoints[i]->SetSelected(select);
3077 // ----------------------------------------------------------------------------
3078 void manualViewBaseContour::SelectLstPoints()
3082 // ----------------------------------------------------------------------------
3083 void manualViewBaseContour::SelectAllPoints(bool select)
3085 int i,size=_lstViewPoints.size();
3086 for (i=0;i<size;i++){
3087 SelectPoint(i,select);
3090 //-----------------------------------------------------------------------------
3091 void manualViewBaseContour:: SetIfViewControlPoints(bool ifShow)
3093 _viewControlPoints = ifShow;
3095 // ----------------------------------------------------------------------------
3096 bool manualViewBaseContour:: GetIfViewControlPoints()
3098 return _viewControlPoints;
3101 // ----------------------------------------------------------------------------
3102 void manualViewBaseContour::SetPointPosibleSelected(int id,bool select)
3104 _lstViewPoints[id]->SetPosibleSelected(select);
3106 // ----------------------------------------------------------------------------
3107 void manualViewBaseContour::SetPointSelected(int id,bool select)
3109 _lstViewPoints[id]->SetSelected(select);
3111 // ----------------------------------------------------------------------------
3112 void manualViewBaseContour::SelectAllPossibleSelected(bool select)
3114 int i,size=_lstViewPoints.size();
3115 for (i=0;i<size;i++){
3116 SetPointPosibleSelected(i,select);
3119 // ----------------------------------------------------------------------------
3120 int manualViewBaseContour::SelectPosiblePoint(int x, int y, int z) // virtual
3122 SelectAllPossibleSelected(false);
3124 int id = GetIdPoint(x,y,z);
3127 SetPointPosibleSelected(id,true);
3131 // ----------------------------------------------------------------------------
3132 bool manualViewBaseContour::SelectPosibleContour(int x, int y, int z)
3135 SetPosibleSelected(result);
3136 int id = GetIdPoint(x,y,z);
3137 if( !GetEditable() && !_selected && id!= -1)
3140 SetPosibleSelected(result);
3144 if ( (GetEditable()==true) && (id==-1 ) && (this->_lstViewPoints.size()>=2) )
3146 if (ifTouchContour(x,y,z)==true)
3149 SetPosibleSelected(result);
3153 if (GetEditable()==false)
3155 if (ifTouchContour(x,y,z)==true)
3158 SetPosibleSelected(result);
3166 // ----------------------------------------------------------------------------
3167 bool manualViewBaseContour::ifTouchContour(int x,int y, int z) // virtual
3171 // ----------------------------------------------------------------------------
3172 void manualViewBaseContour::UnSelectPoint(int i){
3173 _lstViewPoints[i]->SetSelected(false);
3176 // ----------------------------------------------------------------------------
3177 void manualViewBaseContour::UnSelectLstPoints(){
3180 // ----------------------------------------------------------------------------
3181 void manualViewBaseContour::UnSelectAllPoints(){
3182 int i,size=_lstViewPoints.size();
3183 for (i=0;i<size;i++){
3188 // ----------------------------------------------------------------------------
3189 void manualViewBaseContour::SetModel(manualContourModel *manContModel){
3190 _manContModel=manContModel;
3192 // ----------------------------------------------------------------------------
3193 void manualViewBaseContour::SetWxVtkBaseView(wxVtkBaseView *wxvtkbaseview){
3194 _wxvtkbaseview = wxvtkbaseview;
3196 // ----------------------------------------------------------------------------
3197 void manualViewBaseContour::RefreshContour() // Virtual
3200 // ----------------------------------------------------------------------------
3201 double* manualViewBaseContour::GetVectorPointsXManualContour(){
3203 int i,size = _sizePointsContour;
3204 double *vx = (double*)malloc(sizeof(double)*size);
3205 for (i=0;i<size;i++){
3206 _pts->GetPoint(i,pp);
3211 // ----------------------------------------------------------------------------
3212 double* manualViewBaseContour::GetVectorPointsYManualContour()
3215 int i,size = _sizePointsContour;
3216 double *vy = (double*)malloc(sizeof(double)*size);
3217 for (i=0;i<size;i++){
3218 _pts->GetPoint(i,pp);
3223 // ----------------------------------------------------------------------------
3224 double* manualViewBaseContour::GetVectorPointsZManualContour()
3227 int i,size = _sizePointsContour;
3228 double *vz = (double*)malloc(sizeof(double)*size);
3229 for (i=0;i<size;i++){
3230 _pts->GetPoint(i,pp);
3235 // ----------------------------------------------------------------------------
3236 void manualViewBaseContour::Refresh() // virtual
3238 if (_contourVtkActor!=NULL){
3241 int i,size=_lstViewPoints.size();
3242 for (i=0;i<size;i++){
3244 _lstViewPoints[i]->UpdateColorActor();
3248 if (_show_text==true)
3253 vtkRenderWindowInteractor *vri = _wxvtkbaseview->GetWxVTKRenderWindowInteractor ();
3256 _wxvtkbaseview->GetRenWin()->Render();
3260 // ----------------------------------------------------------------------------
3261 void manualViewBaseContour::RefreshText() // virtual
3263 if( _textActor!=NULL)
3264 _textActor -> SetInput(" ");
3266 // ----------------------------------------------------------------------------
3267 void manualViewBaseContour::SetColorNormalContour(double r, double g, double b)
3269 _coulorNormal_r = r;
3270 _coulorNormal_g = g;
3271 _coulorNormal_b = b;
3273 // ----------------------------------------------------------------------------
3274 void manualViewBaseContour::GetColorNormalContour(double &r, double &g, double &b)
3276 r = _coulorNormal_r;
3277 g = _coulorNormal_g;
3278 b = _coulorNormal_b;
3280 // ----------------------------------------------------------------------------
3281 void manualViewBaseContour::SetColorEditContour(double r, double g, double b)
3287 // ----------------------------------------------------------------------------
3288 void manualViewBaseContour::GetColorEditContour(double &r, double &g, double &b)
3294 // ----------------------------------------------------------------------------
3295 void manualViewBaseContour::SetColorSelectContour(double r, double g, double b)
3297 _coulorSelection_r = r;
3298 _coulorSelection_g = g;
3299 _coulorSelection_b = b;
3301 // ----------------------------------------------------------------------------
3302 void manualViewBaseContour::GetColorSelectContour(double &r, double &g, double &b)
3304 r = _coulorSelection_r;
3305 g = _coulorSelection_g;
3306 b = _coulorSelection_b;
3308 // ----------------------------------------------------------------------------
3309 void manualViewBaseContour::UpdateColorActor()
3311 if (_contourVtkActor!=NULL)
3313 _contourVtkActor->GetProperty()->SetLineWidth( _widthline );
3314 _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorNormal_r , _coulorNormal_g , _coulorNormal_b );
3315 if (_posibleSelected || (_posibleSelected && GetEditable() ) )
3317 _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorEdit_r , _coulorEdit_g , _coulorEdit_b );
3321 _contourVtkActor->GetProperty()->SetDiffuseColor( _coulorSelection_r , _coulorSelection_g , _coulorSelection_b );
3325 // ----------------------------------------------------------------------------
3326 int manualViewBaseContour::GetIdPoint(int x, int y, int z) // virtual
3329 if (_manContModel!=NULL){
3333 TransfromeCoordViewWorld(xx,yy,zz);
3334 ii=_manContModel->GetIdPoint(xx,yy,zz,_range,-1);
3339 // ----------------------------------------------------------------------------
3342 int manualViewBaseContour::GetNumberOfPoints()
3344 return _lstViewPoints.size();
3347 // ----------------------------------------------------------------------------
3349 //JSTG 25-02-08 ---------------------------------------------------------------
3350 /*int manualViewBaseContour::GetNumberOfPointsSpline()
3352 return _sizePointsContour;
3354 //----------------------------------------------------------------------------
3356 //JSTG 25-02-08 ---------------------------------------------------------------
3357 /*void manualViewBaseContour::SetNumberOfPointsSpline(int size)
3359 _sizePointsContour = size;
3361 //----------------------------------------------------------------------------
3363 void manualViewBaseContour::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type) // Virtual
3365 _wxvtkbaseview->TransfromeCoordScreenToWorld(X, Y, Z, type);
3370 // wxVtk2DBaseView *wxvtk2Dbaseview = (wxVtk2DBaseView*)_wxvtkbaseview;
3371 // wxvtk2Dbaseview->TransformCoordinate_spacing_ModelToView(X,Y,Z);
3374 // ----------------------------------------------------------------------------
3375 void manualViewBaseContour::SetRange(int range)
3379 // ----------------------------------------------------------------------------
3380 int manualViewBaseContour::GetRange()
3384 // ----------------------------------------------------------------------------
3385 void manualViewBaseContour::SetZ(int z)
3389 // ----------------------------------------------------------------------------
3390 int manualViewBaseContour::GetZ()
3395 // ----------------------------------------------------------------------------
3396 void manualViewBaseContour::InitMove(int x, int y, int z) // virtual
3400 // ----------------------------------------------------------------------------
3401 void manualViewBaseContour::MoveContour(int x, int y, int z) // virtual
3404 // ----------------------------------------------------------------------------
3405 void manualViewBaseContour::MoveContour(int horizontalUnits, int verticalUnits )// virtual
3409 // ----------------------------------------------------------------------------
3410 void manualViewBaseContour::GetMinMax( double &minX,double &minY, double &minZ, double &maxX, double &maxY, double &maxZ )// virtual
3415 int size=_manContModel->GetSizeLstPoints();
3420 bool ifFindZ = minZ!=-1.0 && maxZ!=-1.0;
3426 for( i = 0; i < size; i++ )
3428 mp=_manContModel->GetManualPoint(i);
3480 // ----------------------------------------------------------------------------
3481 void manualViewBaseContour::ClearContour()
3483 if (_contourVtkActor!=NULL){
3484 _wxvtkbaseview->GetRenderer()->RemoveActor( _contourVtkActor );
3487 int i,size=_lstViewPoints.size();
3488 for (i=0;i<size;i++){
3493 // ----------------------------------------------------------------------------
3494 void manualViewBaseContour::ClearPoint(int id)
3498 // ----------------------------------------------------------------------------
3499 void manualViewBaseContour::SetVisible(bool ok)
3510 int i,size=_lstViewPoints.size();
3511 for (i=0;i<size;i++){
3512 actor = _lstViewPoints[i]->GetVtkActor();
3513 actor->GetProperty()->SetOpacity( opacity );
3515 _contourVtkActor->GetProperty()->SetOpacity( opacity );
3516 _textActor->GetProperty()->SetOpacity( opacity );
3517 _textActor->SetInput(" ");
3520 // ----------------------------------------------------------------------------
3521 void manualViewBaseContour::SetShowText(bool ok)
3524 if (_show_text==false)
3526 _textActor->SetInput(" ");
3529 // ----------------------------------------------------------------------------
3530 wxVtkBaseView *manualViewBaseContour::GetWxVtkBaseView()
3532 return this->_wxvtkbaseview;
3534 // ----------------------------------------------------------------------------
3535 void manualViewBaseContour::GetSpacing(double spc[3])
3541 // ----------------------------------------------------------------------------
3542 void manualViewBaseContour::SetSpacing(double spc[3])
3550 // ----------------------------------------------------------------------------
3551 // ----------------------------------------------------------------------------
3552 // ----------------------------------------------------------------------------
3554 // _type = 0 Sagital
3555 // _type = 1 Coronal
3557 // _type = -1 View 3D
3559 manualContour3VControler::manualContour3VControler(int type)
3564 // _manViewBaseCont1 = NULL;
3565 // _manViewBaseCont2 = NULL;
3566 // _manViewBaseCont3 = NULL;
3568 //----------------------------------------------------------------------------
3569 manualContour3VControler::~manualContour3VControler()
3573 // ----------------------------------------------------------------------------
3574 manualContour3VControler * manualContour3VControler :: Clone() // virtual
3576 manualContour3VControler * clone = new manualContour3VControler( this->GetType() );
3577 CopyAttributesTo(clone);
3581 // ---------------------------------------------------------------------------
3582 void manualContour3VControler::CopyAttributesTo( manualContour3VControler * cloneObject)
3585 manualContourControler::CopyAttributesTo(cloneObject);
3587 cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3589 // Remember to add ManualViewBaseContour with "AddManualViewBaseContour"
3592 // ----------------------------------------------------------------------------
3593 int manualContour3VControler::GetType()
3598 // ----------------------------------------------------------------------------
3599 void manualContour3VControler::AddPoint_Others()
3601 manualViewBaseContour *mvbc;
3602 int i,size=this->_lstManualViewBaseContour.size();
3603 for ( i = 0 ; i < size ; i++ )
3605 mvbc = _lstManualViewBaseContour[i];
3610 // if (_manViewBaseCont1!=NULL){
3611 // _manViewBaseCont1->AddPoint();
3612 // _manViewBaseCont2->AddPoint();
3613 // _manViewBaseCont3->AddPoint();
3614 // this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3617 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3619 // ----------------------------------------------------------------------------
3620 void manualContour3VControler::AddPoint( int x, int y, int z ) // virtual
3623 z=(int)_vtkmprbasedata->GetZ();
3624 if (GetManualContourModel()!=NULL){
3628 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3632 xx=_vtkmprbasedata->GetX();
3637 yy=_vtkmprbasedata->GetY();
3641 /*int id = */ GetManualContourModel()->AddPoint(xx,yy,zz); // JPRx
3642 GetManualViewBaseContour()->AddPoint();
3648 // ----------------------------------------------------------------------------
3649 void manualContour3VControler::InsertPoint_Others(int id)
3652 manualViewBaseContour *mvbc;
3653 int i,size=this->_lstManualViewBaseContour.size();
3654 for ( i = 0 ; i < size ; i++ )
3656 mvbc = _lstManualViewBaseContour[i];
3657 mvbc->InsertPoint(id);
3661 if (_manViewBaseCont1!=NULL){
3662 _manViewBaseCont1->InsertPoint(id);
3663 _manViewBaseCont2->InsertPoint(id);
3664 _manViewBaseCont3->InsertPoint(id);
3665 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3669 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3672 // ----------------------------------------------------------------------------
3673 void manualContour3VControler::InsertPoint(int x, int y, int z)
3676 if (GetManualContourModel()!=NULL){
3677 if (GetManualContourModel()->GetSizeLstPoints()>1){
3678 z=(int)_vtkmprbasedata->GetZ();
3682 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3685 xx=_vtkmprbasedata->GetX();
3690 yy=_vtkmprbasedata->GetY();
3693 id = GetManualContourModel()->InsertPoint(xx,yy,zz);
3695 GetManualViewBaseContour()->InsertPoint(id);
3696 InsertPoint_Others(0);
3703 // ----------------------------------------------------------------------------
3707 void manualContour3VControler::SetModelView ( manualContourModel *manContModel,
3708 manualViewBaseContour *manViewBaseCont0,
3709 manualViewBaseContour *manViewBaseCont1,
3710 manualViewBaseContour *manViewBaseCont2,
3711 manualViewBaseContour *manViewBaseCont3)
3713 manualContourControler::SetModelView(manContModel,manViewBaseCont0);
3714 _manViewBaseCont1 = manViewBaseCont1;
3715 _manViewBaseCont2 = manViewBaseCont2;
3716 _manViewBaseCont3 = manViewBaseCont3;
3720 // ----------------------------------------------------------------------------
3721 void manualContour3VControler::AddManualViewBaseContour( manualViewBaseContour *manViewBaseCont )
3723 _lstManualViewBaseContour.push_back( manViewBaseCont );
3726 // ----------------------------------------------------------------------------
3727 void manualContour3VControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3729 _vtkmprbasedata=vtkmprbasedata;
3731 // ----------------------------------------------------------------------------
3732 vtkMPRBaseData *manualContour3VControler::GetVtkMPRBaseData()
3734 return _vtkmprbasedata;
3736 // ----------------------------------------------------------------------------
3737 void manualContour3VControler::SetPoint( int id ,int x ,int y ,int z ) // virtual
3739 z=(int)_vtkmprbasedata->GetZ();
3740 if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
3744 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz,_type);
3748 xx=_vtkmprbasedata->GetX();
3752 yy=_vtkmprbasedata->GetY();
3755 manualPoint *mp = GetManualContourModel()->GetManualPoint(id);
3756 mp->SetPoint(xx,yy,zz);
3760 // ----------------------------------------------------------------------------
3761 void manualContour3VControler::DeleteActualMousePoint_Others(int id)
3763 manualViewBaseContour *mvbc;
3764 int i,size=this->_lstManualViewBaseContour.size();
3765 for ( i = 0 ; i < size ; i++ )
3767 mvbc = _lstManualViewBaseContour[i];
3768 mvbc->DeletePoint(id);
3773 if (_manViewBaseCont1!=NULL){
3774 _manViewBaseCont1->DeletePoint(id);
3775 _manViewBaseCont2->DeletePoint(id);
3776 _manViewBaseCont3->DeletePoint(id);
3778 _manViewBaseCont1->Refresh();
3779 _manViewBaseCont2->Refresh();
3780 _manViewBaseCont3->Refresh();
3782 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3785 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3787 // ----------------------------------------------------------------------------
3788 void manualContour3VControler::DeleteActualMousePoint(int x, int y)// virtual
3790 int id=GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
3792 manualContourBaseControler::DeleteActualMousePoint( x , y );
3793 DeleteActualMousePoint_Others( id );
3796 // ----------------------------------------------------------------------------
3797 void manualContour3VControler::MouseMove_Others(int id) // virtual
3799 manualViewBaseContour *mvbc;
3800 int i,size=this->_lstManualViewBaseContour.size();
3801 for ( i = 0 ; i < size ; i++ )
3803 mvbc = _lstManualViewBaseContour[i];
3804 mvbc->SelectAllPossibleSelected(false);
3807 mvbc->SetPointPosibleSelected(id,true);
3809 mvbc->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
3815 if (_manViewBaseCont1!=NULL){
3816 _manViewBaseCont1->SelectAllPossibleSelected(false);
3817 _manViewBaseCont2->SelectAllPossibleSelected(false);
3818 _manViewBaseCont3->SelectAllPossibleSelected(false);
3820 _manViewBaseCont1->SetPointPosibleSelected(id,true);
3821 _manViewBaseCont2->SetPointPosibleSelected(id,true);
3822 _manViewBaseCont3->SetPointPosibleSelected(id,true);
3824 _manViewBaseCont1->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
3825 _manViewBaseCont2->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
3826 _manViewBaseCont3->SetPosibleSelected ( GetManualViewBaseContour()->GetPosibleSelected() );
3828 _manViewBaseCont1->Refresh();
3829 _manViewBaseCont2->Refresh();
3830 _manViewBaseCont3->Refresh();
3832 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3835 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3839 // ----------------------------------------------------------------------------
3840 void manualContour3VControler::MouseMove(int x, int y) // virtual
3842 manualContourControler::MouseMove( x , y );
3843 int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
3844 MouseMove_Others( id );
3847 // ----------------------------------------------------------------------------
3848 void manualContour3VControler::OnChar_Others()
3850 manualViewBaseContour *mvbc;
3851 int i,size=this->_lstManualViewBaseContour.size();
3852 for ( i = 0 ; i < size ; i++ )
3854 mvbc = _lstManualViewBaseContour[i];
3859 _manViewBaseCont1->Refresh();
3860 _manViewBaseCont2->Refresh();
3861 _manViewBaseCont3->Refresh();
3863 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3865 // ----------------------------------------------------------------------------
3866 bool manualContour3VControler::OnChar()
3868 manualContourControler::OnChar();
3872 // ----------------------------------------------------------------------------
3873 void manualContour3VControler::ResetContour() // virtual
3875 manualContourControler::ResetContour();
3876 ResetContour_Others();
3879 // ----------------------------------------------------------------------------
3880 void manualContour3VControler::ResetContour_Others()
3882 manualViewBaseContour *mvbc;
3883 int i,size=this->_lstManualViewBaseContour.size();
3884 for ( i = 0 ; i < size ; i++ )
3886 mvbc = _lstManualViewBaseContour[i];
3887 mvbc->DeleteContour();
3888 mvbc->CreateNewContour();
3893 _manViewBaseCont1->DeleteContour();
3894 _manViewBaseCont2->DeleteContour();
3895 _manViewBaseCont3->DeleteContour();
3896 _manViewBaseCont1->CreateNewContour();
3897 _manViewBaseCont2->CreateNewContour();
3898 _manViewBaseCont3->CreateNewContour();
3902 // ----------------------------------------------------------------------------
3903 // ----------------------------------------------------------------------------
3904 // ----------------------------------------------------------------------------
3905 manualContour3DControler::manualContour3DControler()
3908 // ----------------------------------------------------------------------------
3909 manualContour3DControler::~manualContour3DControler()
3912 // ----------------------------------------------------------------------------
3913 manualContour3DControler * manualContour3DControler :: Clone() // virtual
3915 manualContour3DControler * clone = new manualContour3DControler();
3916 CopyAttributesTo(clone);
3920 // ---------------------------------------------------------------------------
3921 void manualContour3DControler::CopyAttributesTo( manualContour3DControler * cloneObject)
3924 manualContourControler::CopyAttributesTo(cloneObject);
3926 cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
3929 // ----------------------------------------------------------------------------
3930 bool manualContour3DControler::OnLeftButtonDown()
3933 wxVTKRenderWindowInteractor *wxVTKiren;
3934 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
3935 wxVTKiren->GetEventPosition(X,Y);
3936 MouseClickLeft(X,Y);
3939 // ----------------------------------------------------------------------------
3940 void manualContour3DControler::ResetOrientationPlane()
3942 double p[3],rp[3],rn[3];
3943 p[0] = this->GetVtkMPRBaseData()->GetX( );
3944 p[1] = this->GetVtkMPRBaseData()->GetY( );
3945 p[2] = this->GetVtkMPRBaseData()->GetZ( );
3946 this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
3947 this->GetVtkMPRBaseData()->SetNormal(rn[0],rn[1],rn[2]);
3949 // ----------------------------------------------------------------------------
3950 void manualContour3DControler::MouseClickLeft(int x, int y) // virtual
3952 manualView3DContour *manualview3Dcontour=(manualView3DContour*)GetManualViewBaseContour();
3953 int id=manualview3Dcontour->GetIdPoint2(x,y);
3954 if ( (GetState()==0) && (id!=-1) )
3956 manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
3958 this->GetVtkMPRBaseData()->SetX( mp->GetX() );
3959 this->GetVtkMPRBaseData()->SetY( mp->GetY() );
3960 this->GetVtkMPRBaseData()->SetZ( mp->GetZ() );
3961 ResetOrientationPlane();
3962 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
3966 manualContourControler::MouseClickLeft(x,y);
3969 // ----------------------------------------------------------------------------
3970 bool manualContour3DControler::OnChar()
3973 manualContourControler::OnChar();
3974 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
3977 ResetOrientationPlane();
3978 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
3983 // ----------------------------------------------------------------------------
3984 void manualContour3DControler::SetVtkMPRBaseData (vtkMPRBaseData *vtkmprbasedata )
3986 _vtkmprbasedata=vtkmprbasedata;
3988 // ----------------------------------------------------------------------------
3989 vtkMPRBaseData *manualContour3DControler::GetVtkMPRBaseData()
3991 return _vtkmprbasedata;
3994 // ----------------------------------------------------------------------------
3995 void manualContour3DControler::InsertPoint(int x, int y, int z ) // virtual
3997 manualContourControler::InsertPoint( x, y, z );
3998 ResetOrientationPlane();
4003 // ----------------------------------------------------------------------------
4004 // ----------------------------------------------------------------------------
4005 // ----------------------------------------------------------------------------
4007 manualContour3V3DControler::manualContour3V3DControler()
4010 // ----------------------------------------------------------------------------
4011 manualContour3V3DControler::~manualContour3V3DControler()
4015 // ----------------------------------------------------------------------------
4016 manualContour3V3DControler * manualContour3V3DControler :: Clone() // virtual
4018 manualContour3V3DControler * clone = new manualContour3V3DControler();
4019 CopyAttributesTo(clone);
4023 // ---------------------------------------------------------------------------
4024 void manualContour3V3DControler::CopyAttributesTo( manualContour3V3DControler * cloneObject)
4027 manualContour3DControler::CopyAttributesTo(cloneObject);
4029 cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4031 // ----------------------------------------------------------------------------
4032 void manualContour3V3DControler::InsertPoint(int x, int y, int z ) // virtual
4034 manualContour3DControler::InsertPoint( x, y, z );
4035 _manualcontour3Vcontroler->InsertPoint_Others(0);
4037 // ----------------------------------------------------------------------------
4038 void manualContour3V3DControler::AddPoint( int x, int y, int z )
4040 manualContour3DControler::AddPoint( x, y, z );
4041 _manualcontour3Vcontroler->AddPoint_Others();
4043 // ----------------------------------------------------------------------------
4044 void manualContour3V3DControler::DeleteActualMousePoint(int x, int y)
4046 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4047 manualContour3DControler::DeleteActualMousePoint( x , y );
4048 _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4050 // ----------------------------------------------------------------------------
4051 void manualContour3V3DControler::MouseMove( int x, int y )
4053 int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4054 if ((this->GetState()!=7) && (ss!=1)){
4055 manualContour3DControler::MouseMove( x , y );
4056 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4057 _manualcontour3Vcontroler->MouseMove_Others(id);
4060 // ----------------------------------------------------------------------------
4061 void manualContour3V3DControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4063 _manualcontour3Vcontroler = manualcontour3Vcontroler;
4065 // ----------------------------------------------------------------------------
4066 manualContour3VControler *manualContour3V3DControler::GetManualContour3VControler()
4068 return _manualcontour3Vcontroler;
4070 // ----------------------------------------------------------------------------
4071 bool manualContour3V3DControler::OnChar() // virtual
4073 if (manualContour3DControler::OnChar()==false )
4075 _manualcontour3Vcontroler->OnChar_Others();
4080 // ----------------------------------------------------------------------------
4081 void manualContour3V3DControler::ResetContour() // virtual
4083 manualContourControler::ResetContour();
4084 _manualcontour3Vcontroler->ResetContour_Others();
4088 // ----------------------------------------------------------------------------
4089 // ----------------------------------------------------------------------------
4090 // ----------------------------------------------------------------------------
4092 // _state = 0 // ..nothing..
4093 // _state = 1 // move with add point
4094 // _state = 5 // move
4095 // _state = 6 // move with insert point
4096 // _state = 7 // move with non selection
4098 manualContourControler::manualContourControler()
4100 _easyCreation = true;
4103 // ----------------------------------------------------------------------------
4104 manualContourControler::~manualContourControler()
4107 // ----------------------------------------------------------------------------
4108 manualContourControler * manualContourControler :: Clone() // virtual
4110 manualContourControler * clone = new manualContourControler();
4111 CopyAttributesTo(clone);
4114 // ---------------------------------------------------------------------------
4115 void manualContourControler::CopyAttributesTo( manualContourControler * cloneObject)
4118 manualContourBaseControler::CopyAttributesTo(cloneObject);
4119 cloneObject->SetEasyCreation( this->GetEasyCreation() );
4122 // ----------------------------------------------------------------------------
4123 void manualContourControler::Configure() //virtual
4125 // this->_manContModel->SetNumberOfPointsSpline(100);
4128 // ----------------------------------------------------------------------------
4129 void manualContourControler::MouseClickLeft(int x, int y){
4134 int size= GetManualViewBaseContour()->GetNumberOfPoints();
4136 // Insert a Control Point with shift+ClickLeft
4137 // int tt = GetState(); // JPRx
4138 vtkRenderWindowInteractor *vtkrenderwindowinteractor = _vtkInteractorStyleBaseView->GetInteractor();
4142 if ( (_vtkInteractorStyleBaseView!=NULL) && (GetState()==0) && ( (vtkrenderwindowinteractor!=NULL) && (vtkrenderwindowinteractor->GetShiftKey()==1) ) )
4148 // Start to Insert Control Points with ClickLeft (Empty contour)
4149 if ((GetState()==0) && (size==0) && (_easyCreation==true) )
4155 // Continuie to Insert Control Points with ClickLeft (After being empty the contour)
4156 if ((GetState()==1) && (_easyCreation==true) )
4160 _bakIdPoint=GetNumberOfPointsManualContour() - 1;
4162 // Insert Control Points IF Contour si Selected
4163 if ((GetState()==0) && GetManualViewBaseContour()->GetPosibleSelected() )
4167 _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4170 // Chose id of Control Point to be move
4171 if ( (GetState()==0 || GetState()==6) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) )
4174 _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4177 // If nothing selected _state=7
4178 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)==-1 ) )
4181 _bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4187 SetPosibleToMove( true );
4188 GetManualViewBaseContour()->SetSelected( GetManualViewBaseContour()->GetPosibleSelected() );
4190 if ( GetState() == 0 && GetManualViewBaseContour()->GetPosibleSelected() )
4194 GetManualViewBaseContour()->InitMove(x,y,z);
4199 GetManualViewBaseContour()->Refresh();
4202 // ----------------------------------------------------------------------------
4203 void manualContourControler::MouseMove(int x, int y) // virtual
4206 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4207 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4208 if (GetState()==1){ SetPoint( _bakIdPoint , x , y ,z); }
4209 if (GetState()==5){ SetPoint( _bakIdPoint , x , y ,z); }
4210 if ( GetState()==6 && !IsEditable() && GetPosibleToMove() &&IsMoving() )
4212 GetManualViewBaseContour()->MoveContour(x,y,z);
4214 if (GetState()!=7 || GetManualViewBaseContour()->GetPosibleSelected() ){
4215 GetManualViewBaseContour()->Refresh();
4216 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4220 GetManualViewBaseContour()->RemoveControlPoints();
4221 GetManualViewBaseContour()->RemoveTextActor();
4222 GetManualViewBaseContour()->Refresh();
4223 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4228 // ----------------------------------------------------------------------------
4229 void manualContourControler::MouseDLeft( int x, int y)//virtual
4231 manualContourBaseControler::MouseDLeft( x, y);
4234 GetManualViewBaseContour()->AddControlPoints();
4235 GetManualViewBaseContour()->AddTextActor();
4236 GetManualViewBaseContour()->Refresh();
4237 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4240 // ----------------------------------------------------------------------------
4241 void manualContourControler::SetEasyCreation(bool easyCreation)
4243 _easyCreation=easyCreation;
4245 // ----------------------------------------------------------------------------
4246 bool manualContourControler::GetEasyCreation()
4248 return _easyCreation;
4252 // ----------------------------------------------------------------------------
4253 // ----------------------------------------------------------------------------
4254 // ----------------------------------------------------------------------------
4255 manualContourPerpPlaneControler::manualContourPerpPlaneControler()
4257 _flagMouseMove = true;
4259 // ----------------------------------------------------------------------------
4260 manualContourPerpPlaneControler::~manualContourPerpPlaneControler()
4263 // ----------------------------------------------------------------------------
4264 manualContourPerpPlaneControler * manualContourPerpPlaneControler :: Clone() // virtual
4266 manualContourPerpPlaneControler * clone = new manualContourPerpPlaneControler();
4267 CopyAttributesTo(clone);
4271 // ---------------------------------------------------------------------------
4272 void manualContourPerpPlaneControler::CopyAttributesTo( manualContourPerpPlaneControler * cloneObject)
4275 manualContourControler::CopyAttributesTo(cloneObject);
4277 cloneObject->SetVtkMPRBaseData( this->GetVtkMPRBaseData() );
4278 cloneObject->SetManualContour3VControler( this->GetManualContour3VControler() );
4279 cloneObject->SetVtkInteractorStylePlane2D( this->GetVtkInteractorStylePlane2D() );
4282 // ----------------------------------------------------------------------------
4283 void manualContourPerpPlaneControler::SetVtkMPRBaseData(vtkMPRBaseData *vtkmprbasedata)
4285 _vtkmprbasedata = vtkmprbasedata;
4288 // ----------------------------------------------------------------------------
4289 vtkMPRBaseData *manualContourPerpPlaneControler::GetVtkMPRBaseData()
4291 return _vtkmprbasedata;
4295 // ----------------------------------------------------------------------------
4296 void manualContourPerpPlaneControler::InsertPoint(int x, int y, int z ) // virtual
4298 manualContourControler::InsertPoint( x, y, z );
4299 _manualcontour3Vcontroler->InsertPoint_Others(0);
4301 // ----------------------------------------------------------------------------
4302 void manualContourPerpPlaneControler::AddPoint( int x, int y, int z )
4304 manualContourControler::AddPoint( x, y, z );
4305 _manualcontour3Vcontroler->AddPoint_Others();
4307 // ----------------------------------------------------------------------------
4308 void manualContourPerpPlaneControler::DeleteActualMousePoint(int x, int y)
4310 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4311 manualContourControler::DeleteActualMousePoint( x , y );
4312 _manualcontour3Vcontroler->DeleteActualMousePoint_Others(id);
4314 // ----------------------------------------------------------------------------
4315 void manualContourPerpPlaneControler::MouseMove( int x, int y )
4317 _flagMouseMove = true;
4318 int ss =this->_vtkInteractorStyleBaseView->vtkInteractorStyle::GetState();
4319 if ((this->GetState()!=7) && (ss!=1)){
4320 manualContourControler::MouseMove( x , y );
4321 int id = GetManualViewBaseContour()->GetIdPoint ( x , y , GetZ() );
4324 _manualcontour3Vcontroler->MouseMove_Others(id);
4325 _flagMouseMove = false;
4329 // ----------------------------------------------------------------------------
4330 void manualContourPerpPlaneControler::SetManualContour3VControler(manualContour3VControler *manualcontour3Vcontroler)
4332 _manualcontour3Vcontroler = manualcontour3Vcontroler;
4334 // ----------------------------------------------------------------------------
4335 manualContour3VControler * manualContourPerpPlaneControler::GetManualContour3VControler()
4337 return _manualcontour3Vcontroler;
4339 // ----------------------------------------------------------------------------
4340 bool manualContourPerpPlaneControler::OnChar() // virtual
4342 if (manualContourControler::OnChar()==false )
4344 _manualcontour3Vcontroler->OnChar_Others();
4348 // ----------------------------------------------------------------------------
4349 bool manualContourPerpPlaneControler::OnMouseMove() // virtual
4351 manualContourControler::OnMouseMove();
4352 return _flagMouseMove;
4354 // ----------------------------------------------------------------------------
4355 bool manualContourPerpPlaneControler::OnLeftDClick() // virtual
4357 manualContourControler::OnLeftDClick();
4358 return _flagMouseDClick;
4360 // ----------------------------------------------------------------------------
4361 void manualContourPerpPlaneControler::ResetContour() // virtual
4363 manualContourControler::ResetContour();
4364 _manualcontour3Vcontroler->ResetContour_Others();
4367 // ----------------------------------------------------------------------------
4368 void manualContourPerpPlaneControler::MouseDLeft( int x, int y) // virtual
4370 _flagMouseDClick=true;
4371 manualContourControler::MouseDLeft(x,y);
4373 if (GetManualViewBaseContour()->ifTouchContour(x,y,0)==true)
4375 _flagMouseDClick = false;
4376 _vtkinteractorstyleplane2D->OnLeftDClick();
4377 ResetOrientationPlane();
4378 this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4381 // int id=GetManualViewBaseContour()->GetIdPoint(x,y,GetZ());
4382 // if ( (GetState()==0) && (id!=-1) )
4384 // manualPoint *mp = this->GetManualContourModel()->GetManualPoint(id);
4385 // _vtkmprbasedata->SetX( mp->GetX() );
4386 // _vtkmprbasedata->SetY( mp->GetY() );
4387 // _vtkmprbasedata->SetZ( mp->GetZ() );
4388 // ResetOrientationPlane();
4389 // this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
4395 // ----------------------------------------------------------------------------
4396 void manualContourPerpPlaneControler::ResetOrientationPlane()
4398 double p[3],rp[3],rn[3];
4399 p[0] = _vtkmprbasedata->GetX( );
4400 p[1] = _vtkmprbasedata->GetY( );
4401 p[2] = _vtkmprbasedata->GetZ( );
4402 this->GetManualContourModel()->GetNearestPointAndNormal(p,rp,rn);
4404 _vtkmprbasedata->SetNormal(rn[0],rn[1],rn[2]);
4407 // ----------------------------------------------------------------------------
4408 void manualContourPerpPlaneControler::SetVtkInteractorStylePlane2D(InteractorStyleMaracas *vtkinteractorstyleplane2D)
4410 _vtkinteractorstyleplane2D = vtkinteractorstyleplane2D;
4412 // ----------------------------------------------------------------------------
4413 InteractorStyleMaracas * manualContourPerpPlaneControler::GetVtkInteractorStylePlane2D()
4415 return _vtkinteractorstyleplane2D;
4418 // ----------------------------------------------------------------------------
4419 // ----------------------------------------------------------------------------
4420 // ----------------------------------------------------------------------------
4422 // _state = 0 // ..nothing..
4423 // _state = 5 // move point
4424 // _state = 6 // move all
4425 // _state = 7 // Empty mouse drag
4427 manualRoiControler::manualRoiControler()
4430 // ----------------------------------------------------------------------------
4431 manualRoiControler::~manualRoiControler()
4434 // ----------------------------------------------------------------------------
4435 manualRoiControler * manualRoiControler :: Clone() // virtual
4437 manualRoiControler * clone = new manualRoiControler();
4438 CopyAttributesTo(clone);
4442 // ---------------------------------------------------------------------------
4443 void manualRoiControler::CopyAttributesTo( manualRoiControler * cloneObject)
4446 manualContourBaseControler::CopyAttributesTo(cloneObject);
4449 // ----------------------------------------------------------------------------
4450 void manualRoiControler::Configure() //virtual
4452 this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4455 // ----------------------------------------------------------------------------
4456 void manualRoiControler::MouseClickLeft(int x, int y){
4458 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4459 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4462 if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
4463 GetManualViewBaseContour()->InitMove(x,y,z);
4466 int size=GetManualViewBaseContour()->GetNumberOfPoints();
4467 if (GetState()==0) {
4479 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4482 GetManualViewBaseContour()->Refresh();
4484 // ----------------------------------------------------------------------------
4485 void manualRoiControler::MouseMove(int x, int y) // virtual
4489 // this->_vtkInteractorStyleBaseView->
4491 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4492 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4495 SetPoint( bakIdPoint , x , y ,z);
4518 GetManualViewBaseContour()->MoveContour(x,y,z);
4520 GetManualViewBaseContour()->Refresh();
4522 // ----------------------------------------------------------------------------
4523 void manualRoiControler::DeleteActualMousePoint(int x, int y) // virtual
4526 // ----------------------------------------------------------------------------
4527 void manualRoiControler::InitRoi(int ww, int hh, double porcentage)
4532 if (GetManualContourModel()->GetSizeLstPoints() ==0)
4541 double pp1=porcentage;
4542 double pp2=1-porcentage;
4544 mp = GetManualContourModel()->GetManualPoint(2);
4546 mp->SetPoint(ww*pp1,hh*pp1,zz);
4548 mp = GetManualContourModel()->GetManualPoint(1);
4550 mp->SetPoint(ww*pp2,hh*pp1,zz);
4552 mp = GetManualContourModel()->GetManualPoint(0);
4554 mp->SetPoint(ww*pp2,hh*pp2,zz);
4556 mp = GetManualContourModel()->GetManualPoint(3);
4558 mp->SetPoint(ww*pp1,hh*pp2,zz);
4560 GetManualViewBaseContour() ->UpdateViewPoint(0);
4561 GetManualViewBaseContour() ->UpdateViewPoint(1);
4562 GetManualViewBaseContour() ->UpdateViewPoint(2);
4563 GetManualViewBaseContour() ->UpdateViewPoint(3);
4566 GetManualViewBaseContour()->Refresh();
4569 // ----------------------------------------------------------------------------
4570 void manualRoiControler::SetRoi(int x1, int y1,int x2, int y2)
4573 InitRoi( 0 , 0 , 0.2 );
4574 mp = GetManualContourModel()->GetManualPoint(2);
4578 mp = GetManualContourModel()->GetManualPoint(1);
4582 mp = GetManualContourModel()->GetManualPoint(0);
4586 mp = GetManualContourModel()->GetManualPoint(3);
4590 GetManualViewBaseContour() ->UpdateViewPoint(0);
4591 GetManualViewBaseContour() ->UpdateViewPoint(1);
4592 GetManualViewBaseContour() ->UpdateViewPoint(2);
4593 GetManualViewBaseContour() ->UpdateViewPoint(3);
4597 // ----------------------------------------------------------------------------
4598 // ----------------------------------------------------------------------------
4599 // ----------------------------------------------------------------------------
4603 // _state = 0 // ..nothing..
4604 // _state = 5 // move point
4605 // _state = 6 // move all
4606 // _state = 7 // Empty mouse drag
4608 manualCircleControler::manualCircleControler()
4611 // ----------------------------------------------------------------------------
4612 manualCircleControler::~manualCircleControler()
4615 // ----------------------------------------------------------------------------
4616 manualCircleControler * manualCircleControler :: Clone() // virtual
4618 manualCircleControler * clone = new manualCircleControler();
4619 CopyAttributesTo(clone);
4623 // ---------------------------------------------------------------------------
4624 void manualCircleControler::CopyAttributesTo( manualCircleControler * cloneObject)
4627 manualContourBaseControler::CopyAttributesTo(cloneObject);
4630 // ----------------------------------------------------------------------------
4631 void manualCircleControler::Configure() //virtual
4633 // this->GetManualContourModel()->SetNumberOfPointsSpline(5);
4636 // ----------------------------------------------------------------------------
4637 void manualCircleControler::MouseClickLeft(int x, int y){
4639 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4640 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4643 if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
4644 GetManualViewBaseContour()->InitMove(x,y,z);
4647 int size=GetManualViewBaseContour()->GetNumberOfPoints();
4648 if (GetState()==0) {
4657 // SetPoint(2,x,y,z);
4658 // SetPoint(3,x,y,z);
4660 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4663 GetManualViewBaseContour()->Refresh();
4665 // ----------------------------------------------------------------------------
4667 void manualCircleControler::MouseMove(int x, int y) // virtual
4671 // this->_vtkInteractorStyleBaseView->
4673 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4674 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4677 SetPoint( bakIdPoint , x , y ,z);
4703 GetManualViewBaseContour()->MoveContour(x,y,z);
4705 GetManualViewBaseContour()->Refresh();
4709 // ----------------------------------------------------------------------------
4710 void manualCircleControler::DeleteActualMousePoint(int x, int y) // virtual
4713 // ----------------------------------------------------------------------------
4715 void manualCircleControler::InitRoi(int ww, int hh, double porcentage)
4720 if (GetManualContourModel()->GetSizeLstPoints() ==0)
4725 // AddPoint(0,0,zz);
4726 // AddPoint(0,0,zz);
4729 double pp1=porcentage;
4730 double pp2=1-porcentage;
4732 // mp = GetManualContourModel()->GetManualPoint(2);
4733 // zz=(int)mp->GetZ();
4734 // mp->SetPoint(ww*pp1,hh*pp1,zz);
4736 mp = GetManualContourModel()->GetManualPoint(1);
4738 mp->SetPoint(ww*pp2,hh*pp1,zz);
4740 mp = GetManualContourModel()->GetManualPoint(0);
4742 mp->SetPoint(ww*pp2,hh*pp2,zz);
4744 // mp = GetManualContourModel()->GetManualPoint(3);
4745 // zz=(int)mp->GetZ();
4746 // mp->SetPoint(ww*pp1,hh*pp2,zz);
4748 GetManualViewBaseContour() ->UpdateViewPoint(0);
4749 GetManualViewBaseContour() ->UpdateViewPoint(1);
4750 // GetManualViewBaseContour() ->UpdateViewPoint(2);
4751 // GetManualViewBaseContour() ->UpdateViewPoint(3);
4754 GetManualViewBaseContour()->Refresh();
4757 // ----------------------------------------------------------------------------
4759 void manualCircleControler::SetRoi(int x1, int y1,int x2, int y2)
4762 InitRoi( 0 , 0 , 0.2 );
4763 mp = GetManualContourModel()->GetManualPoint(2);
4767 mp = GetManualContourModel()->GetManualPoint(1);
4771 mp = GetManualContourModel()->GetManualPoint(0);
4775 mp = GetManualContourModel()->GetManualPoint(3);
4779 GetManualViewBaseContour() ->UpdateViewPoint(0);
4780 GetManualViewBaseContour() ->UpdateViewPoint(1);
4781 GetManualViewBaseContour() ->UpdateViewPoint(2);
4782 GetManualViewBaseContour() ->UpdateViewPoint(3);
4787 // ----------------------------------------------------------------------------
4788 // ----------------------------------------------------------------------------
4789 // ----------------------------------------------------------------------------
4793 // _state = 0 // ..nothing..
4794 // _state = 5 // move point
4795 // _state = 6 // move all
4796 // _state = 7 // Empty mouse drag
4798 manualLineControler::manualLineControler()
4801 // ----------------------------------------------------------------------------
4802 manualLineControler::~manualLineControler()
4805 // ----------------------------------------------------------------------------
4806 manualLineControler * manualLineControler :: Clone() // virtual
4808 manualLineControler * clone = new manualLineControler();
4809 CopyAttributesTo(clone);
4813 // ---------------------------------------------------------------------------
4814 void manualLineControler::CopyAttributesTo( manualLineControler * cloneObject)
4817 manualContourBaseControler::CopyAttributesTo(cloneObject);
4820 // ----------------------------------------------------------------------------
4821 void manualLineControler::MouseClickLeft(int x, int y){
4823 if ( (GetState()==0) && (GetManualViewBaseContour()->GetIdPoint(x,y,z)!=-1 ) ){
4824 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4827 if ((GetState()==0) && (GetManualViewBaseContour()->GetPosibleSelected()==true)) {
4828 GetManualViewBaseContour()->InitMove(x,y,z);
4831 int size=GetManualViewBaseContour()->GetNumberOfPoints();
4832 if (GetState()==0) {
4840 bakIdPoint = GetManualViewBaseContour()->GetIdPoint(x,y,z);
4843 GetManualViewBaseContour()->Refresh();
4845 // ----------------------------------------------------------------------------
4847 void manualLineControler::MouseMove(int x, int y) // virtual
4851 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
4852 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
4856 SetPoint( bakIdPoint , x , y ,z);
4860 GetManualViewBaseContour()->MoveContour(x,y,z);
4862 GetManualViewBaseContour()->Refresh();
4866 // ----------------------------------------------------------------------------
4867 void manualLineControler::DeleteActualMousePoint(int x, int y) // virtual
4870 // ----------------------------------------------------------------------------
4872 void manualLineControler::InitRoi(int ww, int hh, double porcentage)
4877 if (GetManualContourModel()->GetSizeLstPoints() ==0)
4884 double pp1=porcentage;
4885 double pp2=1-porcentage;
4887 mp = GetManualContourModel()->GetManualPoint(0);
4889 mp->SetPoint(ww*pp2,hh*pp2,zz);
4891 mp = GetManualContourModel()->GetManualPoint(1);
4893 mp->SetPoint(ww*pp2,hh*pp1,zz);
4895 GetManualViewBaseContour() ->UpdateViewPoint(0);
4896 GetManualViewBaseContour() ->UpdateViewPoint(1);
4899 GetManualViewBaseContour()->Refresh();
4902 // ----------------------------------------------------------------------------
4903 // ----------------------------------------------------------------------------
4904 // ----------------------------------------------------------------------------
4907 manualContourBaseControler::manualContourBaseControler()
4909 _manViewBaseCont = NULL;
4910 _manContModel = NULL;
4914 _posibleToMove = true;
4917 _keyBoardMoving = false;
4919 // ----------------------------------------------------------------------------
4920 manualContourBaseControler::~manualContourBaseControler()
4924 // ----------------------------------------------------------------------------
4925 manualContourBaseControler * manualContourBaseControler :: Clone() // virtual
4927 manualContourBaseControler * clone = new manualContourBaseControler();
4928 CopyAttributesTo(clone);
4932 // ---------------------------------------------------------------------------
4934 void manualContourBaseControler::CopyAttributesTo( manualContourBaseControler * cloneObject)
4937 InteractorStyleMaracas::CopyAttributesTo(cloneObject);
4938 cloneObject->SetZ( this->GetZ() );
4939 cloneObject->SetState( this->GetState() );
4940 cloneObject->SetEditable( this->IsEditable() );
4941 cloneObject->SetPosibleToMove( this->GetPosibleToMove() );
4942 cloneObject->SetMoving( this->IsMoving() );
4943 cloneObject->SetCompleteCreation( this->GetIfCompleteCreation() );
4944 cloneObject->SetKeyBoardMoving( this->GetKeyBoardMoving() );
4947 // ----------------------------------------------------------------------------
4948 void manualContourBaseControler::Configure() //virtual
4952 // ----------------------------------------------------------------------------
4953 bool manualContourBaseControler::OnChar()
4955 if ( _vtkInteractorStyleBaseView!=NULL )
4957 char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
4960 wxVTKRenderWindowInteractor *_wxVTKiren;
4961 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
4962 _wxVTKiren->GetEventPosition(X, Y);
4963 //int Z = GetZ(); // JPRx
4965 if ((keyCode==8) || (keyCode==127))
4968 if (!GetManualViewBaseContour()->GetPosibleSelected()==true)
4970 DeleteActualMousePoint(X,Y);
4972 GetManualViewBaseContour()->Refresh();
4973 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4981 GetManualViewBaseContour()->Refresh();
4982 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
4984 else if( !IsEditable() )
4986 if ( keyCode == 'L' )
4988 GetManualViewBaseContour()->MoveContour( -1, 0 );
4989 SetKeyBoardMoving( true );
4991 else if ( keyCode == 'R' )
4993 GetManualViewBaseContour()->MoveContour( 1, 0 );
4994 SetKeyBoardMoving( true );
4996 else if ( keyCode == 'U' )
4998 GetManualViewBaseContour()->MoveContour( 0, -1 );
4999 SetKeyBoardMoving( true );
5001 else if ( keyCode == 'D' )
5003 GetManualViewBaseContour()->MoveContour( 0, 1 );
5004 SetKeyBoardMoving( true );
5006 else if ( keyCode == 'W' )//Diagonal left down
5008 GetManualViewBaseContour()->MoveContour( -1, 1 );
5009 SetKeyBoardMoving( true );
5011 else if ( keyCode == 'Q' )//Diagonal left up
5013 GetManualViewBaseContour()->MoveContour( -1, -1 );
5014 SetKeyBoardMoving( true );
5016 else if( keyCode == 'P' )//Diagonal right up
5018 GetManualViewBaseContour()->MoveContour( 1, -1 );
5019 SetKeyBoardMoving( true );
5021 else if( keyCode == 'M' )//Diagonal right down
5023 GetManualViewBaseContour()->MoveContour( 1, 1 );
5024 SetKeyBoardMoving( true );
5026 if( GetKeyBoardMoving() )
5028 GetManualViewBaseContour()->Refresh();
5029 this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
5036 // ----------------------------------------------------------------------------
5037 bool manualContourBaseControler::OnMouseMove()
5039 if ( _vtkInteractorStyleBaseView!=NULL)
5042 wxVTKRenderWindowInteractor *_wxVTKiren;
5043 _wxVTKiren= _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5044 _wxVTKiren->GetEventPosition( X , Y );
5047 if ( (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) &&
5048 (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) ) {
5054 // ----------------------------------------------------------------------------
5055 bool manualContourBaseControler::OnLeftButtonDown()
5057 SetKeyBoardMoving( false );
5058 if ( _vtkInteractorStyleBaseView!=NULL )
5061 wxVTKRenderWindowInteractor *wxVTKiren;
5062 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5063 wxVTKiren->GetEventPosition(X,Y);
5065 MouseClickLeft(X,Y);
5069 // ----------------------------------------------------------------------------
5070 bool manualContourBaseControler::OnLeftButtonUp()
5072 if ( _vtkInteractorStyleBaseView!=NULL )
5075 wxVTKRenderWindowInteractor *wxVTKiren;
5076 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5077 wxVTKiren->GetEventPosition(X,Y);
5078 MouseReleaseLeft(X,Y);
5082 // ----------------------------------------------------------------------------
5083 bool manualContourBaseControler::OnLeftDClick()
5085 if ( _vtkInteractorStyleBaseView!=NULL )
5088 wxVTKRenderWindowInteractor *wxVTKiren;
5089 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5090 wxVTKiren->GetEventPosition(X,Y);
5092 this->MouseDLeft(X,Y);
5096 // ----------------------------------------------------------------------------
5097 bool manualContourBaseControler::OnMiddleButtonDown()
5099 // SetKeyBoardMoving( false );
5100 if ( _vtkInteractorStyleBaseView!=NULL )
5103 wxVTKRenderWindowInteractor *wxVTKiren;
5104 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5105 wxVTKiren->GetEventPosition(X,Y);
5106 GetManualViewBaseContour()->InitMove( X, Y,GetZ());
5110 // ----------------------------------------------------------------------------
5111 bool manualContourBaseControler::OnMiddleButtonUp()
5115 // ----------------------------------------------------------------------------
5116 bool manualContourBaseControler::OnRightButtonDown()
5118 if( _vtkInteractorStyleBaseView!= NULL )
5121 wxVTKRenderWindowInteractor *wxVTKiren;
5122 wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
5123 wxVTKiren->GetEventPosition(X, Y);
5125 SetCompleteCreation( true );
5126 SetKeyBoardMoving( false );
5127 MouseClickRight(X,Y);
5131 // ----------------------------------------------------------------------------
5132 bool manualContourBaseControler::OnRightButtonUp()
5136 // ----------------------------------------------------------------------------
5137 void manualContourBaseControler::SetModelView(manualContourModel *manContModel, manualViewBaseContour *manViewBaseCont){
5138 _manContModel = manContModel;
5139 _manViewBaseCont = manViewBaseCont;
5140 _manViewBaseCont->SetEditable( &_editable );
5142 // ----------------------------------------------------------------------------
5143 manualContourModel* manualContourBaseControler::GetManualContourModel()
5145 return _manContModel;
5147 // ----------------------------------------------------------------------------
5148 manualViewBaseContour* manualContourBaseControler::GetManualViewBaseContour()
5150 return _manViewBaseCont;
5152 // ----------------------------------------------------------------------------
5153 void manualContourBaseControler::MouseClickLeft(int x, int y) // virtual
5157 // ----------------------------------------------------------------------------
5158 void manualContourBaseControler::MouseClickRight(int x, int y)
5164 SetEditable( false );
5165 SetPosibleToMove( false );
5169 // ----------------------------------------------------------------------------
5170 void manualContourBaseControler::MouseReleaseLeft(int x, int y)
5172 if (_state==5){ _state = 0; }
5173 if (_state==6){ _state = 0; }
5174 if (_state==7){ _state = 0; }
5176 GetManualViewBaseContour()->SelectPosibleContour(x,y,GetZ());
5177 if( GetIfCompleteCreation() && IsEditable() && !GetManualViewBaseContour()->GetPosibleSelected() && (GetManualViewBaseContour()->GetIdPoint(x,y,GetZ())==-1) )
5179 SetEditable( false );
5180 SetPosibleToMove( false );
5183 // ----------------------------------------------------------------------------
5184 void manualContourBaseControler::MouseDLeft(int x, int y )
5189 GetManualViewBaseContour()->SelectPosibleContour(x,y,z);
5190 GetManualViewBaseContour()->SelectPosiblePoint(x,y,z);
5191 if ( GetManualViewBaseContour()->GetPosibleSelected() )
5197 // ----------------------------------------------------------------------------
5198 void manualContourBaseControler::MouseMove(int x, int y) // virtual
5201 // ----------------------------------------------------------------------------
5202 void manualContourBaseControler::SetState(int state)
5206 // ----------------------------------------------------------------------------
5207 int manualContourBaseControler::GetState()
5211 // ----------------------------------------------------------------------------
5212 bool manualContourBaseControler::IsEditable( )
5216 // ----------------------------------------------------------------------------
5217 void manualContourBaseControler::SetEditable( bool condition )
5219 if (GetManualViewBaseContour()!=NULL) {
5222 GetManualViewBaseContour()->RemoveControlPoints();
5224 GetManualViewBaseContour()->SetSelected( condition );
5226 _editable = condition;
5229 // ----------------------------------------------------------------------------
5230 bool manualContourBaseControler::GetPosibleToMove()
5232 return _posibleToMove;
5234 // ----------------------------------------------------------------------------
5235 void manualContourBaseControler::SetPosibleToMove( bool condition )
5237 _posibleToMove = condition;
5239 // ----------------------------------------------------------------------------
5240 bool manualContourBaseControler::IsMoving()
5244 // ----------------------------------------------------------------------------
5245 void manualContourBaseControler::SetMoving( bool condition )
5247 _moving = condition;
5249 // ----------------------------------------------------------------------------
5250 void manualContourBaseControler::SetCompleteCreation( bool condition )
5252 _created = condition;
5254 // ----------------------------------------------------------------------------
5255 bool manualContourBaseControler::GetIfCompleteCreation ( )
5259 // ----------------------------------------------------------------------------
5260 void manualContourBaseControler::SetKeyBoardMoving( bool condition )
5262 _keyBoardMoving = condition;
5264 // ----------------------------------------------------------------------------
5265 bool manualContourBaseControler::GetKeyBoardMoving( )
5267 return _keyBoardMoving;
5269 // ----------------------------------------------------------------------------
5270 void manualContourBaseControler::CreateNewManualContour(){
5271 _manViewBaseCont->CreateNewContour();
5273 // ----------------------------------------------------------------------------
5274 int manualContourBaseControler::GetNumberOfPointsManualContour(){
5275 return _manViewBaseCont->GetNumberOfPoints();
5277 // ----------------------------------------------------------------------------
5279 //JSTG - 25-02-08 -------------------------------------------------------------
5280 int manualContourBaseControler::GetNumberOfPointsSplineManualContour(){
5281 //return _manViewBaseCont->GetNumberOfPointsSpline();
5282 return _manContModel->GetNumberOfPointsSpline();
5284 // ----------------------------------------------------------------------------
5286 double* manualContourBaseControler::GetVectorPointsXManualContour(){
5287 return _manViewBaseCont->GetVectorPointsXManualContour();
5289 // ----------------------------------------------------------------------------
5290 double* manualContourBaseControler::GetVectorPointsYManualContour(){
5291 return _manViewBaseCont->GetVectorPointsYManualContour();
5293 // ----------------------------------------------------------------------------
5294 void manualContourBaseControler::DeleteContour(){
5295 _manViewBaseCont->DeleteContour();
5296 _manContModel->DeleteAllPoints();
5298 // ----------------------------------------------------------------------------
5299 void manualContourBaseControler::DeleteActualMousePoint(int x, int y)// virtual
5301 if ((_manContModel!=NULL) && (_manViewBaseCont!=NULL) )
5303 int id=_manViewBaseCont->GetIdPoint(x,y,GetZ());
5304 if ((id!=-1) && (_manContModel->GetSizeLstPoints()>2) ){
5305 _manContModel->DeletePoint(id);
5306 _manViewBaseCont->DeletePoint(id);
5312 // ----------------------------------------------------------------------------
5313 void manualContourBaseControler::Magnet(int x, int y)
5317 /*int id= */ _manViewBaseCont->GetIdPoint(x,y,GetZ()); // JPRx
5318 if (GetManualContourModel()!=NULL){
5322 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5323 int id = GetManualContourModel()->GetIdPoint(xx,yy,zz,32000,-1);
5326 manualPoint *mp = GetManualContourModel()->GetManualPoint(id);
5327 mp->SetPoint(xx,yy,zz);
5329 // GetManualViewBaseContour()->UpdateViewPoint(id);
5335 // ----------------------------------------------------------------------------
5336 void manualContourBaseControler::SetZ(int z)
5340 // ----------------------------------------------------------------------------
5341 int manualContourBaseControler::GetZ()
5345 // ----------------------------------------------------------------------------
5346 void manualContourBaseControler::AddPoint(int x, int y, int z) // virtual
5348 if (GetManualContourModel()!=NULL){
5352 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5353 /*int id =*/ GetManualContourModel()->AddPoint(xx,yy,zz); // JPRx
5354 GetManualViewBaseContour()->AddPoint();
5355 // GetManualViewBaseContour()->UpdateViewPoint(id);
5358 // ----------------------------------------------------------------------------
5359 void manualContourBaseControler::InsertPoint(int x,int y,int z) // virtual
5363 if (GetManualContourModel()!=NULL){
5367 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5368 if (GetManualContourModel()->GetSizeLstPoints()>1){
5369 id = GetManualContourModel()->InsertPoint(xx,yy,zz);
5370 GetManualViewBaseContour()->InsertPoint(id);
5371 // GetManualViewBaseContour()->UpdateViewPoint(id);
5373 GetManualContourModel()->AddPoint(xx,yy,zz);
5374 GetManualViewBaseContour()->AddPoint();
5376 // GetManualViewBaseContour()->UpdateViewPoint(id);
5381 // ----------------------------------------------------------------------------
5382 void manualContourBaseControler::SetPoint( int id ,int x , int y , int z){ // virtual
5383 if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5387 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5388 manualPoint *mp = _manContModel->GetManualPoint(id);
5389 mp->SetPoint(xx,yy,zz);
5390 GetManualViewBaseContour()->UpdateViewPoint(id);
5393 // ----------------------------------------------------------------------------
5394 void manualContourBaseControler::SetPointX( int id ,int x ){
5395 if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5399 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5400 manualPoint *mp = _manContModel->GetManualPoint(id);
5402 GetManualViewBaseContour()->UpdateViewPoint(id);
5405 // ----------------------------------------------------------------------------
5406 void manualContourBaseControler::SetPointY( int id ,int y ){
5407 if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5411 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5412 manualPoint *mp = _manContModel->GetManualPoint(id);
5414 GetManualViewBaseContour()->UpdateViewPoint(id);
5417 // ----------------------------------------------------------------------------
5418 void manualContourBaseControler::SetPointZ( int id ,int z ){
5419 if ((GetManualViewBaseContour()!=NULL) && (id>=0)){
5423 GetManualViewBaseContour()->TransfromeCoordViewWorld(xx,yy,zz);
5424 manualPoint *mp = _manContModel->GetManualPoint(id);
5426 GetManualViewBaseContour()->UpdateViewPoint(id);
5429 // ----------------------------------------------------------------------------
5430 void manualContourBaseControler::ResetContour() // virtual
5432 this->DeleteContour();
5433 GetManualViewBaseContour()->CreateNewContour();