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(); 
                vtkPolyDataPtr getDifferenceLines(); 
 
                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();
 
        bool initialize(DataPtr source, DataPtr target, QString logPath);
        bool isValid() const;
        bool execute();
        bool performOneRegistration();
 
        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;
        }
        vtkPolyDataPtr getDifferenceLines(); 
        void notifyPreRegistrationWarnings();
 
 
        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;
        double margin;
        QString m_logPath;
 
        // debug interface:
        ContextPtr createContext(DataPtr source, DataPtr target);
        void performOneRegistration(ContextPtr context, bool linear);
        void computeDistances(ContextPtr context = ContextPtr());
        static vtkPolyDataPtr convertToPolyData(vtkPointsPtr input);
 
        static vtkPolyDataPtr extractPolyData(ImagePtr image, int p_neighborhoodFilterThreshold,
                double p_BoundingBox[6]);
private:
        Transform3D getLinearTransform(vtkGeneralTransformPtr concatenation);
 
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, QString id);
        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