SeansVesselReg.hxx

Go to the documentation of this file.

#ifndef SeansVesselSegmentation_hxx
#define SeansVesselSegmentation_hxx

#include "cxResourceExport.h"

#include "cxForwardDeclarations.h"
#include "vtkForwardDeclarations.h"
#include "cxTransform3D.h"
#include "vtkSmartPointer.h"

namespace cx
{
class cxResource_EXPORT SeansVesselReg
{
public:
        struct cxResource_EXPORT Context
        {
                vtkCellLocatorPtr mTargetPointLocator; 
                vtkPolyDataPtr mTargetPoints; 
                vtkPointsPtr mSourcePoints; 

                vtkPolyDataPtr getMovingPoints(); 
                vtkPolyDataPtr getFixedPoints(); 

                vtkPointsPtr mSortedSourcePoints; 
                vtkPointsPtr mSortedTargetPoints; 

                vtkGeneralTransformPtr mConcatenation; 
                vtkAbstractTransformPtr mTransform; 
                double mMetric; 

                double mLtsRatio; 

                //---------------------------------------------------------------------------
                //TODO non-linear needs to handle this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                bool mInvertedTransform; 
                //---------------------------------------------------------------------------
        };
        typedef boost::shared_ptr<Context> ContextPtr;

        SeansVesselReg();
//      SeansVesselReg(int lts_ratio, double stop_delta, double lambda, double sigma, bool lin_flag, int sample,
//              int single_point_thre, bool verbose);
        ~SeansVesselReg();

        bool execute(DataPtr source, DataPtr target, QString logPath);
        Transform3D getLinearResult(ContextPtr context=ContextPtr());
        double getResultMetric(ContextPtr context=ContextPtr());
        double getResultLtsRatio(ContextPtr context=ContextPtr());
        Transform3D getNonLinearTransform();
        void checkQuality(Transform3D linearTransform);
//      ImagePtr loadMinc(char* source_file);
        void setDebugOutput(bool on)
        {
                mt_verbose = on;
        }

        bool mt_auto_lts;
        int mt_ltsRatio;
        double mt_distanceDeltaStopThreshold;
        double mt_lambda;
        double mt_sigma;
        bool mt_doOnlyLinear;
//      bool mt_doStepping;
        int mt_sampleRatio;
        int mt_singlePointThreshold;
        int mt_maximumNumberOfIterations;
        bool mt_verbose;
        double mt_maximumDurationSeconds;

        // debug interface:
        ContextPtr createContext(DataPtr source, DataPtr target);
        void performOneRegistration(ContextPtr context, bool linear);
        void computeDistances(ContextPtr context);
        static vtkPolyDataPtr convertToPolyData(vtkPointsPtr input);

        static vtkPolyDataPtr extractPolyData(ImagePtr image, int p_neighborhoodFilterThreshold,
                double p_BoundingBox[6]);
private:
        Transform3D getLinearTransform(vtkGeneralTransformPtr myConcatenation);

protected:
        bool runAlgorithm(ContextPtr context, vtkGeneralTransformPtr myConcatenation, int largeSteps, double fraction);
        void printOutResults(QString fileNamePrefix, vtkGeneralTransformPtr myConcatenation);
        vtkAbstractTransformPtr linearRegistration(vtkPointsPtr sortedSourcePoints, vtkPointsPtr sortedTargetPoints);
        vtkAbstractTransformPtr nonLinearRegistration(vtkPointsPtr sortedSourcePoints, vtkPointsPtr sortedTargetPoints);
        vtkPolyDataPtr convertToPolyData(DataPtr data);
        vtkPointsPtr transformPoints(vtkPointsPtr input, vtkAbstractTransformPtr transform);
        vtkPointsPtr createSortedPoints(vtkIdListPtr sortedIDList, vtkPointsPtr unsortedPoints, int numPoints);
        vtkPolyDataPtr crop(vtkPolyDataPtr input, vtkPolyDataPtr fixed, double margin);
        ContextPtr linearRefineAllLTS(ContextPtr context);
        void linearRefine(ContextPtr context);
        SeansVesselReg::ContextPtr splitContext(ContextPtr context);

        void print(vtkPointsPtr points);
        void print(vtkPolyDataPtr data);



//      Transform3D mLinearTransformResult;
        ContextPtr mLastRun; 

//      //---------------------------------------------------------------------------
//      //TODO non-linear needs to handle this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//      bool mInvertedTransform; ///< the calculated registration goes from target to source instead of source to target
//      //---------------------------------------------------------------------------
};
}//namespace cx
#endif