axisExtractor02.h

Go to the documentation of this file.

/*=========================================================================

  */

#ifndef __axisExtractor02_h
#define __axisExtractor02_h


#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkPolyData.h"
#include "vtkImageToStructuredPoints.h"
#include "vtkImageEuclideanDistance.h"
#include "vtkExtractVOI.h"
#include "vtkImageThreshold.h"
#include "vtkImageCast.h"
#include "vtkImageSeedConnectivity.h"
#include "vtkImageData.h"
#include "vtkImageReslice.h"
#include "vtkDoubleArray.h"
#include "vtkPointData.h"
#include "vtkImageResample.h"
#include "vtkMath.h"
#include "vtkPolyDataSource.h"
#include "vtkImageConstantPad.h"


#include <stack>
#include <deque>
#include <stdio.h>




class  axisExtractor02 : public vtkPolyDataSource
{
public:
        static axisExtractor02 *New();
        void PrintSelf(ostream& os, vtkIndent indent);

        virtual void SetInput(vtkImageData *input);
        vtkImageData *GetInput();
        vtkPolyData  *GetOutput();

        void SetParam(double value);
        double GetParam();

        void SetParam2(double value);
        double GetParam2();

        void SetParam3(double value);
        double GetParam3();


        void SetMaxant(int value);
        int GetMaxant();

        void SetMinant(int value);
        int GetMinant();

        void SetPoint(double value[3]);
        
        vtkImageData *GetVolumen();

        void distanciaejes(vtkPolyData *eje1,  vtkPolyData *eje2);

        void blanquear(vtkImageData *data );

        void copiar(vtkImageData *data, vtkImageData *data2 );

        

        




        
  
  
protected:  
        axisExtractor02();
        
        ~axisExtractor02() {};

        void Execute();
 
  

private:
        axisExtractor02(const axisExtractor02&);  // Not implemented.

        void operator=(const axisExtractor02&);  // Not implemented.

        void realtoreal(double a[3], double b[3] );

        void realtoreal2(double a[3], double b[3] );

        void realtoindex(double a[3], int b[3] );

        void indextoreal(int a[3], double b[3] );

        void indextoreal(double a[3], double b[3] );

        double distanciaejepunto(double point[3], double point2[3], double point3[3]);

        double proporcioejepunto(double point[3], double point2[3], double point3[3]);

        void searc(int i, int j, int k, vtkImageData *data, vtkImageData *data2, unsigned char label, unsigned long vector[50][4] );

        void searcb(int i, int j, int k, vtkImageData *data, vtkImageData *data2, unsigned char label, unsigned long vector[50][4] );

        unsigned char find_components(vtkImageData *data, vtkImageData *data2, unsigned char label, unsigned long vector[50][4] );

        unsigned char find_componentsb(vtkImageData *data, vtkImageData *data2, unsigned char label, unsigned long vector[50][4] );

        int proporcion(vtkImageData *data );

        bool border(vtkImageData *data, int p1[3] );

        void optim(vtkImageData *data, vtkImageData *data2 );

        void costominimo(vtkImageData *data,  vtkImageData *data2 );

        void costominimo2(vtkImageData *data,  vtkImageData *data3, int p1[3], int p2[3], int p3[3]);

        void invertir(vtkImageData *data );

        void redondear(vtkImageData *data );

        void redondear2(vtkImageData *data );

        void redondear3(vtkImageData *data );

        double distancia(double a[3], double b[3] );

        double distancia(int a[3], int b[3] );

        void blanquear3(vtkImageData *data );

        void blanquear2(vtkImageData *data );

        void cilindro(vtkImageData *data, double vector[3] );

        void modelo(vtkImageData *data, unsigned char cantidad,  unsigned long vector[50][4], int candit[10][3], double radioactual, double minis[10]);

        void comparacion(vtkImageData *data, vtkImageData *data2, unsigned long minis[4]);

        void copiar2(vtkImageData *data, vtkImageData *data2 );

        double angulo(double a[3], double b[3] );

        double angulo(double i1, double j1, double k1, double i2, double j2, double k2 );

        int envolumen(int a[3], vtkImageData *datae );

        int mincandit(int candit[10][3], int cantidad, double puntoanterior[3]);

        int maxareacandit(unsigned long vector[50][4], int cantidad);

        unsigned long totalarea(unsigned long vector[50][4], unsigned long vectorb[50][4], int cantidad, int cantidadb);

        unsigned long conecarea(unsigned long vector[50][4], int cantidad);

        int bruled(int candit[10][3], int cantidad, vtkImageData *data4);

        double correction(int candit[10][3], int cantidad, vtkImageData *data, int indicecorregido[3], double puntocorregido[3], int indiceanterior[3], double radioanterior, int indicepre[3], double radiopre);

        double correction2(int candit[10][3], int cantidad, vtkImageData *data, int indicecorregido[3], double puntocorregido[3], int indiceanterior[3], double radioanterior);

        void avanzar();

        void todo();

        void paso();

        void rama();

        void segmento();

        

        int extprin0[6];
        double espprin[3];
        int extprin[6];
        

                
        
        vtkImageEuclideanDistance *distance;
        vtkExtractVOI *extrac;
        vtkImageSeedConnectivity *connect;
        vtkImageResample *resample;
        

        vtkImageData *data1;
        vtkImageData *data2;
        vtkImageData *data3;
        vtkImageData *data4;
        vtkImageData *data6;
        
                

        int flagg;
        int flagg2;

        vtkPoints *points;
        vtkCellArray *lineas; 
        int buenos;

/*      std::stack< double  >                                           m_Stack0;
        std::stack< double  >                                           m_Stack1;
        std::stack< double  >                                           m_Stack2;
        std::stack< double  >                                           m_Stack3;
        std::stack< double  >                                           m_Stack4;
        std::stack< double  >                                           m_Stack5;
        std::stack< double  >                                           m_Stack6;
        std::stack< double  >                                           m_Stack7;
        std::stack< double  >                                           m_Stack8;
        std::stack< int  >                                              m_Stack;
        std::stack< double  >                                           m_Stackr;
        std::stack< double  >                                           m_Stackra;
        std::stack< double  >                                           m_Stackrp;*/


        std::deque< double  >                                           m_Stack0;
        std::deque< double  >                                           m_Stack1;
        std::deque< double  >                                           m_Stack2;
        std::deque< double  >                                           m_Stack3;
        std::deque< double  >                                           m_Stack4;
        std::deque< double  >                                           m_Stack5;
        std::deque< double  >                                           m_Stack6;
        std::deque< double  >                                           m_Stack7;
        std::deque< double  >                                           m_Stack8;
        std::deque< int  >                                              m_Stack;
        std::deque< double  >                                           m_Stackr;
        std::deque< double  >                                           m_Stackra;
        std::deque< double  >                                           m_Stackrp;



        double puntoanteriorr[3];



        unsigned short max;
        unsigned long cantt;
        double sum;
        double sumc;
        double sums;
        double sumk;
        double kurt;
        double slew;
        double des;
        double prom;
        unsigned short min;

        double kurt1;
        double slew1;


        unsigned short max2;
        unsigned long cant;
        double sumi;
        double sumii;
        double kurt2;
        double slew2;
        double des2;
        double inerciaii;
        double centi;
        unsigned short min2;

        unsigned short max3;
        unsigned long cant2;
        double sumi2;
        double sumii2;
        double kurt3;
        double slew3;
        double des3;
        double inerciaii2;
        double centi2;
        unsigned short min3;

        float tmin, tmax;

        unsigned int hist[2000];

        int maxant;
        int minant;
        double totalMean ;
        double variance, maxVariance, zerothCumuMoment, firstCumuMoment ;
        double variance2, maxVariance2, zerothCumuMoment2, firstCumuMoment2 ;
        double variance3, maxVariance3, zerothCumuMoment3, firstCumuMoment3 ;
        double firstCumuMomentb, firstCumuMomentb2, firstCumuMomentb3 ;

        double kurtt;
        double slewt;
        
        int thresholdPoint, thresholdPoint1, thresholdPoint2;

        double    w[3];
        double    V[3][3];
        int ejemin;

        double    w2[3];
        double    V2[3][3];
        int ejemin2;

        double    wi[3];
        double    Vi[3][3];
        int ejemini;

        double centx, centy, centz;
        double centx2, centy2, centz2;

        double centix, centiy, centiz;

        double    A[3][3];
        double    A2[3][3];
        double    Ai[3][3];

        double    wp[3];
        double    Vp[3][3];
        int ejeminp;

        double    w2p[3];
        double    V2p[3][3];
        int ejemin2p;

        double centxp, centyp, centzp;
        double centx2p, centy2p, centz2p;

        double centixp, centiyp, centizp;
        
        double costo, costop;

        double    Ap[3][3];
        double    A2p[3][3];

        int candit[10][3];

        double minis[10];

        double inerciar, inerciarp, inerciari, inerciary, inerciarz, inerciariy, inerciariz, inerciarpy, inerciarpz;

        double inercia2r, inercia2rp;

        double mejor[3];

        
        

        int visited[10][3];

        double visitedrad[10];

        int frama;
        int fseg;
        double mejordst;

        double mejorrad;

        int mejorcant;

        

        double param;
        double param2;
        double param3;
        double param4;

        FILE *stream;


        
        
        


        
};

#endif