PropContour Class Reference

#include <Propagation.h>

Collaboration diagram for PropContour:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 PropContour ()
 ~PropContour ()
int VectorDirection (std::vector< double > *InX, std::vector< double > *InY, std::vector< double > *InZ)
void VectorOrder (int dir, int posinic, std::vector< double > *InX, std::vector< double > *InY, std::vector< double > *InZ)
void ReadKeyContour (FILE *fd)
void ResetKeyContours ()
void SetKeyContours (std::vector< double > *InX, std::vector< double > *InY, std::vector< double > *InZ)
vtkImageData * CalculeSplinePropagation ()
void GetKeyContours (std::vector< double > *KeyX, std::vector< double > *KeyY, std::vector< double > *KeyZ, std::vector< int > *KeyS)
void GetPropagatedContours (std::vector< Vector > *planevec)
void GetIdContour (int id, std::vector< double > *vecX, std::vector< double > *vecY, std::vector< double > *vecZ)
void SetInterpNumber (int val)
int FindIdWithZ (double z)

Private Member Functions

void PreparePointsForSpline (std::vector< double > *InX, std::vector< double > *InY, std::vector< double > *InZ, std::vector< int > *Sizes)
vtkImageData * method_Spline (std::vector< double > *InX, std::vector< double > *InY, std::vector< double > *InZ, std::vector< int > *Sizes)
void ResetPlaneVector ()

Private Attributes

int _interpnumber
int _dimImage [3]
vtkImageData * imagedataValue
manualContourModel * _mContourModel
std::vector< double > _KeyContourX
std::vector< double > _KeyContourY
std::vector< double > _KeyContourZ
std::vector< int > _KeyContourSizes
std::vector< Vector > _planevector

Detailed Description

Definition at line 50 of file Propagation.h.

Constructor & Destructor Documentation

PropContour::PropContour (  ) 

Definition at line 180 of file Propagation.cxx.

References _interpnumber.

00181 {
00182         _interpnumber = 100;
00183 }

PropContour::~PropContour (  ) 

Definition at line 186 of file Propagation.cxx.

References ResetKeyContours(), and ResetPlaneVector().

00187 {
00188         ResetPlaneVector();
00189         ResetKeyContours();
00190 }

Here is the call graph for this function:

Member Function Documentation

vtkImageData * PropContour::CalculeSplinePropagation (  ) 

Definition at line 1141 of file Propagation.cxx.

References _KeyContourSizes, _KeyContourX, _KeyContourY, _KeyContourZ, and method_Spline().

Referenced by ContourPropagation::CalculeSplinePropagation(), ContourPropagation::GetContour(), and ContourPropagation::GetKeyContours().

01142 {
01143         if(_KeyContourSizes.size() <= 0)
01144         {
01145                 printf("\n There would be at last 1 contour");
01146                 return NULL;
01147         }
01148         if(_KeyContourSizes.size() == 1)
01149         {
01150                 return NULL;
01151         }
01152         if(_KeyContourSizes.size() >= 2)
01153         {
01154                 return method_Spline(&_KeyContourX,&_KeyContourY,&_KeyContourZ,&_KeyContourSizes);
01155         }
01156         return NULL;
01157 }

Here is the call graph for this function:

Here is the caller graph for this function:

int PropContour::FindIdWithZ ( double  z  ) 

Definition at line 1203 of file Propagation.cxx.

References _planevector.

Referenced by ContourPropagation::FindIdWithZ().

01204 {
01205         int result_ID=0;
01206         int k,size=_planevector.size();
01207         double dist,minDist=99999999;
01208         for ( k=0 ; k<size ; k++)
01209         {
01210                 dist=fabs( z - _planevector[k].get_z(0) );
01211                 if (dist<minDist)
01212                 {
01213                         minDist=dist;
01214                         result_ID = k;
01215                 }
01216         }// for i
01217         return result_ID;
01218 }

Here is the caller graph for this function:

void PropContour::GetIdContour ( int  id,
std::vector< double > *  vecX,
std::vector< double > *  vecY,
std::vector< double > *  vecZ 
)

Definition at line 1221 of file Propagation.cxx.

References _planevector.

Referenced by ContourPropagation::GetContour(), ContourPropagation::GetControlPoints(), and ContourPropagation::GetInitialControlPoints().

01222 {
01223         int i;
01224         vecX->clear();
01225         vecY->clear();
01226         vecZ->clear();
01227         //int sizeplane = _planevector[id].getsize_x();
01228         double tempx;
01229         for(i=0; i<_planevector[id].getsize_x(); i++)
01230         {
01231                 vecX->push_back( _planevector[id].get_x(i) );
01232                 tempx = _planevector[id].get_x(i);
01233                 vecY->push_back( _planevector[id].get_y(i) );
01234                 vecZ->push_back( _planevector[id].get_z(i) );
01235         }
01236 }

Here is the caller graph for this function:

void PropContour::GetKeyContours ( std::vector< double > *  KeyX,
std::vector< double > *  KeyY,
std::vector< double > *  KeyZ,
std::vector< int > *  KeyS 
)

Definition at line 1159 of file Propagation.cxx.

References _KeyContourSizes, _KeyContourX, _KeyContourY, and _KeyContourZ.

Referenced by ContourPropagation::appendContour(), ContourPropagation::CalculeSplinePropagation(), and ContourPropagation::GetKeyContours().

01160 {
01161         int i;
01162         KeyX->clear();
01163         KeyY->clear();
01164         KeyZ->clear();
01165         KeyS->clear();
01166 
01167         for(i=0; i<(int)(_KeyContourSizes.size()); i++)
01168         {
01169                 KeyS->push_back( _KeyContourSizes[i] );
01170         }
01171         for(i=0; i<(int)(_KeyContourX.size()); i++)
01172         {
01173                 KeyX->push_back( _KeyContourX[i] );
01174                 KeyY->push_back( _KeyContourY[i] );
01175                 KeyZ->push_back( _KeyContourZ[i] );
01176         }
01177 }

Here is the caller graph for this function:

void PropContour::GetPropagatedContours ( std::vector< Vector > *  planevec  ) 

Definition at line 1179 of file Propagation.cxx.

References _planevector, Vector::set_plane(), Vector::set_x(), Vector::set_y(), and Vector::set_z().

01180 {
01181         int i,j;
01182         planevec->clear();
01183         for(i=0; i<(int)(_planevector.size()); i++)
01184         {
01185                 Vector *temp = new Vector();
01186                 temp->set_plane( _planevector[i].get_plane() );
01187                 for(j=0; j<_planevector[i].getsize_x(); j++)
01188                 {
01189                         temp->set_x( _planevector[i].get_x(j) );
01190                         temp->set_y( _planevector[i].get_y(j) );
01191                         temp->set_z( _planevector[i].get_z(j) );
01192                 }
01193                 planevec->push_back(*temp);
01194                 delete temp;
01195         }
01196 }

Here is the call graph for this function:

vtkImageData * PropContour::method_Spline ( std::vector< double > *  InX,
std::vector< double > *  InY,
std::vector< double > *  InZ,
std::vector< int > *  Sizes 
) [private]

Definition at line 906 of file Propagation.cxx.

References _interpnumber, _mContourModel, _planevector, manualContourModel::AddPoint(), manualContourModel::DeleteAllPoints(), manualContourModel::GetNumberOfPointsSpline(), manualContourModel::GetSpline_i_Point(), imagedataValue, PreparePointsForSpline(), ResetPlaneVector(), manualContourModel::SetCloseContour(), manualContourModel::SetNumberOfPointsSpline(), and manualContourModel::UpdateSpline().

Referenced by CalculeSplinePropagation().

00907 {
00908         //long interval = wxGetElapsedTime(TRUE); // JPRx
00909 
00910         int i,j,k,sizeX,sizeS,sizeInS;
00911         int numspline;
00912         double x,y,z;
00913 //EED   double spc[3]={1,1,1};
00914         std::vector<double> lstX;
00915         std::vector<double> lstY;
00916         std::vector<double> lstZ;
00917         std::vector<double> tempX;
00918         std::vector<double> tempY;
00919         std::vector<double> tempZ;
00920         std::vector<double> tempS;
00921         _mContourModel = new manualContourModel();
00922         _mContourModel->SetNumberOfPointsSpline(_interpnumber);
00923 
00924         imagedataValue=NULL;
00925 //EED
00926 //      _dimImage[0] = 200;                     // X axis
00927 //      _dimImage[1] = 200;                     // Y axis
00928 //      _dimImage[2] = 200;                     // Z axis
00929 //
00930 //      unsigned short *pValue;
00931 //      imagedataValue = vtkImageData::New();
00932 //      imagedataValue->SetScalarTypeToUnsignedShort();
00933 //      imagedataValue->SetSpacing(spc);
00934 //      imagedataValue->SetDimensions(_dimImage);
00935 //      imagedataValue->SetExtent(0,_dimImage[0]-1,0,_dimImage[1]-1,0,_dimImage[2]-1);
00936 //      imagedataValue->AllocateScalars();
00937 //      imagedataValue->Update();
00938         
00939 //      lstX.clear();
00940 //      lstY.clear();
00941 //      lstZ.clear();
00942 
00943         sizeX = InX->size();
00944         for(i=0; i<sizeX; i++)
00945         {
00946                 lstX.push_back((*InX)[i]);
00947                 lstY.push_back((*InY)[i]);
00948                 lstZ.push_back((*InZ)[i]);
00949         }
00950         
00951         PreparePointsForSpline(&lstX,&lstY,&lstZ,Sizes);
00952         /*int sizetemp = lstX.size();
00953         printf("\nJSTG-PropContour::method_Spline");
00954         for(i=0; i<sizetemp; i++)
00955         {
00956                 printf("\nlst: Z = %f, X = %f, Y = %f, ",lstZ[i],lstX[i],lstY[i]);
00957         }*/
00958 
00959         sizeS = Sizes->size();
00960         int cont = 0;
00961         for(i=0; i<sizeS; i++)
00962         {
00963                 _mContourModel->DeleteAllPoints();
00964                 _mContourModel->SetCloseContour(true);
00965                 sizeInS = (*Sizes)[i];
00966                 for(j=0; j<sizeInS; j++)
00967                 {
00968                         _mContourModel->AddPoint(lstX[cont],lstY[cont],lstZ[cont]);
00969                         cont ++;
00970                 }
00971                 _mContourModel->UpdateSpline();
00972                 numspline = _mContourModel->GetNumberOfPointsSpline();
00973                 for(k=0; k<numspline; k++)
00974                 {
00975                         _mContourModel->GetSpline_i_Point(k,&x,&y,&z);
00976 //EED                   pValue = (unsigned short *)imagedataValue->GetScalarPointer(x,y,z);
00977 //                      *pValue = 128;
00978                         tempX.push_back(x);
00979                         tempY.push_back(y);
00980                         tempZ.push_back(z);
00981                 }
00982         }
00983         
00984         int tam = numspline;
00985         std::vector<Vector>::iterator it;
00986         
00987         ResetPlaneVector();
00988 
00989         for(i=0; i<numspline; i++)
00990         {
00991                 Vector *vec = new Vector();
00992                 _planevector.push_back(*vec);
00993         }// for i
00994 
00995         for(j=0; j<tam; j++)
00996         {
00997                 _mContourModel->DeleteAllPoints();
00998                 _mContourModel->SetCloseContour(false);
00999                 cont = 0;
01000                 for(i=0; i<sizeS; i++)
01001                 {
01002                         //double hh=tempZ[cont+j]; // JPRx
01003                         _mContourModel->AddPoint(tempX[cont+j],tempY[cont+j],tempZ[cont+j]);
01004                         cont = cont + tam;
01005                 } // for i
01006                 _mContourModel->UpdateSpline();
01007                 numspline = _mContourModel->GetNumberOfPointsSpline();
01008                 for(k=0; k<numspline; k++)
01009                 {
01010 //EED002
01011                         _mContourModel->GetSpline_i_Point(k,&x,&y,&z);
01012                         _planevector[k].set_x(x);
01013                         _planevector[k].set_y(y);
01014                         _planevector[k].set_z(z);
01015                         _planevector[k].set_plane(k);
01016 //EED                   pValue = (unsigned short *)imagedataValue->GetScalarPointer(x,y,z);
01017 //EED                   *pValue = 128;
01018                 } // for k
01019         } // for j
01020 
01021 /*
01022         int tempsize = _planevector.size();
01023         int sizexx;
01024         for(i=0; i<tempsize; i++)
01025         {
01026                 sizexx = _planevector[i].getsize_x();
01027         }
01028 */
01029 /*
01030         interval = wxGetElapsedTime(FALSE);
01031         int zplanes = abs(tempZ[0]-tempZ[tempZ.size()-1]);
01032         long interPlane = interval/zplanes;
01033         int pointsSize = 0;
01034         for(i=0; i<sizeS; i++)
01035         {
01036                 pointsSize = pointsSize + (*Sizes)[i]; 
01037         }
01038         for(i=0; i<pointsSize; i++)
01039         {
01040                  pValue = (unsigned short *)imagedataValue->GetScalarPointer( (int)(*InX)[i] , (int)(*InY)[i] ,(int)(*InZ)[i]);
01041                 *pValue=255;
01042         }
01043 
01044         printf("\n\n JSTG - PropContour::method_Spline ------------------------");
01045         printf("\n TIME FOR: IMAGE 3D WITHOUT THE CONTROL POINTS.... %d (ms)",interval);
01046         //printf("\n TIME FOR: IMAGE 3D WITH THE CONTROL POINTS....... %lld (ms)",intervalPC);
01047         printf("\n TIME AVERAGE FOR: EVERY PLANE.................... %d (ms)",interPlane);
01048         printf("\n NUMBER OF PLANES................................. %d",zplanes);
01049         printf("\n TOTAL NUMBER OF CONTROL POINTS................... %d",pointsSize);
01050         printf("\n ------------------------------------------------------------");
01051 */
01052         return imagedataValue;
01053 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PropContour::PreparePointsForSpline ( std::vector< double > *  InX,
std::vector< double > *  InY,
std::vector< double > *  InZ,
std::vector< int > *  Sizes 
) [private]

Definition at line 838 of file Propagation.cxx.

References VectorDirection(), and VectorOrder().

Referenced by method_Spline().

00840 {
00841         int sizeS = Sizes->size();
00842         //int sizeV = InX->size(); // JPRx
00843         int i,j,mem,posinic,dir,cont;
00844         double leX;
00845 
00846         std::vector<double> tempX;
00847         std::vector<double> tempY;
00848         std::vector<double> tempZ;
00849         std::vector<double> lstX;
00850         std::vector<double> lstY;
00851         std::vector<double> lstZ;
00852         
00853         lstX.clear();
00854         lstY.clear();
00855         lstZ.clear();
00856 
00857         mem = 0;
00858         cont = 0;
00859         for(i=0; i<sizeS; i++)
00860         {
00861                 leX=1000;
00862                 tempX.clear();
00863                 tempY.clear();
00864                 tempZ.clear();
00865                 for(j=0; j<(*Sizes)[i]; j++)
00866                 {
00867                         tempX.push_back((*InX)[j+mem]);
00868                         tempY.push_back((*InY)[j+mem]);
00869                         tempZ.push_back((*InZ)[j+mem]);
00870                         if( (*InX)[j] < leX )
00871                         {
00872                                 posinic = j;
00873                                 leX = (*InX)[j];
00874                         }
00875                 }
00876                 mem = mem + (*Sizes)[i];
00877                 dir = VectorDirection(&tempX,&tempY,&tempZ);
00878                 VectorOrder(dir,posinic,&tempX,&tempY,&tempZ);
00879 
00880                 for(j=0; j<(*Sizes)[i]; j++)
00881                 {
00882                         lstX.push_back(tempX[j]);
00883                         lstY.push_back(tempY[j]);
00884                         lstZ.push_back((*InZ)[j+cont]);
00885                 }
00886                 cont = cont + (*Sizes)[i];
00887         }
00888 
00889 //Fill the Finally lst in X,Y,Z ---------------
00890         int sizetemp = lstX.size();
00891         //printf("\nJSTG-PropContour::PreparePointsForSpline");
00892         InX->clear();
00893         InY->clear();
00894         InZ->clear();
00895         for(i=0; i<sizetemp; i++)
00896         {
00897                 //printf("\nlst: Z = %f, X = %f, Y = %f, ",lstZ[i],lstX[i],lstY[i]);
00898                 InX->push_back(lstX[i]);
00899                 InY->push_back(lstY[i]);
00900                 InZ->push_back(lstZ[i]);
00901         }
00902 
00903         
00904 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PropContour::ReadKeyContour ( FILE *  fd  ) 

Definition at line 715 of file Propagation.cxx.

References SetKeyContours().

Referenced by ContourPropagation::appendContour().

00716 {
00717         char firstline[30];
00718         int     size;
00719         double x,y;             
00720         int z;
00721         std::vector<double> tempX;
00722         std::vector<double> tempY;
00723         std::vector<double> tempZ;
00724         tempX.clear();
00725         tempY.clear();
00726         tempZ.clear();
00727         while(!feof(fd))
00728         {
00729                 //fscanf(fd," %s %d",&firstline,&size); // JPRx
00730                 fscanf(fd," %s %d",firstline,&size);
00731                 for(int i=0; i<size; i++)
00732                 {
00733                         fscanf(fd,"%lf %lf %d",&x,&y,&z);
00734                         tempX.push_back(x);
00735                         tempY.push_back(y);
00736                         tempZ.push_back(z);
00737                 }
00738                 SetKeyContours(&tempX,&tempY,&tempZ);
00739                 tempX.clear();
00740                 tempY.clear();
00741                 tempZ.clear();
00742         }
00743 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PropContour::ResetKeyContours (  ) 

Definition at line 1070 of file Propagation.cxx.

References _KeyContourSizes, _KeyContourX, _KeyContourY, and _KeyContourZ.

Referenced by ContourPropagation::appendContour(), ContourPropagation::resetAppend(), and ~PropContour().

01071 {
01072         _KeyContourSizes.clear();
01073         _KeyContourX.clear();
01074         _KeyContourY.clear();
01075         _KeyContourZ.clear();
01076 }

Here is the caller graph for this function:

void PropContour::ResetPlaneVector (  )  [private]

Definition at line 1056 of file Propagation.cxx.

References _planevector.

Referenced by method_Spline(), and ~PropContour().

01057 {
01058 //      Vector *vec;
01059 //      int ii,iiSize = _planevector.size();
01060 //      for (ii=0 ; ii<iiSize ; ii++) 
01061 //      {
01062 //              vec = &(_planevector[ii]);
01063 //              delete vec;
01064 //      }
01065         _planevector.clear();
01066 }

Here is the caller graph for this function:

void PropContour::SetInterpNumber ( int  val  ) 

Definition at line 1198 of file Propagation.cxx.

References _interpnumber.

Referenced by ContourPropagation::setInterpolationNumber().

01199 {
01200         _interpnumber = val;
01201 }

Here is the caller graph for this function:

void PropContour::SetKeyContours ( std::vector< double > *  InX,
std::vector< double > *  InY,
std::vector< double > *  InZ 
)

Definition at line 1078 of file Propagation.cxx.

References _KeyContourSizes, _KeyContourX, _KeyContourY, and _KeyContourZ.

Referenced by ContourPropagation::appendContour(), ContourPropagation::GetContour(), and ReadKeyContour().

01079 {
01080 
01081         int idKeyContour                = 0;
01082         int idKeyContourSizes   = 0;
01083         int tmpIdKeyContSizes   = 0;
01084         bool okFind                             = false;
01085         int i;
01086         int sizeKeyContour,Z=(int)(*InZ)[0];
01087         sizeKeyContour = _KeyContourZ.size();
01088         for (i=0; i<sizeKeyContour; i++)
01089         { 
01090                 if (i>0)
01091                 {
01092                         if ( (_KeyContourZ[i-1]<Z) && (_KeyContourZ[i]>=Z) )
01093                         {
01094                                 idKeyContour            = i;
01095                                 idKeyContourSizes       = tmpIdKeyContSizes;
01096                                 okFind=true;
01097                                 i=sizeKeyContour;
01098                         }
01099                         if ( (i<sizeKeyContour) && (_KeyContourZ[i-1] != _KeyContourZ[i]) )
01100                         {
01101                                 tmpIdKeyContSizes++;
01102                         }
01103                 } else {
01104                         if  (_KeyContourZ[0]>Z) 
01105                         {
01106                                 idKeyContour            = 0;
01107                                 idKeyContourSizes       = 0;
01108                                 okFind                          = true;
01109                                 i                                       = sizeKeyContour;
01110                         }
01111                 } // if >O
01112         } // for 
01113 
01114         if (okFind==false)
01115         {
01116                 idKeyContour            = _KeyContourX.size();
01117                 idKeyContourSizes       = _KeyContourSizes.size();
01118                 okFind=true;
01119         }
01120 
01121         _KeyContourSizes.insert( _KeyContourSizes.begin() + idKeyContourSizes , InX->size() );
01122         for(i=0; i<(int)(InX->size()); i++)
01123         {
01124                 _KeyContourX.insert( _KeyContourX.begin() + idKeyContour, (*InX)[i] );
01125                 _KeyContourY.insert( _KeyContourY.begin() + idKeyContour, (*InY)[i] );
01126                 _KeyContourZ.insert( _KeyContourZ.begin() + idKeyContour, (*InZ)[i] );
01127         }
01128 
01129 
01130 //EED
01131 //      _KeyContourSizes.push_back( InX->size() );
01132 //      for(i=0; i<InX->size(); i++)
01133 //      {
01134 //              _KeyContourX.push_back( (*InX)[i] );
01135 //              _KeyContourY.push_back( (*InY)[i] );
01136 //              _KeyContourZ.push_back( (*InZ)[i] );
01137 //      }
01138 
01139 }

Here is the caller graph for this function:

int PropContour::VectorDirection ( std::vector< double > *  InX,
std::vector< double > *  InY,
std::vector< double > *  InZ 
)

Definition at line 745 of file Propagation.cxx.

Referenced by PreparePointsForSpline().

00746 {
00747         int dir,i;
00748         double SumX = 0,SumY = 0;
00749         double ax,ay,bx,by,axb;
00750         int size = InX->size();
00751         for(i=0; i<size; i++)
00752         {
00753                 SumX = SumX + (*InX)[i];
00754                 SumY = SumY + (*InY)[i];
00755         }
00756         SumX = SumX/size;               //Mass Center: X coord
00757         SumY = SumY/size;               //Mass Center: Y coord
00758         
00759         int positive = 0;
00760         int negative = 0;
00761         for(i=0; i<size; i++)
00762         {
00763                 ax = (*InX)[i]-SumX;
00764                 ay = (*InY)[i]-SumY;
00765                 bx = (*InX)[(i+1)%size]-SumX;
00766                 by = (*InY)[(i+1)%size]-SumY;
00767                 axb = (ax*by) - (bx*ay);
00768                 if(axb > 0)
00769                 {
00770                         positive++;
00771                 }
00772                 if(axb < 0)
00773                 {
00774                         negative++;
00775                 }
00776         }
00777         if(positive >= negative)
00778         {
00779                 dir = 1;
00780         }
00781         else
00782         {
00783                 dir = -1;
00784         }
00785 
00786         return dir;
00787 }

Here is the caller graph for this function:

void PropContour::VectorOrder ( int  dir,
int  posinic,
std::vector< double > *  InX,
std::vector< double > *  InY,
std::vector< double > *  InZ 
)

Definition at line 789 of file Propagation.cxx.

Referenced by PreparePointsForSpline().

00790 {
00791         int size = InX->size();
00792         int i;
00793         std::vector<double> tempX;
00794         std::vector<double> tempY;
00795         std::vector<double> tempZ;
00796         
00797         tempX.clear();
00798         tempY.clear();
00799         tempZ.clear();
00800 
00801         for(i=0; i<size; i++)
00802         {
00803                 if(dir == 1)
00804                 {
00805                         tempX.push_back((*InX)[posini]);
00806                         tempY.push_back((*InY)[posini]);
00807                         tempZ.push_back((*InZ)[posini]);
00808                         posini++;
00809                         if(posini == size)
00810                         {
00811                                 posini = 0;
00812                         }
00813                 }
00814                 if(dir == -1)
00815                 {
00816                         tempX.push_back((*InX)[posini]);
00817                         tempY.push_back((*InY)[posini]);
00818                         tempZ.push_back((*InZ)[posini]);
00819                         posini--;
00820                         if(posini < 0)
00821                         {
00822                                 posini = size-1;
00823                         }
00824                 }
00825         }
00826         InX->clear();
00827         InY->clear();
00828         InZ->clear();
00829         for(i=0; i<size; i++)
00830         {
00831                 InX->push_back(tempX[i]);
00832                 InY->push_back(tempY[i]);
00833                 InZ->push_back(tempZ[i]);
00834         }
00835 
00836 }

Here is the caller graph for this function:

Member Data Documentation

int PropContour::_dimImage[3] [private]

Definition at line 91 of file Propagation.h.

int PropContour::_interpnumber [private]

Definition at line 89 of file Propagation.h.

Referenced by method_Spline(), PropContour(), and SetInterpNumber().

std::vector<int> PropContour::_KeyContourSizes [private]

Definition at line 98 of file Propagation.h.

Referenced by CalculeSplinePropagation(), GetKeyContours(), ResetKeyContours(), and SetKeyContours().

std::vector<double> PropContour::_KeyContourX [private]

Definition at line 95 of file Propagation.h.

Referenced by CalculeSplinePropagation(), GetKeyContours(), ResetKeyContours(), and SetKeyContours().

std::vector<double> PropContour::_KeyContourY [private]

Definition at line 96 of file Propagation.h.

Referenced by CalculeSplinePropagation(), GetKeyContours(), ResetKeyContours(), and SetKeyContours().

std::vector<double> PropContour::_KeyContourZ [private]

Definition at line 97 of file Propagation.h.

Referenced by CalculeSplinePropagation(), GetKeyContours(), ResetKeyContours(), and SetKeyContours().

manualContourModel* PropContour::_mContourModel [private]

Definition at line 93 of file Propagation.h.

Referenced by method_Spline().

std::vector<Vector> PropContour::_planevector [private]

Definition at line 100 of file Propagation.h.

Referenced by FindIdWithZ(), GetIdContour(), GetPropagatedContours(), method_Spline(), and ResetPlaneVector().

vtkImageData* PropContour::imagedataValue [private]

Definition at line 92 of file Propagation.h.

Referenced by method_Spline().

The documentation for this class was generated from the following files:
Generated on 18 Mar 2010 for creaMaracasVisu_lib by  doxygen 1.6.1